Name resolution globbing

gcc/rust/Make-lang.in

@@ -134,6 +134,7 @@ GRS_OBJS = \
     rust/rust-toplevel-name-resolver-2.0.o \
     rust/rust-early-name-resolver-2.0.o \
     rust/rust-late-name-resolver-2.0.o \
+	rust/rust-immutable-name-resolution-context.o \
     rust/rust-early-name-resolver.o \
     rust/rust-name-resolver.o \
     rust/rust-ast-resolve.o \

gcc/rust/backend/rust-compile-base.cc

@@ -31,6 +31,7 @@
 #include "rust-type-util.h"
 #include "rust-compile-implitem.h"
 #include "rust-attribute-values.h"
+#include "rust-immutable-name-resolution-context.h"
 
 #include "fold-const.h"
 #include "stringpool.h"

gcc/rust/backend/rust-compile-context.h

@@ -27,6 +27,7 @@
 #include "rust-hir-full.h"
 #include "rust-mangle.h"
 #include "rust-tree.h"
+#include "rust-immutable-name-resolution-context.h"
 
 namespace Rust {
 namespace Compile {

gcc/rust/backend/rust-compile-expr.cc

@@ -2311,11 +2311,23 @@ CompileExpr::generate_closure_function (HIR::ClosureExpr &expr,
   if (is_block_expr)
     {
       auto body_mappings = function_body->get_mappings ();
-      Resolver::Rib *rib = nullptr;
-      bool ok
-	= ctx->get_resolver ()->find_name_rib (body_mappings.get_nodeid (),
-					       &rib);
-      rust_assert (ok);
+      if (flag_name_resolution_2_0)
+	{
+	  auto nr_ctx
+	    = Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
+
+	  auto candidate = nr_ctx.values.to_rib (body_mappings.get_nodeid ());
+
+	  rust_assert (candidate.has_value ());
+	}
+      else
+	{
+	  Resolver::Rib *rib = nullptr;
+	  bool ok
+	    = ctx->get_resolver ()->find_name_rib (body_mappings.get_nodeid (),
+						   &rib);
+	  rust_assert (ok);
+	}
     }
 
   tree enclosing_scope = NULL_TREE;

gcc/rust/backend/rust-compile-item.cc

@@ -19,6 +19,7 @@
 #include "rust-compile-item.h"
 #include "rust-compile-implitem.h"
 #include "rust-compile-extern.h"
+#include "rust-immutable-name-resolution-context.h"
 
 namespace Rust {
 namespace Compile {
@@ -75,32 +76,48 @@ CompileItem::visit (HIR::StaticItem &var)
 void
 CompileItem::visit (HIR::ConstantItem &constant)
 {
-  if (ctx->lookup_const_decl (constant.get_mappings ().get_hirid (),
-			      &reference))
+  auto &mappings = constant.get_mappings ();
+
+  if (ctx->lookup_const_decl (mappings.get_hirid (), &reference))
     return;
 
   // resolve the type
   TyTy::BaseType *resolved_type = nullptr;
+
   bool ok
-    = ctx->get_tyctx ()->lookup_type (constant.get_mappings ().get_hirid (),
-				      &resolved_type);
+    = ctx->get_tyctx ()->lookup_type (mappings.get_hirid (), &resolved_type);
   rust_assert (ok);
 
   // canonical path
-  const Resolver::CanonicalPath *canonical_path = nullptr;
-  ok = ctx->get_mappings ()->lookup_canonical_path (
-    constant.get_mappings ().get_nodeid (), &canonical_path);
-  rust_assert (ok);
+  Resolver::CanonicalPath canonical_path
+    = Resolver::CanonicalPath::create_empty ();
+
+  if (flag_name_resolution_2_0)
+    {
+      auto nr_ctx
+	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
+
+      canonical_path
+	= nr_ctx.values.to_canonical_path (mappings.get_nodeid ()).value ();
+    }
+  else
+    {
+      const Resolver::CanonicalPath *canonical_path_ptr = nullptr;
+      ok = ctx->get_mappings ()->lookup_canonical_path (mappings.get_nodeid (),
+							&canonical_path_ptr);
+      rust_assert (ok);
+      canonical_path = *canonical_path_ptr;
+    }
 
   HIR::Expr *const_value_expr = constant.get_expr ().get ();
   ctx->push_const_context ();
   tree const_expr
-    = compile_constant_item (resolved_type, canonical_path, const_value_expr,
+    = compile_constant_item (resolved_type, &canonical_path, const_value_expr,
 			     constant.get_locus ());
   ctx->pop_const_context ();
 
   ctx->push_const (const_expr);
-  ctx->insert_const_decl (constant.get_mappings ().get_hirid (), const_expr);
+  ctx->insert_const_decl (mappings.get_hirid (), const_expr);
   reference = const_expr;
 }
 
@@ -149,12 +166,30 @@ CompileItem::visit (HIR::Function &function)
 	}
     }
 
-  const Resolver::CanonicalPath *canonical_path = nullptr;
-  bool ok = ctx->get_mappings ()->lookup_canonical_path (
-    function.get_mappings ().get_nodeid (), &canonical_path);
-  rust_assert (ok);
+  Resolver::CanonicalPath canonical_path
+    = Resolver::CanonicalPath::create_empty ();
+
+  if (flag_name_resolution_2_0)
+    {
+      auto nr_ctx
+	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
+
+      auto path = nr_ctx.values.to_canonical_path (
+	function.get_mappings ().get_nodeid ());
+
+      canonical_path = path.value ();
+    }
+  else
+    {
+      const Resolver::CanonicalPath *path = nullptr;
+      bool ok = ctx->get_mappings ()->lookup_canonical_path (
+	function.get_mappings ().get_nodeid (), &path);
+      rust_assert (ok);
+
+      canonical_path = *path;
+    }
 
-  const std::string asm_name = ctx->mangle_item (fntype, *canonical_path);
+  const std::string asm_name = ctx->mangle_item (fntype, canonical_path);
 
   // items can be forward compiled which means we may not need to invoke this
   // code. We might also have already compiled this generic function as well.
@@ -181,7 +216,7 @@ CompileItem::visit (HIR::Function &function)
 			function.get_function_params (),
 			function.get_qualifiers (), function.get_visibility (),
 			function.get_outer_attrs (), function.get_locus (),
-			function.get_definition ().get (), canonical_path,
+			function.get_definition ().get (), &canonical_path,
 			fntype);
   reference = address_expression (fndecl, ref_locus);
 

gcc/rust/backend/rust-compile-resolve-path.cc

@@ -17,14 +17,17 @@
 // <http://www.gnu.org/licenses/>.
 
 #include "rust-compile-resolve-path.h"
+#include "options.h"
 #include "rust-compile-intrinsic.h"
 #include "rust-compile-item.h"
 #include "rust-compile-implitem.h"
 #include "rust-compile-expr.h"
+#include "rust-hir-map.h"
 #include "rust-hir-trait-resolve.h"
 #include "rust-hir-path-probe.h"
 #include "rust-compile-extern.h"
 #include "rust-constexpr.h"
+#include "rust-tyty.h"
 
 namespace Rust {
 namespace Compile {
@@ -43,6 +46,50 @@ ResolvePathRef::visit (HIR::PathInExpression &expr)
 		      expr.get_mappings (), expr.get_locus (), false);
 }
 
+tree
+ResolvePathRef::attempt_constructor_expression_lookup (
+  TyTy::BaseType *lookup, Context *ctx, const Analysis::NodeMapping &mappings,
+  location_t expr_locus)
+{
+  // it might be an enum data-less enum variant
+  if (lookup->get_kind () != TyTy::TypeKind::ADT)
+    return error_mark_node;
+
+  TyTy::ADTType *adt = static_cast<TyTy::ADTType *> (lookup);
+  if (adt->is_unit ())
+    return unit_expression (ctx, expr_locus);
+
+  if (!adt->is_enum ())
+    return error_mark_node;
+
+  HirId variant_id;
+  if (!ctx->get_tyctx ()->lookup_variant_definition (mappings.get_hirid (),
+						     &variant_id))
+    return error_mark_node;
+
+  int union_disriminator = -1;
+  TyTy::VariantDef *variant = nullptr;
+  if (!adt->lookup_variant_by_id (variant_id, &variant, &union_disriminator))
+    return error_mark_node;
+
+  // this can only be for discriminant variants the others are built up
+  // using call-expr or struct-init
+  rust_assert (variant->get_variant_type ()
+	       == TyTy::VariantDef::VariantType::NUM);
+
+  // we need the actual gcc type
+  tree compiled_adt_type = TyTyResolveCompile::compile (ctx, adt);
+
+  // make the ctor for the union
+  HIR::Expr *discrim_expr = variant->get_discriminant ();
+  tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
+  tree folded_discrim_expr = fold_expr (discrim_expr_node);
+  tree qualifier = folded_discrim_expr;
+
+  return Backend::constructor_expression (compiled_adt_type, true, {qualifier},
+					  union_disriminator, expr_locus);
+}
+
 tree
 ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
 			 const Analysis::NodeMapping &mappings,
@@ -53,52 +100,29 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
   rust_assert (ok);
 
   // need to look up the reference for this identifier
+
+  // this can fail because it might be a Constructor for something
+  // in that case the caller should attempt ResolvePathType::Compile
   NodeId ref_node_id = UNKNOWN_NODEID;
-  if (!ctx->get_resolver ()->lookup_resolved_name (mappings.get_nodeid (),
-						   &ref_node_id))
+  if (flag_name_resolution_2_0)
+    {
+      auto nr_ctx
+	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
+
+      auto resolved = nr_ctx.lookup (mappings.get_nodeid ());
+
+      if (!resolved)
+	return attempt_constructor_expression_lookup (lookup, ctx, mappings,
+						      expr_locus);
+
+      ref_node_id = *resolved;
+    }
+  else
     {
-      // this can fail because it might be a Constructor for something
-      // in that case the caller should attempt ResolvePathType::Compile
-
-      // it might be an enum data-less enum variant
-      if (lookup->get_kind () != TyTy::TypeKind::ADT)
-	return error_mark_node;
-
-      TyTy::ADTType *adt = static_cast<TyTy::ADTType *> (lookup);
-      if (adt->is_unit ())
-	return unit_expression (ctx, expr_locus);
-
-      if (!adt->is_enum ())
-	return error_mark_node;
-
-      HirId variant_id;
-      if (!ctx->get_tyctx ()->lookup_variant_definition (mappings.get_hirid (),
-							 &variant_id))
-	return error_mark_node;
-
-      int union_disriminator = -1;
-      TyTy::VariantDef *variant = nullptr;
-      if (!adt->lookup_variant_by_id (variant_id, &variant,
-				      &union_disriminator))
-	return error_mark_node;
-
-      // this can only be for discriminant variants the others are built up
-      // using call-expr or struct-init
-      rust_assert (variant->get_variant_type ()
-		   == TyTy::VariantDef::VariantType::NUM);
-
-      // we need the actual gcc type
-      tree compiled_adt_type = TyTyResolveCompile::compile (ctx, adt);
-
-      // make the ctor for the union
-      HIR::Expr *discrim_expr = variant->get_discriminant ();
-      tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
-      tree folded_discrim_expr = fold_expr (discrim_expr_node);
-      tree qualifier = folded_discrim_expr;
-
-      return Backend::constructor_expression (compiled_adt_type, true,
-					      {qualifier}, union_disriminator,
-					      expr_locus);
+      if (!ctx->get_resolver ()->lookup_resolved_name (mappings.get_nodeid (),
+						       &ref_node_id))
+	return attempt_constructor_expression_lookup (lookup, ctx, mappings,
+						      expr_locus);
     }
 
   HirId ref;

gcc/rust/backend/rust-compile-resolve-path.h

@@ -66,6 +66,12 @@ class ResolvePathRef : public HIRCompileBase, public HIR::HIRPatternVisitor
 		bool is_qualified_path);
 
   tree resolved;
+
+private:
+  tree
+  attempt_constructor_expression_lookup (TyTy::BaseType *lookup, Context *ctx,
+					 const Analysis::NodeMapping &mappings,
+					 location_t expr_locus);
 };
 
 } // namespace Compile

gcc/rust/checks/lints/rust-lint-marklive.cc

@@ -20,8 +20,10 @@
 // from live codes are live, and everything else is dead.
 
 #include "rust-lint-marklive.h"
+#include "options.h"
 #include "rust-hir-full.h"
 #include "rust-name-resolver.h"
+#include "rust-immutable-name-resolution-context.h"
 
 namespace Rust {
 namespace Analysis {
@@ -270,12 +272,25 @@ MarkLive::mark_hir_id (HirId id)
 void
 MarkLive::find_ref_node_id (NodeId ast_node_id, NodeId &ref_node_id)
 {
-  if (!resolver->lookup_resolved_name (ast_node_id, &ref_node_id))
+  if (flag_name_resolution_2_0)
     {
-      if (!resolver->lookup_resolved_type (ast_node_id, &ref_node_id))
+      auto nr_ctx
+	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
+
+      nr_ctx.lookup (ast_node_id).map ([&ref_node_id] (NodeId resolved) {
+	ref_node_id = resolved;
+      });
+    }
+  else
+    {
+      if (!resolver->lookup_resolved_name (ast_node_id, &ref_node_id))
 	{
-	  bool ok = resolver->lookup_resolved_misc (ast_node_id, &ref_node_id);
-	  rust_assert (ok);
+	  if (!resolver->lookup_resolved_type (ast_node_id, &ref_node_id))
+	    {
+	      bool ok
+		= resolver->lookup_resolved_misc (ast_node_id, &ref_node_id);
+	      rust_assert (ok);
+	    }
 	}
     }
 }