Reduce node id sharing

Also removes some redundant copies and improves TypePath copying.

gcc/rust/ChangeLog:

	* ast/rust-ast-builder.cc (Builder::trait_bound): Replace copy
	with move.
	(Builder::trait_impl): Likewise.
	(Builder::new_const_param): Replace cloning with reconstruction.
	* ast/rust-path.h (TypePath::TypePath): Use TypeNoBounds copy
	constructor.
	(TypePath::operator=): Use TypeNoBounds copy assignment.
	* expand/rust-derive-clone.cc (DeriveClone::clone_impl): Produce
	trait bounds lazily.
	* expand/rust-derive-copy.cc (DeriveCopy::copy_impl): Likewise.
	* expand/rust-derive-debug.cc (DeriveDebug::stub_derive_impl):
	Likewise.
	* expand/rust-derive-default.cc (DeriveDefault::default_impl):
	Likewise.
	* expand/rust-derive-eq.cc (DeriveEq::eq_impls): Likewise.
	* expand/rust-derive-hash.cc (DeriveHash::hash_impl): Likewise.
	* expand/rust-derive-ord.cc (DeriveOrd::cmp_impl): Likewise.
	* expand/rust-derive-partial-eq.cc
	(DerivePartialEq::partialeq_impls): Likewise.
	* expand/rust-derive.cc (DeriveVisitor::setup_impl_generics):
	Likewise.
	* expand/rust-derive.h (DeriveVisitor::setup_impl_generics):
	Likewise.

Signed-off-by: Owen Avery <[email protected]>

Author: powerboat9

gcc/rust/ast/rust-ast-builder.cc

@@ -510,7 +510,7 @@ Builder::loop (std::vector<std::unique_ptr<Stmt>> &&stmts)
 std::unique_ptr<TypeParamBound>
 Builder::trait_bound (TypePath bound)
 {
-  return std::make_unique<TraitBound> (bound, loc);
+  return std::make_unique<TraitBound> (std::move (bound), loc);
 }
 
 std::unique_ptr<Item>
@@ -520,7 +520,7 @@ Builder::trait_impl (TypePath trait_path, std::unique_ptr<Type> target,
 		     WhereClause where_clause, Visibility visibility) const
 {
   return std::unique_ptr<Item> (
-    new TraitImpl (trait_path, /* unsafe */ false,
+    new TraitImpl (std::move (trait_path), /* unsafe */ false,
 		   /* exclam */ false, std::move (trait_items),
 		   std::move (generics), std::move (target), where_clause,
 		   visibility, {}, {}, loc));
@@ -567,7 +567,7 @@ std::unique_ptr<GenericParam>
 Builder::new_const_param (ConstGenericParam &param) const
 {
   return std::make_unique<ConstGenericParam> (param.get_name (),
-					      param.get_type ().clone_type (),
+					      param.get_type ().reconstruct (),
 					      param.get_default_value (),
 					      param.get_outer_attrs (),
 					      param.get_locus ());

gcc/rust/ast/rust-path.h

@@ -1216,10 +1216,10 @@ class TypePath : public TypeNoBounds
 
   // Copy constructor with vector clone
   TypePath (TypePath const &other)
-    : has_opening_scope_resolution (other.has_opening_scope_resolution),
+    : TypeNoBounds (other),
+      has_opening_scope_resolution (other.has_opening_scope_resolution),
       locus (other.locus)
   {
-    node_id = other.node_id;
     segments.reserve (other.segments.size ());
     for (const auto &e : other.segments)
       segments.push_back (e->clone_type_path_segment ());
@@ -1228,7 +1228,7 @@ class TypePath : public TypeNoBounds
   // Overloaded assignment operator with clone
   TypePath &operator= (TypePath const &other)
   {
-    node_id = other.node_id;
+    TypeNoBounds::operator= (other);
     has_opening_scope_resolution = other.has_opening_scope_resolution;
     locus = other.locus;
 

gcc/rust/expand/rust-derive-clone.cc

@@ -89,17 +89,17 @@ DeriveClone::clone_impl (
   std::unique_ptr<AssociatedItem> &&clone_fn, std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  // we should have two of these, so we don't run into issues with
-  // two paths sharing a node id
-  auto clone_bound = builder.type_path (LangItem::Kind::CLONE);
-  auto clone_trait_path = builder.type_path (LangItem::Kind::CLONE);
+  auto clone_trait_path
+    = [this] () { return builder.type_path (LangItem::Kind::CLONE); };
 
   auto trait_items = vec (std::move (clone_fn));
 
-  auto generics = setup_impl_generics (name, type_generics,
-				       builder.trait_bound (clone_bound));
+  auto generics = setup_impl_generics (name, type_generics, [&, this] () {
+    return builder.trait_bound (clone_trait_path ());
+  });
 
-  return builder.trait_impl (clone_trait_path, std::move (generics.self_type),
+  return builder.trait_impl (clone_trait_path (),
+			     std::move (generics.self_type),
 			     std::move (trait_items),
 			     std::move (generics.impl));
 }

gcc/rust/expand/rust-derive-copy.cc

@@ -42,15 +42,14 @@ DeriveCopy::copy_impl (
   std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  // we should have two of these, so we don't run into issues with
-  // two paths sharing a node id
-  auto copy_bound = builder.type_path (LangItem::Kind::COPY);
-  auto copy_trait_path = builder.type_path (LangItem::Kind::COPY);
+  auto copy_trait_path
+    = [this] () { return builder.type_path (LangItem::Kind::COPY); };
 
-  auto generics = setup_impl_generics (name, type_generics,
-				       builder.trait_bound (copy_bound));
+  auto generics = setup_impl_generics (name, type_generics, [&, this] () {
+    return builder.trait_bound (copy_trait_path ());
+  });
 
-  return builder.trait_impl (copy_trait_path, std::move (generics.self_type),
+  return builder.trait_impl (copy_trait_path (), std::move (generics.self_type),
 			     {}, std::move (generics.impl));
 }
 

gcc/rust/expand/rust-derive-debug.cc

@@ -81,11 +81,14 @@ DeriveDebug::stub_derive_impl (
 {
   auto trait_items = vec (stub_debug_fn ());
 
-  auto debug = builder.type_path ({"core", "fmt", "Debug"}, true);
-  auto generics
-    = setup_impl_generics (name, type_generics, builder.trait_bound (debug));
-
-  return builder.trait_impl (debug, std::move (generics.self_type),
+  auto debug = [this] () {
+    return builder.type_path ({"core", "fmt", "Debug"}, true);
+  };
+  auto generics = setup_impl_generics (name, type_generics, [&, this] () {
+    return builder.trait_bound (debug ());
+  });
+
+  return builder.trait_impl (debug (), std::move (generics.self_type),
 			     std::move (trait_items),
 			     std::move (generics.impl));
 }

gcc/rust/expand/rust-derive-default.cc

@@ -69,14 +69,17 @@ DeriveDefault::default_impl (
   std::unique_ptr<AssociatedItem> &&default_fn, std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  auto default_path = builder.type_path ({"core", "default", "Default"}, true);
+  auto default_path = [this] () {
+    return builder.type_path ({"core", "default", "Default"}, true);
+  };
 
   auto trait_items = vec (std::move (default_fn));
 
-  auto generics = setup_impl_generics (name, type_generics,
-				       builder.trait_bound (default_path));
+  auto generics = setup_impl_generics (name, type_generics, [&, this] () {
+    return builder.trait_bound (default_path ());
+  });
 
-  return builder.trait_impl (default_path, std::move (generics.self_type),
+  return builder.trait_impl (default_path (), std::move (generics.self_type),
 			     std::move (trait_items),
 			     std::move (generics.impl));
 }

gcc/rust/expand/rust-derive-eq.cc

@@ -118,19 +118,17 @@ DeriveEq::eq_impls (
   std::unique_ptr<AssociatedItem> &&fn, std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  // We create two copies of the type-path to avoid duplicate NodeIds
-  auto eq = get_eq_trait_path (builder);
-  auto eq_bound = builder.trait_bound (get_eq_trait_path (builder));
+  auto eq = [this] () { return get_eq_trait_path (builder); };
+  auto eq_bound = [&, this] () { return builder.trait_bound (eq ()); };
 
   auto steq = builder.type_path (LangItem::Kind::STRUCTURAL_TEQ);
 
   auto trait_items = vec (std::move (fn));
 
-  auto eq_generics
-    = setup_impl_generics (name, type_generics, std::move (eq_bound));
+  auto eq_generics = setup_impl_generics (name, type_generics, eq_bound);
   auto steq_generics = setup_impl_generics (name, type_generics);
 
-  auto eq_impl = builder.trait_impl (eq, std::move (eq_generics.self_type),
+  auto eq_impl = builder.trait_impl (eq (), std::move (eq_generics.self_type),
 				     std::move (trait_items),
 				     std::move (eq_generics.impl));
 

gcc/rust/expand/rust-derive-hash.cc

@@ -77,14 +77,17 @@ DeriveHash::hash_impl (
   std::unique_ptr<AssociatedItem> &&hash_fn, std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  auto hash_path = builder.type_path ({"core", "hash", "Hash"}, true);
+  auto hash_path = [this] () {
+    return builder.type_path ({"core", "hash", "Hash"}, true);
+  };
 
   auto trait_items = vec (std::move (hash_fn));
 
-  auto generics = setup_impl_generics (name, type_generics,
-				       builder.trait_bound (hash_path));
+  auto generics = setup_impl_generics (name, type_generics, [&, this] () {
+    return builder.trait_bound (hash_path ());
+  });
 
-  return builder.trait_impl (hash_path, std::move (generics.self_type),
+  return builder.trait_impl (hash_path (), std::move (generics.self_type),
 			     std::move (trait_items),
 			     std::move (generics.impl));
 }

gcc/rust/expand/rust-derive-ord.cc

@@ -58,18 +58,19 @@ DeriveOrd::cmp_impl (
   auto fn = cmp_fn (std::move (fn_block), type_name);
 
   auto trait = ordering == Ordering::Partial ? "PartialOrd" : "Ord";
-  auto trait_path = builder.type_path ({"core", "cmp", trait}, true);
+  auto trait_path = [&, this] () {
+    return builder.type_path ({"core", "cmp", trait}, true);
+  };
 
   auto trait_bound
-    = builder.trait_bound (builder.type_path ({"core", "cmp", trait}, true));
+    = [&, this] () { return builder.trait_bound (trait_path ()); };
 
   auto trait_items = vec (std::move (fn));
 
   auto cmp_generics
-    = setup_impl_generics (type_name.as_string (), type_generics,
-			   std::move (trait_bound));
+    = setup_impl_generics (type_name.as_string (), type_generics, trait_bound);
 
-  return builder.trait_impl (trait_path, std::move (cmp_generics.self_type),
+  return builder.trait_impl (trait_path (), std::move (cmp_generics.self_type),
 			     std::move (trait_items),
 			     std::move (cmp_generics.impl));
 }

gcc/rust/expand/rust-derive-partial-eq.cc

@@ -42,17 +42,18 @@ DerivePartialEq::partialeq_impls (
   std::unique_ptr<AssociatedItem> &&eq_fn, std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  auto eq = builder.type_path (LangItem::Kind::EQ);
+  auto eq = [this] () { return builder.type_path (LangItem::Kind::EQ); };
   auto speq = builder.type_path (LangItem::Kind::STRUCTURAL_PEQ);
 
   auto trait_items = vec (std::move (eq_fn));
 
   // no extra bound on StructuralPeq
-  auto peq_generics
-    = setup_impl_generics (name, type_generics, builder.trait_bound (eq));
+  auto peq_generics = setup_impl_generics (name, type_generics, [&, this] () {
+    return builder.trait_bound (eq ());
+  });
   auto speq_generics = setup_impl_generics (name, type_generics);
 
-  auto peq = builder.trait_impl (eq, std::move (peq_generics.self_type),
+  auto peq = builder.trait_impl (eq (), std::move (peq_generics.self_type),
 				 std::move (trait_items),
 				 std::move (peq_generics.impl));