ast: Add reconstruct_type() method

gcc/rust/ChangeLog:

	* ast/rust-ast.h: Add reconstruct_type() and reconstruct_type_impl()
	* ast/rust-type.h: Implement them.
	* ast/rust-macro.h: Likewise.
	* ast/rust-path.h: Likewise.

Author: CohenArthur

gcc/rust/ast/rust-ast.h

@@ -1525,6 +1525,13 @@ class Type : public Visitable
     return std::unique_ptr<Type> (clone_type_impl ());
   }
 
+  // Similar to `clone_type`, but generates a new instance of the node with a
+  // different NodeId
+  std::unique_ptr<Type> reconstruct_type () const
+  {
+    return reconstruct (this, &Type::reconstruct_type_impl);
+  }
+
   // virtual destructor
   virtual ~Type () {}
 
@@ -1546,9 +1553,11 @@ class Type : public Visitable
 
 protected:
   Type () : node_id (Analysis::Mappings::get ().get_next_node_id ()) {}
+  Type (NodeId node_id) : node_id (node_id) {}
 
-  // Clone function implementation as pure virtual method
+  // Clone and reconstruct function implementations as pure virtual methods
   virtual Type *clone_type_impl () const = 0;
+  virtual Type *reconstruct_type_impl () const = 0;
 
   NodeId node_id;
 };
@@ -1562,10 +1571,15 @@ class TypeNoBounds : public Type
   {
     return std::unique_ptr<TypeNoBounds> (clone_type_no_bounds_impl ());
   }
+  std::unique_ptr<TypeNoBounds> reconstruct_type_no_bounds () const
+  {
+    return reconstruct (this, &TypeNoBounds::reconstruct_type_no_bounds_impl);
+  }
 
 protected:
   // Clone function implementation as pure virtual method
   virtual TypeNoBounds *clone_type_no_bounds_impl () const = 0;
+  virtual TypeNoBounds *reconstruct_type_no_bounds_impl () const = 0;
 
   /* Save having to specify two clone methods in derived classes by making
    * type clone return typenobounds clone. Hopefully won't affect performance
@@ -1575,6 +1589,11 @@ class TypeNoBounds : public Type
     return clone_type_no_bounds_impl ();
   }
 
+  TypeNoBounds *reconstruct_type_impl () const final override
+  {
+    return reconstruct_type_no_bounds_impl ();
+  }
+
   TypeNoBounds () : Type () {}
 };
 
@@ -1596,6 +1615,11 @@ class TypeParamBound : public Visitable
   {
     return std::unique_ptr<TypeParamBound> (clone_type_param_bound_impl ());
   }
+  std::unique_ptr<TypeParamBound> reconstruct_type_param_bound () const
+  {
+    return reconstruct (this,
+			&TypeParamBound::reconstruct_type_param_bound_impl);
+  }
 
   virtual std::string as_string () const = 0;
 
@@ -1608,7 +1632,10 @@ class TypeParamBound : public Visitable
 protected:
   // Clone function implementation as pure virtual method
   virtual TypeParamBound *clone_type_param_bound_impl () const = 0;
+  virtual TypeParamBound *reconstruct_type_param_bound_impl () const = 0;
 
+  TypeParamBound () : node_id (Analysis::Mappings::get ().get_next_node_id ())
+  {}
   TypeParamBound (NodeId node_id) : node_id (node_id) {}
 
   NodeId node_id;
@@ -1670,6 +1697,10 @@ class Lifetime : public TypeParamBound
   {
     return new Lifetime (node_id, lifetime_type, lifetime_name, locus);
   }
+  Lifetime *reconstruct_type_param_bound_impl () const override
+  {
+    return new Lifetime (lifetime_type, lifetime_name, locus);
+  }
 };
 
 /* Base generic parameter in AST. Abstract - can be represented by a Lifetime

gcc/rust/ast/rust-macro.h

@@ -756,22 +756,16 @@ class MacroInvocation : public TypeNoBounds,
   std::vector<std::unique_ptr<MacroInvocation>> pending_eager_invocs;
 
 protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
   MacroInvocation *clone_pattern_impl () const final override
   {
     return clone_macro_invocation_impl ();
   }
 
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
   MacroInvocation *clone_expr_without_block_impl () const final override
   {
     return clone_macro_invocation_impl ();
   }
 
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
   MacroInvocation *clone_type_no_bounds_impl () const final override
   {
     return clone_macro_invocation_impl ();
@@ -782,12 +776,31 @@ class MacroInvocation : public TypeNoBounds,
     return clone_macro_invocation_impl ();
   }
 
+  MacroInvocation *reconstruct_type_no_bounds_impl () const final override
+  {
+    return reconstruct_macro_invocation_impl ();
+  }
+
 public:
   /*virtual*/ MacroInvocation *clone_macro_invocation_impl () const
   {
     return new MacroInvocation (*this);
   }
 
+  std::unique_ptr<MacroInvocation> reconstruct_macro_invocation () const
+  {
+    return reconstruct (this,
+			&MacroInvocation::reconstruct_macro_invocation_impl);
+  }
+
+  MacroInvocation *reconstruct_macro_invocation_impl () const
+  {
+    return new MacroInvocation (
+      kind, builtin_kind, invoc_data, outer_attrs, locus, is_semi_coloned,
+      reconstruct_vec (pending_eager_invocs,
+		       &MacroInvocation::reconstruct_macro_invocation));
+  }
+
   void add_semicolon () override { is_semi_coloned = true; }
 
   Pattern::Kind get_pattern_kind () override

gcc/rust/ast/rust-path.h

@@ -377,6 +377,12 @@ class ConstGenericParam : public GenericParam
     return *type;
   }
 
+  tl::optional<GenericArg> &get_default_value () { return default_value; }
+  const tl::optional<GenericArg> &get_default_value () const
+  {
+    return default_value;
+  }
+
   GenericArg &get_default_value_unchecked ()
   {
     rust_assert (has_default_value ());
@@ -779,6 +785,11 @@ class TypePathSegment
   {
     return new TypePathSegment (*this);
   }
+  virtual TypePathSegment *reconstruct_type_path_segment_impl () const
+  {
+    return new TypePathSegment (lang_item, ident_segment,
+				has_separating_scope_resolution, locus);
+  }
 
 public:
   virtual ~TypePathSegment () {}
@@ -790,6 +801,12 @@ class TypePathSegment
   {
     return std::unique_ptr<TypePathSegment> (clone_type_path_segment_impl ());
   }
+  // Unique pointer custom reconstruct function
+  std::unique_ptr<TypePathSegment> reconstruct_type_path_segment () const
+  {
+    return std::unique_ptr<TypePathSegment> (
+      reconstruct_type_path_segment_impl ());
+  }
 
   TypePathSegment (PathIdentSegment ident_segment,
 		   bool has_separating_scope_resolution, location_t locus)
@@ -814,6 +831,15 @@ class TypePathSegment
       node_id (Analysis::Mappings::get ().get_next_node_id ())
   {}
 
+  // General constructor
+  TypePathSegment (tl::optional<LangItem::Kind> lang_item,
+		   tl::optional<PathIdentSegment> ident_segment,
+		   bool has_separating_scope_resolution, location_t locus)
+    : lang_item (lang_item), ident_segment (ident_segment), locus (locus),
+      has_separating_scope_resolution (has_separating_scope_resolution),
+      node_id (Analysis::Mappings::get ().get_next_node_id ())
+  {}
+
   TypePathSegment (TypePathSegment const &other)
     : lang_item (other.lang_item), ident_segment (other.ident_segment),
       locus (other.locus),
@@ -1145,6 +1171,13 @@ class TypePath : public TypeNoBounds
   {
     return new TypePath (*this);
   }
+  TypePath *reconstruct_type_no_bounds_impl () const override
+  {
+    return new TypePath (
+      reconstruct_vec (segments,
+		       &TypePathSegment::reconstruct_type_path_segment),
+      locus, has_opening_scope_resolution);
+  }
 
 public:
   /* Returns whether the TypePath has an opening scope resolution operator
@@ -1436,6 +1469,14 @@ class QualifiedPathInType : public TypeNoBounds
   {
     return new QualifiedPathInType (*this);
   }
+  QualifiedPathInType *reconstruct_type_no_bounds_impl () const override
+  {
+    return new QualifiedPathInType (
+      path_type, associated_segment->reconstruct_type_path_segment (),
+      reconstruct_vec (segments,
+		       &TypePathSegment::reconstruct_type_path_segment),
+      locus);
+  }
 
 public:
   QualifiedPathInType (