ast: Add reconstruct() logic for PathInExpression

This patch implements the `reconstruct` pattern for `PathInExpression`
and its constituents (segments, generic args), following the architectural
pattern established in PR Rust-GCC#3799 for Types.

Previously, derive expansion relied on building paths twice or potentially
using local helpers. This change moves that logic into the AST, allowing
paths to be deeply reconstructed with fresh NodeIDs.

gcc/rust/ChangeLog:

	* ast/rust-path.h (GenericArgsBinding::reconstruct): New method.
	(GenericArg::reconstruct): New method.
	(GenericArgs::reconstruct): New method.
	(PathExprSegment::reconstruct): New method.
	(PathInExpression::reconstruct): New method.
	* expand/rust-derive-cmp-common.cc (reconstruct_path): Remove.
	(EnumMatchBuilder::tuple): Use path.reconstruct().
	(EnumMatchBuilder::strukt): Use path.reconstruct().

Signed-off-by: Jayant Chauhan <0001jayant@gmail.com>

Author: Pasta-coder

gcc/rust/ast/rust-path.h

@@ -83,6 +83,16 @@ struct GenericArgsBinding
     return type == nullptr;
     // and also identifier is empty, but cheaper computation
   }
+  Identifier get_identifier () const { return identifier; }
+
+  GenericArgsBinding reconstruct () const
+  {
+    std::unique_ptr<Type> new_type = nullptr;
+    if (type)
+      new_type = type->reconstruct ();
+
+    return GenericArgsBinding (identifier, std::move (new_type), locus);
+  }
 
   // Creates an error state generic args binding.
   static GenericArgsBinding create_error ()
@@ -189,6 +199,24 @@ class GenericArg
   {
     return GenericArg (nullptr, nullptr, std::move (path), Kind::Either, locus);
   }
+  Kind get_kind () const { return kind; }
+  location_t get_locus () const { return locus; }
+
+  GenericArg reconstruct () const
+  {
+    switch (kind)
+      {
+      case Kind::Type:
+	return create_type (type->reconstruct ());
+      case Kind::Const:
+	// FIXME: Use reconstruct_expr when available
+	return create_const (expression->clone_expr ());
+      case Kind::Either:
+      default:
+	// For ambiguous or error states, copy constructs are sufficient
+	return GenericArg (*this);
+      }
+  }
 
   GenericArg (const GenericArg &other)
     : path (other.path), kind (other.kind), locus (other.locus)
@@ -460,6 +488,23 @@ struct GenericArgs
 
   ~GenericArgs () = default;
 
+  GenericArgs reconstruct () const
+  {
+    std::vector<GenericArg> new_args;
+    new_args.reserve (generic_args.size ());
+    for (const auto &arg : generic_args)
+      new_args.push_back (arg.reconstruct ());
+
+    std::vector<GenericArgsBinding> new_bindings;
+    new_bindings.reserve (binding_args.size ());
+    for (const auto &binding : binding_args)
+      new_bindings.push_back (binding.reconstruct ());
+
+    // Lifetimes are values, so they can be copied directly
+    return GenericArgs (lifetime_args, std::move (new_args),
+			std::move (new_bindings), locus);
+  }
+
   // overloaded assignment operator to vector clone
   GenericArgs &operator= (GenericArgs const &other)
   {
@@ -563,6 +608,11 @@ class PathExprSegment
 
   NodeId get_node_id () const { return node_id; }
 
+  PathExprSegment reconstruct () const
+  {
+    return PathExprSegment (segment_name, locus, generic_args.reconstruct ());
+  }
+
   bool is_super_path_seg () const
   {
     return !has_generic_args () && get_ident_segment ().is_super_path_seg ();
@@ -705,6 +755,20 @@ class PathInExpression : public Path, public ExprWithoutBlock
     return convert_to_simple_path (has_opening_scope_resolution);
   }
 
+  std::unique_ptr<PathInExpression> reconstruct () const
+  {
+    std::vector<PathExprSegment> new_segments;
+    new_segments.reserve (segments.size ());
+    for (const auto &seg : segments)
+      new_segments.push_back (seg.reconstruct ());
+
+    auto *new_path
+      = new PathInExpression (std::move (new_segments), outer_attrs, locus,
+			      has_opening_scope_resolution);
+
+    return std::unique_ptr<PathInExpression> (new_path);
+  }
+
   location_t get_locus () const override final { return locus; }
 
   void accept_vis (ASTVisitor &vis) override;

gcc/rust/expand/rust-derive-cmp-common.cc

@@ -96,9 +96,10 @@ EnumMatchBuilder::tuple (EnumItem &variant_raw)
       });
     }
 
-  // TODO: Replace with `reconstruct()` instead of building these twice
   auto self_variant_path = builder.variant_path (enum_path, variant_path);
-  auto other_variant_path = builder.variant_path (enum_path, variant_path);
+  // Dereference the unique_ptr if you need the object directly,
+  // or move it if you need ownership.
+  auto other_variant_path = *self_variant_path.reconstruct ();
 
   auto self_pattern_items = std::unique_ptr<TupleStructItems> (
     new TupleStructItemsNoRest (std::move (self_patterns)));
@@ -159,9 +160,8 @@ EnumMatchBuilder::strukt (EnumItem &variant_raw)
       });
     }
 
-  // TODO: Replace with `reconstruct()` instead of building these twice
   auto self_variant_path = builder.variant_path (enum_path, variant_path);
-  auto other_variant_path = builder.variant_path (enum_path, variant_path);
+  auto other_variant_path = *self_variant_path.reconstruct ();
 
   auto self_elts = StructPatternElements (std::move (self_fields));
   auto other_elts = StructPatternElements (std::move (other_fields));