stash

Author: powerboat9

gcc/rust/Make-lang.in

@@ -146,6 +146,7 @@ GRS_OBJS = \
 	rust/rust-finalize-imports-2.0.o \
 	rust/rust-ice-finalizer.o \
     rust/rust-late-name-resolver-2.0.o \
+    rust/rust-identifier-path.o \
 	rust/rust-immutable-name-resolution-context.o \
     rust/rust-name-resolver.o \
     rust/rust-resolve-builtins.o \

gcc/rust/resolve/rust-identifier-path.cc

@@ -0,0 +1,66 @@
+// Copyright (C) 2026 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-system.h"
+#include "rust-identifier-path.h"
+#include "rust-pattern.h"
+
+namespace Rust {
+namespace Resolver2_0 {
+
+IdentifierPathPass::IdentifierPathPass (
+  NameResolutionContext &ctx, std::map<Usage, Definition> expected_mappings)
+  : ctx (&ctx), expected_mappings (std::move (expected_mappings))
+{}
+
+void
+IdentifierPathPass::go (AST::Crate &crate, NameResolutionContext &ctx,
+			std::map<Usage, Definition> expected_mappings)
+{
+  IdentifierPathPass pass (ctx, std::move (expected_mappings));
+  pass.visit (crate);
+}
+
+void
+IdentifierPathPass::reseat (std::unique_ptr<AST::Pattern> &ptr)
+{
+  AST::IdentifierPattern *ident_pat;
+  if (ptr->get_pattern_kind () == AST::Pattern::Kind::Identifier)
+    ident_pat = static_cast<AST::IdentifierPattern *> (ptr.get ());
+  else
+    return;
+
+  auto expected_it = expected_mappings.find (Usage (ident_pat->get_node_id ()));
+
+  if (expected_it != expected_mappings.end ())
+    {
+      auto def = expected_it->second;
+
+      std::vector<AST::PathExprSegment> segments;
+      segments.emplace_back (ident_pat->get_ident ().as_string (),
+			     ident_pat->get_locus ());
+      ctx->map_usage (Usage (segments.back ().get_node_id ()), def);
+      ptr = std::make_unique<AST::PathInExpression> (
+	std::move (segments), std::vector<AST::Attribute> (),
+	ident_pat->get_locus ());
+      ctx->map_usage (Usage (ptr->get_node_id ()), def);
+    }
+}
+
+} // namespace Resolver2_0
+} // namespace Rust

gcc/rust/resolve/rust-identifier-path.h

@@ -0,0 +1,50 @@
+// Copyright (C) 2026 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef RUST_RESOLVE_IDENTIFIER_PATH_H
+#define RUST_RESOLVE_IDENTIFIER_PATH_H
+
+#include "rust-ast-pointer-visitor.h"
+#include "rust-name-resolution-context.h"
+
+namespace Rust {
+namespace Resolver2_0 {
+
+// changes IdentifierPattern instances to PathInExpression instances
+class IdentifierPathPass : public AST::PointerVisitor
+{
+public:
+  IdentifierPathPass (NameResolutionContext &ctx,
+		      std::map<Usage, Definition> expected_mappings);
+
+  static void go (AST::Crate &crate, NameResolutionContext &ctx,
+		  std::map<Usage, Definition> expected_mappings);
+
+  using AST::PointerVisitor::reseat;
+
+  void reseat (std::unique_ptr<AST::Pattern> &ptr) override;
+
+private:
+  NameResolutionContext *ctx;
+  std::map<Usage, Definition> expected_mappings;
+};
+
+} // namespace Resolver2_0
+} // namespace Rust
+
+#endif // ! RUST_RESOLVE_IDENTIFIER_PATH_H

gcc/rust/resolve/rust-late-name-resolver-2.0.cc

@@ -31,6 +31,7 @@
 #include "rust-hir-type-check.h"
 #include "rust-ice-finalizer.h"
 #include "rust-ast.h"
+#include "rust-identifier-path.h"
 
 namespace Rust {
 namespace Resolver2_0 {
@@ -45,6 +46,8 @@ Late::go (AST::Crate &crate)
   Builtins::setup_type_ctx ();
 
   visit (crate);
+
+  IdentifierPathPass::go (crate, ctx, std::move (expected_mappings));
 }
 
 void
@@ -204,6 +207,28 @@ Late::visit (AST::IdentifierPattern &identifier)
 {
   DefaultResolver::visit (identifier);
 
+  // check if this is *really* a path pattern
+  if (!identifier.get_is_ref () && !identifier.get_is_mut ()
+      && !identifier.has_subpattern ())
+    {
+      auto res = ctx.values.get (identifier.get_ident ());
+      if (res)
+	{
+	  rust_debug_loc (identifier.get_locus (), "RESOLVING %d to %d",
+			  (int) identifier.get_node_id (),
+			  (int) res->get_node_id ());
+	  if (res->is_ambiguous ())
+	    rust_error_at (identifier.get_locus (), ErrorCode::E0659,
+			   "%qs is ambiguous",
+			   identifier.get_ident ().as_string ().c_str ());
+	  else
+	    expected_mappings.insert (
+	      std::make_pair (Usage (identifier.get_node_id ()),
+			      Definition (res->get_node_id ())));
+	  return;
+	}
+    }
+
   visit_identifier_as_pattern (ctx, identifier.get_ident (),
 			       identifier.get_locus (),
 			       identifier.get_node_id (),

gcc/rust/resolve/rust-late-name-resolver-2.0.h

@@ -79,6 +79,9 @@ class Late : public DefaultResolver
 
   /* used to prevent "impl Self {}", "impl (Self, i32) {}", etc */
   bool block_big_self;
+
+  /* used to help conversion from IdentifierPattern to PathInExpression */
+  std::map<Usage, Definition> expected_mappings;
 };
 
 // TODO: Add missing mappings and data structures

gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc

@@ -309,6 +309,8 @@ TopLevel::visit (AST::TupleStruct &tuple_struct)
 void
 TopLevel::visit (AST::EnumItem &variant)
 {
+  rust_debug_loc (variant.get_locus (), "ITEM %d",
+		  (int) variant.get_node_id ());
   insert_enum_variant_or_error_out (variant.get_identifier (), variant);
 
   DefaultResolver::visit (variant);
@@ -317,6 +319,8 @@ TopLevel::visit (AST::EnumItem &variant)
 void
 TopLevel::visit (AST::EnumItemTuple &variant)
 {
+  rust_debug_loc (variant.get_locus (), "ITEM %d",
+		  (int) variant.get_node_id ());
   insert_enum_variant_or_error_out (variant.get_identifier (), variant);
 
   DefaultResolver::visit (variant);
@@ -325,6 +329,8 @@ TopLevel::visit (AST::EnumItemTuple &variant)
 void
 TopLevel::visit (AST::EnumItemStruct &variant)
 {
+  rust_debug_loc (variant.get_locus (), "ITEM %d",
+		  (int) variant.get_node_id ());
   insert_enum_variant_or_error_out (variant.get_identifier (), variant);
 
   DefaultResolver::visit (variant);
@@ -333,6 +339,8 @@ TopLevel::visit (AST::EnumItemStruct &variant)
 void
 TopLevel::visit (AST::EnumItemDiscriminant &variant)
 {
+  rust_debug_loc (variant.get_locus (), "ITEM %d",
+		  (int) variant.get_node_id ());
   insert_or_error_out (variant.get_identifier (), variant, Namespace::Types);
 
   DefaultResolver::visit (variant);

gcc/rust/typecheck/rust-hir-type-check-path.cc

@@ -335,6 +335,8 @@ TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset,
 	= mappings.lookup_hir_enumitem (ref);
       bool is_enum_item = enum_item_lookup.first != nullptr
 			  && enum_item_lookup.second != nullptr;
+      rust_debug_loc (mappings.lookup_location (ref), "is enum? %s",
+		      is_enum_item ? "yes" : "no");
       if (is_enum_item)
 	{
 	  HirId expr_id = expr.get_mappings ().get_hirid ();

gcc/testsuite/rust/execute/ident_pat_vs_path.rs

@@ -0,0 +1,26 @@
+// { dg-additional-options '-w' }
+#![no_core]
+
+enum E {
+    A,
+    B,
+    C
+}
+
+fn main() -> i32 {
+    use E::C;
+
+    let v1 = match E::A {
+        C => 1,
+        E::A => 0,
+        E::B => 1
+    };
+
+    let v2 = match E::A {
+        B => 0,
+        E::A => 1,
+        C => 1
+    };
+
+    v1 + v2
+}