derive: Implement reconstruct_path helper for cmp

This patch introduces a local helper  to clone
PathInExpression objects. This allows removing duplicate calls to
, fulfilling the TODOs in EnumMatchBuilder.
This ensures the self and other paths are identical without reconstructing
them from strings twice.

gcc/rust/ChangeLog:

	* expand/rust-derive-cmp-common.cc (reconstruct_path): New helper.
	(EnumMatchBuilder::tuple): Use reconstruct_path.
	(EnumMatchBuilder::strukt): Use reconstruct_path.

Signed-off-by: Jayant Chauhan <[email protected]>

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,19 @@ 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 = reconstruct_path (self_variant_path);
 
   auto self_elts = StructPatternElements (std::move (self_fields));
   auto other_elts = StructPatternElements (std::move (other_fields));