Merge #358

358: Canonical Paths for Name Resolution and handle TurboFish properly r=philberty a=philberty

Add Canonical paths to name resolution
    
In order to support name resolution and checks for duplicate definitions
of names we need canonical paths for all DefId items such as inherent impl
items and normal items. Consider:

```rust
  struct Foo<T>(T);

  impl Foo<f32> {
    fn name()...
  }

  impl Foo<i32> {
    fn name()...
  }
```

Each of the impl blocks have a name function but these are separate due to
the concrete impl of the Parameter type passed in.

The caveat here is that to call this Function name the programmer must be
explicit in which implentation they wish to call such as:

```rust
  let a = Foo::<f32>::name();
```

This lets the Path probe lookup the appropriate impl block. The problem here
is that rust also allows for the compiler to infer the impl you wish such
as:

```rust
  let a = Foo::name();
```

This should fail since there are multiple candidates possible for this
Path. Unless there might have only been one name function in which case
it would have worked.

This patch is also responsible to implement PathInExpression by iterating
each segment and applying generic arguments as we go.

Fixes #355 #335 #325 #353


Co-authored-by: Philip Herron <[email protected]>

Author: bors[bot]

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

@@ -526,7 +526,7 @@ class CompileExpr : public HIRCompileBase
 
   void visit (HIR::PathInExpression &expr) override
   {
-    translated = ResolvePathRef::Compile (&expr, ctx);
+    translated = ResolvePathRef::Compile (expr, ctx);
   }
 
   void visit (HIR::LoopExpr &expr) override

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

@@ -30,10 +30,10 @@ class ResolvePathRef : public HIRCompileBase
   using Rust::Compile::HIRCompileBase::visit;
 
 public:
-  static Bexpression *Compile (HIR::Expr *expr, Context *ctx)
+  static Bexpression *Compile (HIR::PathInExpression &expr, Context *ctx)
   {
     ResolvePathRef resolver (ctx);
-    expr->accept_vis (resolver);
+    expr.accept_vis (resolver);
     return resolver.resolved;
   }
 

gcc/rust/hir/rust-ast-lower-item.h

@@ -360,12 +360,14 @@ class ASTLoweringItem : public ASTLoweringBase
 				   mappings->get_next_localdef_id (crate_num));
 
     std::vector<std::unique_ptr<HIR::InherentImplItem> > impl_items;
+    std::vector<HirId> impl_item_ids;
     for (auto &impl_item : impl_block.get_impl_items ())
       {
 	HIR::InherentImplItem *lowered
 	  = ASTLowerImplItem::translate (impl_item.get (),
 					 mapping.get_hirid ());
 	impl_items.push_back (std::unique_ptr<HIR::InherentImplItem> (lowered));
+	impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
       }
 
     translated
@@ -381,6 +383,13 @@ class ASTLoweringItem : public ASTLoweringBase
 			       translated);
     mappings->insert_location (crate_num, mapping.get_hirid (),
 			       impl_block.get_locus ());
+
+    for (auto &impl_item_id : impl_item_ids)
+      {
+	mappings->insert_impl_item_mapping (impl_item_id,
+					    static_cast<HIR::InherentImpl *> (
+					      translated));
+      }
   }
 
 private:

gcc/rust/hir/tree/rust-hir-path.h

@@ -255,6 +255,12 @@ class PathPattern : public Pattern
       }
   }
 
+  size_t get_num_segments () const { return segments.size (); }
+
+  std::vector<PathExprSegment> &get_segments () { return segments; }
+
+  PathExprSegment &get_root_seg () { return segments.at (0); }
+
   PathExprSegment get_final_segment () const { return segments.back (); }
 };
 

gcc/rust/resolve/rust-ast-resolve-expr.h

@@ -109,15 +109,16 @@ class ResolveExpr : public ResolverBase
 
   void visit (AST::IdentifierExpr &expr) override
   {
-    if (resolver->get_name_scope ().lookup (expr.as_string (), &resolved_node))
+    if (resolver->get_name_scope ().lookup (CanonicalPath (expr.as_string ()),
+					    &resolved_node))
       {
 	resolver->insert_resolved_name (expr.get_node_id (), resolved_node);
 	resolver->insert_new_definition (expr.get_node_id (),
 					 Definition{expr.get_node_id (),
 						    parent});
       }
-    else if (resolver->get_type_scope ().lookup (expr.as_string (),
-						 &resolved_node))
+    else if (resolver->get_type_scope ().lookup (
+	       CanonicalPath (expr.as_string ()), &resolved_node))
       {
 	resolver->insert_resolved_type (expr.get_node_id (), resolved_node);
 	resolver->insert_new_definition (expr.get_node_id (),
@@ -255,8 +256,9 @@ class ResolveExpr : public ResolverBase
 	auto label_name = label.get_lifetime ().get_lifetime_name ();
 	auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
 	resolver->get_label_scope ().insert (
-	  label_name, label_lifetime_node_id, label.get_locus (), false,
-	  [&] (std::string, NodeId, Location locus) -> void {
+	  CanonicalPath (label_name), label_lifetime_node_id,
+	  label.get_locus (), false,
+	  [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	    rust_error_at (label.get_locus (),
 			   "label redefined multiple times");
 	    rust_error_at (locus, "was defined here");
@@ -281,8 +283,8 @@ class ResolveExpr : public ResolverBase
 	  }
 
 	NodeId resolved_node = UNKNOWN_NODEID;
-	if (!resolver->get_label_scope ().lookup (label.get_lifetime_name (),
-						  &resolved_node))
+	if (!resolver->get_label_scope ().lookup (
+	      CanonicalPath (label.get_lifetime_name ()), &resolved_node))
 	  {
 	    rust_error_at (expr.get_label ().get_locus (),
 			   "failed to resolve label");
@@ -311,8 +313,9 @@ class ResolveExpr : public ResolverBase
 	auto label_name = label.get_lifetime ().get_lifetime_name ();
 	auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
 	resolver->get_label_scope ().insert (
-	  label_name, label_lifetime_node_id, label.get_locus (), false,
-	  [&] (std::string, NodeId, Location locus) -> void {
+	  CanonicalPath (label_name), label_lifetime_node_id,
+	  label.get_locus (), false,
+	  [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	    rust_error_at (label.get_locus (),
 			   "label redefined multiple times");
 	    rust_error_at (locus, "was defined here");
@@ -338,8 +341,8 @@ class ResolveExpr : public ResolverBase
 	  }
 
 	NodeId resolved_node = UNKNOWN_NODEID;
-	if (!resolver->get_label_scope ().lookup (label.get_lifetime_name (),
-						  &resolved_node))
+	if (!resolver->get_label_scope ().lookup (
+	      CanonicalPath (label.get_lifetime_name ()), &resolved_node))
 	  {
 	    rust_error_at (expr.get_label ().get_locus (),
 			   "failed to resolve label");

gcc/rust/resolve/rust-ast-resolve-implitem.h

@@ -31,25 +31,19 @@ class ResolveToplevelImplItem : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static void go (AST::InherentImplItem *item, AST::Type *base)
+  static void go (AST::InherentImplItem *item, const CanonicalPath &prefix)
   {
-    ResolveToplevelImplItem resolver (base);
-    if (resolver.base_path.is_empty ())
-      {
-	rust_error_at (base->get_locus_slow (),
-		       "failed to resolve simple path");
-	return;
-      }
+    ResolveToplevelImplItem resolver (prefix);
     item->accept_vis (resolver);
   }
 
   void visit (AST::ConstantItem &constant) override
   {
-    std::string identifier
-      = base_path.as_string () + "::" + constant.get_identifier ();
+    auto path
+      = prefix.append (ResolveConstantItemToCanonicalPath::resolve (constant));
     resolver->get_name_scope ().insert (
-      identifier, constant.get_node_id (), constant.get_locus (), false,
-      [&] (std::string, NodeId, Location locus) -> void {
+      path, constant.get_node_id (), constant.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	rust_error_at (constant.get_locus (), "redefined multiple times");
 	rust_error_at (locus, "was defined here");
       });
@@ -60,11 +54,11 @@ class ResolveToplevelImplItem : public ResolverBase
 
   void visit (AST::Function &function) override
   {
-    std::string identifier
-      = base_path.as_string () + "::" + function.get_function_name ();
+    auto path
+      = prefix.append (ResolveFunctionItemToCanonicalPath::resolve (function));
     resolver->get_name_scope ().insert (
-      identifier, function.get_node_id (), function.get_locus (), false,
-      [&] (std::string, NodeId, Location locus) -> void {
+      path, function.get_node_id (), function.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	rust_error_at (function.get_locus (), "redefined multiple times");
 	rust_error_at (locus, "was defined here");
       });
@@ -75,11 +69,11 @@ class ResolveToplevelImplItem : public ResolverBase
 
   void visit (AST::Method &method) override
   {
-    std::string identifier
-      = base_path.as_string () + "::" + method.get_method_name ();
+    auto path
+      = prefix.append (ResolveMethodItemToCanonicalPath::resolve (method));
     resolver->get_name_scope ().insert (
-      identifier, method.get_node_id (), method.get_locus (), false,
-      [&] (std::string, NodeId, Location locus) -> void {
+      path, method.get_node_id (), method.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	rust_error_at (method.get_locus (), "redefined multiple times");
 	rust_error_at (locus, "was defined here");
       });
@@ -89,15 +83,13 @@ class ResolveToplevelImplItem : public ResolverBase
   }
 
 private:
-  ResolveToplevelImplItem (AST::Type *base)
-    : ResolverBase (UNKNOWN_NODEID), base (base),
-      base_path (AST::SimplePath::create_empty ())
+  ResolveToplevelImplItem (const CanonicalPath &prefix)
+    : ResolverBase (UNKNOWN_NODEID), prefix (prefix)
   {
-    ResolveTypeToSimplePath::go (base, base_path, true);
+    rust_assert (!prefix.is_error ());
   }
 
-  AST::Type *base;
-  AST::SimplePath base_path;
+  const CanonicalPath &prefix;
 };
 
 } // namespace Resolver

gcc/rust/resolve/rust-ast-resolve-item.h

@@ -179,18 +179,21 @@ class ResolveItem : public ResolverBase
 	  }
       }
 
+    bool canonicalize_type_with_generics = false;
     NodeId resolved_node = ResolveType::go (impl_block.get_type ().get (),
-					    impl_block.get_node_id ());
+					    impl_block.get_node_id (),
+					    canonicalize_type_with_generics);
     if (resolved_node == UNKNOWN_NODEID)
       return;
 
+    auto Self = CanonicalPath::get_big_self ();
     resolver->get_type_scope ().insert (
-      "Self", resolved_node, impl_block.get_type ()->get_locus_slow ());
+      Self, resolved_node, impl_block.get_type ()->get_locus_slow ());
 
     for (auto &impl_item : impl_block.get_impl_items ())
       impl_item->accept_vis (*this);
 
-    resolver->get_type_scope ().peek ()->clear_name ("Self", resolved_node);
+    resolver->get_type_scope ().peek ()->clear_name (Self, resolved_node);
     resolver->get_type_scope ().pop ();
   }
 

gcc/rust/resolve/rust-ast-resolve-pattern.h

@@ -33,7 +33,6 @@ class ResolvePattern : public ResolverBase
   static void go (AST::Pattern *pattern, NodeId parent)
   {
     ResolvePattern resolver (parent);
-
     pattern->accept_vis (resolver);
     if (resolver.resolved_node == UNKNOWN_NODEID)
       {
@@ -42,12 +41,10 @@ class ResolvePattern : public ResolverBase
       }
   };
 
-  ~ResolvePattern () {}
-
   void visit (AST::IdentifierPattern &pattern) override
   {
-    if (resolver->get_name_scope ().lookup (pattern.get_ident (),
-					    &resolved_node))
+    if (resolver->get_name_scope ().lookup (
+	  CanonicalPath (pattern.get_ident ()), &resolved_node))
       {
 	resolver->insert_resolved_name (pattern.get_node_id (), resolved_node);
 	resolver->insert_new_definition (pattern.get_node_id (),
@@ -68,23 +65,14 @@ class PatternDeclaration : public ResolverBase
   static void go (AST::Pattern *pattern, NodeId parent)
   {
     PatternDeclaration resolver (parent);
-
     pattern->accept_vis (resolver);
-    if (resolver.resolved_node != UNKNOWN_NODEID)
-      {
-	// print both locations?!
-	rust_error_at (resolver.locus, "duplicate pattern %s",
-		       pattern->as_string ().c_str ());
-      }
   };
 
-  ~PatternDeclaration () {}
-
   void visit (AST::IdentifierPattern &pattern) override
   {
     // if we have a duplicate id this then allows for shadowing correctly
     // as new refs to this decl will match back here so it is ok to overwrite
-    resolver->get_name_scope ().insert (pattern.get_ident (),
+    resolver->get_name_scope ().insert (CanonicalPath (pattern.get_ident ()),
 					pattern.get_node_id (),
 					pattern.get_locus ());
     resolver->insert_new_definition (pattern.get_node_id (),