ast: Refactor how lang item paths are handled.

Lang item typepaths were not handled properly, and required a complete overhaul.
All old classes that concerned lang item paths are now modified to use a simpler
version of `AST::LangItemPath`, which has been removed. TypePath segments can now
be lang items, as this is requied for having generic lang item paths such as
PhantomData<T>.

gcc/rust/ChangeLog:

	* ast/rust-path.h: Rework how lang item paths are represented.
	* ast/rust-path.cc: Likewise.
	* ast/rust-item.h: Likewise.
	* ast/rust-ast.cc: Likewise.
	* ast/rust-ast-collector.cc: Adapt to new lang item path system.
	* ast/rust-ast-collector.h: Likewise.
	* ast/rust-ast-visitor.cc (DefaultASTVisitor::visit): Likewise.
	* ast/rust-ast-visitor.h: Likewise.
	* expand/rust-derive-copy.cc: Likewise.
	* expand/rust-derive.h: Likewise.
	* hir/rust-ast-lower-base.cc (ASTLoweringBase::visit): Likewise.
	* hir/rust-ast-lower-base.h: Likewise.
	* hir/rust-ast-lower-type.cc (ASTLowerTypePath::translate): Likewise.
	(ASTLowerTypePath::visit): Likewise.
	* hir/rust-ast-lower-type.h: Likewise.
	* resolve/rust-ast-resolve-base.cc (ResolverBase::visit): Likewise.
	* resolve/rust-ast-resolve-base.h: Likewise.
	* resolve/rust-ast-resolve-item.cc (ResolveItem::visit): Likewise.
	* resolve/rust-ast-resolve-type.h: Likewise.
	* resolve/rust-ast-resolve-type.cc (ResolveRelativeTypePath::go): Likewise.
	* resolve/rust-late-name-resolver-2.0.cc (Late::visit): Likewise.
	* resolve/rust-late-name-resolver-2.0.h: Likewise.
	* hir/tree/rust-hir-path.cc (TypePathSegment::TypePathSegment): Likewise.
	(TypePathSegmentGeneric::TypePathSegmentGeneric): Likewise.
	* hir/tree/rust-hir-path.h: Likewise.
	* typecheck/rust-hir-type-check-type.cc (TypeCheckType::resolve_root_path): Likewise.
	* ast/rust-ast-builder.cc: Likewise.
	* ast/rust-ast-builder.h: Likewise.

1 files changed, 7 insertions, 33 deletions

diff --git a/gcc/rust/ast/rust-item.h b/gcc/rust/ast/rust-item.h
index a9ee376..1893822 100644
--- a/gcc/rust/ast/rust-item.h
+++ b/gcc/rust/ast/rust-item.h
@@ -3254,7 +3254,7 @@ class TraitImpl : public Impl
 {
   bool has_unsafe;
   bool has_exclam;
-  std::unique_ptr<Path> trait_path;
+  TypePath trait_path;
 
   // bool has_impl_items;
   std::vector<std::unique_ptr<AssociatedItem>> impl_items;
@@ -3266,7 +3266,7 @@ public:
   bool has_impl_items () const { return !impl_items.empty (); }
 
   // Mega-constructor
-  TraitImpl (std::unique_ptr<Path> trait_path, bool is_unsafe, bool has_exclam,
+  TraitImpl (TypePath trait_path, bool is_unsafe, bool has_exclam,
 	     std::vector<std::unique_ptr<AssociatedItem>> impl_items,
 	     std::vector<std::unique_ptr<GenericParam>> generic_params,
 	     std::unique_ptr<Type> trait_type, WhereClause where_clause,
@@ -3275,29 +3275,14 @@ public:
     : Impl (std::move (generic_params), std::move (trait_type),
 	    std::move (where_clause), std::move (vis), std::move (inner_attrs),
 	    std::move (outer_attrs), locus),
-      has_unsafe (is_unsafe), has_exclam (has_exclam),
-      trait_path (std::move (trait_path)), impl_items (std::move (impl_items))
-  {}
-
-  // Delegating constructor for TypePath
-  TraitImpl (TypePath trait_path, bool is_unsafe, bool has_exclam,
-	     std::vector<std::unique_ptr<AssociatedItem>> impl_items,
-	     std::vector<std::unique_ptr<GenericParam>> generic_params,
-	     std::unique_ptr<Type> trait_type, WhereClause where_clause,
-	     Visibility vis, std::vector<Attribute> inner_attrs,
-	     std::vector<Attribute> outer_attrs, location_t locus)
-    : TraitImpl (std::unique_ptr<Path> (new TypePath (trait_path)), is_unsafe,
-		 has_exclam, std::move (impl_items), std::move (generic_params),
-		 std::move (trait_type), std::move (where_clause),
-		 std::move (vis), std::move (inner_attrs),
-		 std::move (outer_attrs), locus)
+      has_unsafe (is_unsafe), has_exclam (has_exclam), trait_path (trait_path),
+      impl_items (std::move (impl_items))
   {}
 
   // Copy constructor with vector clone
   TraitImpl (TraitImpl const &other)
     : Impl (other), has_unsafe (other.has_unsafe),
-      has_exclam (other.has_exclam),
-      trait_path (other.trait_path->clone_path ())
+      has_exclam (other.has_exclam), trait_path (other.trait_path)
   {
     impl_items.reserve (other.impl_items.size ());
     for (const auto &e : other.impl_items)
@@ -3308,7 +3293,7 @@ public:
   TraitImpl &operator= (TraitImpl const &other)
   {
     Impl::operator= (other);
-    trait_path = other.trait_path->clone_path ();
+    trait_path = other.trait_path;
     has_unsafe = other.has_unsafe;
     has_exclam = other.has_exclam;
 
@@ -3339,18 +3324,7 @@ public:
   }
 
   // TODO: is this better? Or is a "vis_block" better?
-  Path &get_trait_path ()
-  {
-    // TODO: assert that trait path is not empty?
-    return *trait_path;
-  }
-
-  Type &get_trait_path_type ()
-  {
-    rust_assert (trait_path->get_path_kind () == Path::Kind::Type);
-
-    return (AST::Type &) static_cast<AST::TypePath &> (*trait_path);
-  }
+  TypePath &get_trait_path () { return trait_path; }
 
 protected:
   /* Use covariance to implement clone function as returning this object