nr2.0: Separate out canonical path handling

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

@@ -687,11 +687,6 @@ HIRCompileBase::compile_function (
     }
   std::string asm_name = fn_name;
 
-  auto &mappings = Analysis::Mappings::get ();
-
-  if (flag_name_resolution_2_0)
-    ir_symbol_name = mappings.get_current_crate_name () + "::" + ir_symbol_name;
-
   unsigned int flags = 0;
   tree fndecl = Backend::function (compiled_fn_type, ir_symbol_name,
 				   "" /* asm_name */, flags, locus);

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

@@ -33,8 +33,8 @@ CompileTraitItem::visit (HIR::TraitItemConst &constant)
       auto &nr_ctx
 	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
 
-      canonical_path = nr_ctx.values.to_canonical_path (
-	constant.get_mappings ().get_nodeid ());
+      canonical_path
+	= nr_ctx.to_canonical_path (constant.get_mappings ().get_nodeid ());
     }
   else
     {
@@ -103,7 +103,7 @@ CompileTraitItem::visit (HIR::TraitItemFunc &func)
 	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
 
       canonical_path
-	= nr_ctx.values.to_canonical_path (func.get_mappings ().get_nodeid ());
+	= nr_ctx.to_canonical_path (func.get_mappings ().get_nodeid ());
     }
   else
     {

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

@@ -58,7 +58,7 @@ CompileItem::visit (HIR::StaticItem &var)
 	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
 
       canonical_path
-	= nr_ctx.values.to_canonical_path (var.get_mappings ().get_nodeid ());
+	= nr_ctx.to_canonical_path (var.get_mappings ().get_nodeid ());
     }
   else
     {
@@ -124,8 +124,7 @@ CompileItem::visit (HIR::ConstantItem &constant)
       auto &nr_ctx
 	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
 
-      canonical_path
-	= nr_ctx.values.to_canonical_path (mappings.get_nodeid ()).value ();
+      canonical_path = nr_ctx.to_canonical_path (mappings.get_nodeid ());
     }
   else
     {
@@ -218,10 +217,8 @@ CompileItem::visit (HIR::Function &function)
       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 ();
+      canonical_path
+	= nr_ctx.to_canonical_path (function.get_mappings ().get_nodeid ());
     }
   else
     {

gcc/rust/resolve/rust-default-resolver.cc

@@ -24,6 +24,21 @@
 namespace Rust {
 namespace Resolver2_0 {
 
+void
+DefaultResolver::visit (AST::Crate &crate)
+{
+  auto inner_fn = [this, &crate] () { AST::DefaultASTVisitor::visit (crate); };
+
+  auto &mappings = Analysis::Mappings::get ();
+
+  auto crate_num = mappings.lookup_crate_num (crate.get_node_id ());
+  rust_assert (crate_num.has_value ());
+  auto crate_name = mappings.get_crate_name (*crate_num);
+  rust_assert (crate_name.has_value ());
+
+  ctx.canonical_ctx.scope (crate.get_node_id (), *crate_name, inner_fn);
+}
+
 void
 DefaultResolver::visit (AST::BlockExpr &expr)
 {
@@ -38,19 +53,32 @@ DefaultResolver::visit (AST::BlockExpr &expr)
 void
 DefaultResolver::visit (AST::Module &module)
 {
-  auto item_fn = [this, &module] () { AST::DefaultASTVisitor::visit (module); };
+  auto item_fn_1
+    = [this, &module] () { AST::DefaultASTVisitor::visit (module); };
 
-  ctx.scoped (Rib::Kind::Module, module.get_node_id (), item_fn,
+  auto item_fn_2 = [this, &module, &item_fn_1] () {
+    ctx.canonical_ctx.scope (module.get_node_id (), module.get_name (),
+			     std::move (item_fn_1));
+  };
+
+  ctx.scoped (Rib::Kind::Module, module.get_node_id (), item_fn_2,
 	      module.get_name ());
 }
 
 void
 DefaultResolver::visit (AST::Function &function)
 {
-  auto def_fn
+  auto def_fn_1
     = [this, &function] () { AST::DefaultASTVisitor::visit (function); };
 
-  ctx.scoped (Rib::Kind::Function, function.get_node_id (), def_fn);
+  auto def_fn_2 = [this, &function, &def_fn_1] () {
+    ctx.canonical_ctx.scope (function.get_node_id (),
+			     function.get_function_name (),
+			     std::move (def_fn_1));
+  };
+
+  ctx.scoped (Rib::Kind::Function, function.get_node_id (), def_fn_2,
+	      function.get_function_name ());
 }
 
 void
@@ -63,9 +91,15 @@ DefaultResolver::visit (AST::ForLoopExpr &expr)
 void
 DefaultResolver::visit (AST::Trait &trait)
 {
-  auto inner_fn = [this, &trait] () { AST::DefaultASTVisitor::visit (trait); };
+  auto inner_fn_1
+    = [this, &trait] () { AST::DefaultASTVisitor::visit (trait); };
+
+  auto inner_fn_2 = [this, &trait, &inner_fn_1] () {
+    ctx.canonical_ctx.scope (trait.get_node_id (), trait.get_identifier (),
+			     std::move (inner_fn_1));
+  };
 
-  ctx.scoped (Rib::Kind::TraitOrImpl, trait.get_node_id (), inner_fn,
+  ctx.scoped (Rib::Kind::TraitOrImpl, trait.get_node_id (), inner_fn_2,
 	      trait.get_identifier () /* FIXME: Is that valid?*/);
 }
 
@@ -76,23 +110,27 @@ DefaultResolver::visit (AST::InherentImpl &impl)
   visit (impl.get_visibility ());
   visit_inner_attrs (impl);
 
-  auto inner_fn_inner = [this, &impl] () {
+  auto inner_fn_1 = [this, &impl] () {
     for (auto &item : impl.get_impl_items ())
       visit (item);
   };
 
-  auto inner_fn_outer = [this, &impl, &inner_fn_inner] () {
+  auto inner_fn_2 = [this, &impl, &inner_fn_1] () {
     maybe_insert_big_self (impl);
     for (auto &generic : impl.get_generic_params ())
       visit (generic);
     if (impl.has_where_clause ())
       visit (impl.get_where_clause ());
     visit (impl.get_type ());
 
-    ctx.scoped (Rib::Kind::TraitOrImpl, impl.get_node_id (), inner_fn_inner);
+    ctx.scoped (Rib::Kind::TraitOrImpl, impl.get_node_id (), inner_fn_1);
   };
 
-  ctx.scoped (Rib::Kind::Generics, impl.get_node_id (), inner_fn_outer);
+  auto inner_fn_3 = [this, &impl, &inner_fn_2] () {
+    ctx.canonical_ctx.scope_impl (impl, std::move (inner_fn_2));
+  };
+
+  ctx.scoped (Rib::Kind::Generics, impl.get_node_id (), inner_fn_3);
 }
 
 void
@@ -102,12 +140,12 @@ DefaultResolver::visit (AST::TraitImpl &impl)
   visit (impl.get_visibility ());
   visit_inner_attrs (impl);
 
-  auto inner_fn_inner = [this, &impl] () {
+  auto inner_fn_1 = [this, &impl] () {
     for (auto &item : impl.get_impl_items ())
       visit (item);
   };
 
-  auto inner_fn_outer = [this, &impl, &inner_fn_inner] () {
+  auto inner_fn_2 = [this, &impl, &inner_fn_1] () {
     maybe_insert_big_self (impl);
     for (auto &generic : impl.get_generic_params ())
       visit (generic);
@@ -116,55 +154,120 @@ DefaultResolver::visit (AST::TraitImpl &impl)
     visit (impl.get_type ());
     visit (impl.get_trait_path ());
 
-    ctx.scoped (Rib::Kind::TraitOrImpl, impl.get_node_id (), inner_fn_inner);
+    ctx.scoped (Rib::Kind::TraitOrImpl, impl.get_node_id (), inner_fn_1);
+  };
+
+  auto inner_fn_3 = [this, &impl, &inner_fn_2] () {
+    ctx.canonical_ctx.scope_impl (impl, std::move (inner_fn_2));
   };
 
-  ctx.scoped (Rib::Kind::Generics, impl.get_node_id (), inner_fn_outer);
+  ctx.scoped (Rib::Kind::Generics, impl.get_node_id (), inner_fn_3);
 }
 
 void
 DefaultResolver::visit (AST::StructStruct &type)
 {
-  auto inner_fn = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+  auto inner_fn_1 = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+
+  auto inner_fn_2 = [this, &type, &inner_fn_1] () {
+    ctx.canonical_ctx.scope (type.get_node_id (), type.get_struct_name (),
+			     std::move (inner_fn_1));
+  };
 
   ctx.scoped (Rib::Kind::Item /* FIXME: Correct? */, type.get_node_id (),
-	      inner_fn, type.get_struct_name ());
+	      inner_fn_2, type.get_struct_name ());
 }
 
 void
 DefaultResolver::visit (AST::TupleStruct &type)
 {
-  auto inner_fn = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+  auto inner_fn_1 = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+
+  auto inner_fn_2 = [this, &type, &inner_fn_1] () {
+    ctx.canonical_ctx.scope (type.get_node_id (), type.get_struct_name (),
+			     std::move (inner_fn_1));
+  };
 
   ctx.scoped (Rib::Kind::Item /* FIXME: Correct? */, type.get_node_id (),
-	      inner_fn, type.get_struct_name ());
+	      inner_fn_2, type.get_struct_name ());
+}
+
+void
+DefaultResolver::visit (AST::EnumItem &item)
+{
+  auto inner_fn = [this, &item] () { AST::DefaultASTVisitor::visit (item); };
+
+  ctx.canonical_ctx.scope (item.get_node_id (), item.get_identifier (),
+			   inner_fn);
+}
+
+void
+DefaultResolver::visit (AST::EnumItemTuple &item)
+{
+  auto inner_fn = [this, &item] () { AST::DefaultASTVisitor::visit (item); };
+
+  ctx.canonical_ctx.scope (item.get_node_id (), item.get_identifier (),
+			   inner_fn);
+}
+
+void
+DefaultResolver::visit (AST::EnumItemStruct &item)
+{
+  auto inner_fn = [this, &item] () { AST::DefaultASTVisitor::visit (item); };
+
+  ctx.canonical_ctx.scope (item.get_node_id (), item.get_identifier (),
+			   inner_fn);
+}
+
+void
+DefaultResolver::visit (AST::EnumItemDiscriminant &item)
+{
+  auto inner_fn = [this, &item] () { AST::DefaultASTVisitor::visit (item); };
+
+  ctx.canonical_ctx.scope (item.get_node_id (), item.get_identifier (),
+			   inner_fn);
 }
 
 void
 DefaultResolver::visit (AST::Enum &type)
 {
-  auto variant_fn = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+  auto inner_fn_1 = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+
+  auto inner_fn_2 = [this, &type, &inner_fn_1] () {
+    ctx.canonical_ctx.scope (type.get_node_id (), type.get_identifier (),
+			     std::move (inner_fn_1));
+  };
 
   ctx.scoped (Rib::Kind::Item /* FIXME: Correct? */, type.get_node_id (),
-	      variant_fn, type.get_identifier ());
+	      inner_fn_2, type.get_identifier ());
 }
 
 void
 DefaultResolver::visit (AST::Union &type)
 {
-  auto inner_fn = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+  auto inner_fn_1 = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+
+  auto inner_fn_2 = [this, &type, &inner_fn_1] () {
+    ctx.canonical_ctx.scope (type.get_node_id (), type.get_identifier (),
+			     std::move (inner_fn_1));
+  };
 
   ctx.scoped (Rib::Kind::Item /* FIXME: Correct? */, type.get_node_id (),
-	      inner_fn, type.get_identifier ());
+	      inner_fn_2, type.get_identifier ());
 }
 
 void
 DefaultResolver::visit (AST::TypeAlias &type)
 {
-  auto inner_fn = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+  auto inner_fn_1 = [this, &type] () { AST::DefaultASTVisitor::visit (type); };
+
+  auto inner_fn_2 = [this, &type, &inner_fn_1] () {
+    ctx.canonical_ctx.scope (type.get_node_id (), type.get_new_type_name (),
+			     std::move (inner_fn_1));
+  };
 
   ctx.scoped (Rib::Kind::Item /* FIXME: Correct? */, type.get_node_id (),
-	      inner_fn, type.get_new_type_name ());
+	      inner_fn_2, type.get_new_type_name ());
 }
 
 void
@@ -199,21 +302,31 @@ DefaultResolver::visit (AST::ConstantItem &item)
 {
   if (item.has_expr ())
     {
-      auto expr_vis
+      auto expr_vis_1
 	= [this, &item] () { AST::DefaultASTVisitor::visit (item); };
 
+      auto expr_vis_2 = [this, &item, &expr_vis_1] () {
+	ctx.canonical_ctx.scope (item.get_node_id (), item.get_identifier (),
+				 std::move (expr_vis_1));
+      };
+
       // FIXME: Why do we need a Rib here?
-      ctx.scoped (Rib::Kind::ConstantItem, item.get_node_id (), expr_vis);
+      ctx.scoped (Rib::Kind::ConstantItem, item.get_node_id (), expr_vis_2);
     }
 }
 
 void
 DefaultResolver::visit (AST::StaticItem &item)
 {
-  auto expr_vis = [this, &item] () { AST::DefaultASTVisitor::visit (item); };
+  auto expr_vis_1 = [this, &item] () { AST::DefaultASTVisitor::visit (item); };
+
+  auto expr_vis_2 = [this, &item, &expr_vis_1] () {
+    ctx.canonical_ctx.scope (item.get_node_id (), item.get_identifier (),
+			     std::move (expr_vis_1));
+  };
 
   // FIXME: Why do we need a Rib here?
-  ctx.scoped (Rib::Kind::ConstantItem, item.get_node_id (), expr_vis);
+  ctx.scoped (Rib::Kind::ConstantItem, item.get_node_id (), expr_vis_2);
 }
 
 void

gcc/rust/resolve/rust-default-resolver.h

@@ -39,6 +39,7 @@ class DefaultResolver : public AST::DefaultASTVisitor
 
   virtual ~DefaultResolver () {}
 
+  void visit (AST::Crate &) override;
   // First, our lexical scope expressions - these visit their sub nodes, always
   // these nodes create new scopes and ribs - they are often used to declare new
   // variables, such as a for loop's iterator, or a function's arguments
@@ -57,6 +58,10 @@ class DefaultResolver : public AST::DefaultASTVisitor
   // type dec nodes, which visit their fields or variants by default
   void visit (AST::StructStruct &) override;
   void visit (AST::TupleStruct &) override;
+  void visit (AST::EnumItem &) override;
+  void visit (AST::EnumItemTuple &) override;
+  void visit (AST::EnumItemStruct &) override;
+  void visit (AST::EnumItemDiscriminant &) override;
   void visit (AST::Enum &) override;
   void visit (AST::Union &) override;
   void visit (AST::TypeAlias &) override;

gcc/rust/resolve/rust-early-name-resolver-2.0.cc

@@ -62,8 +62,9 @@ Early::go (AST::Crate &crate)
   // We now proceed with resolving macros, which can be nested in almost any
   // items
   textual_scope.push ();
-  for (auto &item : crate.items)
-    item->accept_vis (*this);
+
+  visit (crate);
+
   textual_scope.pop ();
 }
 

gcc/rust/resolve/rust-forever-stack.h

@@ -676,9 +676,6 @@ template <Namespace N> class ForeverStack
     std::function<void (const S &, NodeId)> insert_segment_resolution,
     std::vector<Error> &collect_errors);
 
-  // FIXME: Documentation
-  tl::optional<Resolver::CanonicalPath> to_canonical_path (NodeId id) const;
-
   // FIXME: Documentation
   tl::optional<Rib &> to_rib (NodeId rib_id);
   tl::optional<const Rib &> to_rib (NodeId rib_id) const;