Fake PR to test the upstreaming of commit up to gerris/upstream/2025-09-09

contrib/gcc-changelog/git_commit.py

@@ -150,6 +150,7 @@
     'gcc/testsuite/go.test/test/',
     'libffi/',
     'libgo/',
+    'libgrust/rustc-lib/core/',
     'libphobos/libdruntime/',
     'libphobos/src/',
     'libsanitizer/',

gcc/rust/ChangeLog

@@ -5197,7 +5197,7 @@
 
 2025-03-21  Owen Avery  <[email protected]>
 
-	* resolve/rust-name-resolver.cc: Include options.txt.
+	* resolve/rust-name-resolver.cc: Include options.h.
 	(Resolver::insert_resolved_name): Assert that name resolution
 	2.0 is disabled.
 	(Resolver::lookup_resolved_name): Likewise.

gcc/rust/Make-lang.in

@@ -84,6 +84,7 @@ GRS_OBJS = \
     rust/rust-ast-dump.o \
     rust/rust-ast-collector.o \
     rust/rust-ast-visitor.o \
+    rust/rust-ast-pointer-visitor.o \
     rust/rust-hir-visitor.o \
     rust/rust-hir-dump.o \
     rust/rust-session-manager.o \
@@ -149,15 +150,7 @@ GRS_OBJS = \
 	rust/rust-immutable-name-resolution-context.o \
     rust/rust-early-name-resolver.o \
     rust/rust-name-resolver.o \
-    rust/rust-ast-resolve.o \
-    rust/rust-ast-resolve-base.o \
-    rust/rust-ast-resolve-item.o \
-    rust/rust-ast-resolve-pattern.o \
-    rust/rust-ast-resolve-expr.o \
-    rust/rust-ast-resolve-type.o \
-    rust/rust-ast-resolve-path.o \
-    rust/rust-ast-resolve-stmt.o \
-    rust/rust-ast-resolve-struct-expr-field.o \
+    rust/rust-resolve-builtins.o \
     rust/rust-forever-stack.o \
     rust/rust-hir-type-check.o \
     rust/rust-privacy-check.o \
@@ -209,7 +202,6 @@ GRS_OBJS = \
     rust/rust-lint-marklive.o \
     rust/rust-lint-unused-var.o \
     rust/rust-readonly-check.o \
-    rust/rust-readonly-check2.o \
     rust/rust-hir-type-check-path.o \
     rust/rust-unsafe-checker.o \
     rust/rust-hir-pattern-analysis.o \

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

@@ -554,12 +554,12 @@ std::unique_ptr<GenericParam>
 Builder::new_lifetime_param (LifetimeParam &param)
 {
   Lifetime l = new_lifetime (param.get_lifetime ());
+
   std::vector<Lifetime> lifetime_bounds;
+  lifetime_bounds.reserve (param.get_lifetime_bounds ().size ());
+
   for (auto b : param.get_lifetime_bounds ())
-    {
-      Lifetime bl = new_lifetime (b);
-      lifetime_bounds.push_back (bl);
-    }
+    lifetime_bounds.emplace_back (new_lifetime (b));
 
   auto p = new LifetimeParam (l, std::move (lifetime_bounds),
 			      param.get_outer_attrs (), param.get_locus ());
@@ -605,11 +605,11 @@ Builder::new_type_param (
 	    for (const auto &lifetime : tb.get_for_lifetimes ())
 	      {
 		std::vector<Lifetime> lifetime_bounds;
+		lifetime_bounds.reserve (
+		  lifetime.get_lifetime_bounds ().size ());
+
 		for (const auto &b : lifetime.get_lifetime_bounds ())
-		  {
-		    Lifetime bl = new_lifetime (b);
-		    lifetime_bounds.push_back (std::move (bl));
-		  }
+		  lifetime_bounds.emplace_back (new_lifetime (b));
 
 		Lifetime nl = new_lifetime (lifetime.get_lifetime ());
 		LifetimeParam p (std::move (nl), std::move (lifetime_bounds),
@@ -626,12 +626,11 @@ Builder::new_type_param (
 		    {
 		      const TypePathSegment &segment
 			= (const TypePathSegment &) (*seg.get ());
-		      TypePathSegment *s = new TypePathSegment (
+
+		      segments.emplace_back (new TypePathSegment (
 			segment.get_ident_segment (),
 			segment.get_separating_scope_resolution (),
-			segment.get_locus ());
-		      std::unique_ptr<TypePathSegment> sg (s);
-		      segments.push_back (std::move (sg));
+			segment.get_locus ()));
 		    }
 		    break;
 
@@ -642,11 +641,10 @@ Builder::new_type_param (
 
 		      GenericArgs args
 			= new_generic_args (generic.get_generic_args ());
-		      TypePathSegmentGeneric *s = new TypePathSegmentGeneric (
+
+		      segments.emplace_back (new TypePathSegmentGeneric (
 			generic.get_ident_segment (), false, std::move (args),
-			generic.get_locus ());
-		      std::unique_ptr<TypePathSegment> sg (s);
-		      segments.push_back (std::move (sg));
+			generic.get_locus ()));
 		    }
 		    break;
 
@@ -664,23 +662,19 @@ Builder::new_type_param (
 	    TypePath p (std::move (segments), path.get_locus (),
 			path.has_opening_scope_resolution_op ());
 
-	    TraitBound *b = new TraitBound (std::move (p), tb.get_locus (),
-					    tb.is_in_parens (),
-					    tb.has_opening_question_mark (),
-					    std::move (for_lifetimes));
-	    std::unique_ptr<TypeParamBound> bound (b);
-	    type_param_bounds.push_back (std::move (bound));
+	    type_param_bounds.emplace_back (new TraitBound (
+	      std::move (p), tb.get_locus (), tb.is_in_parens (),
+	      tb.has_opening_question_mark (), std::move (for_lifetimes)));
 	  }
 	  break;
 
 	case TypeParamBound::TypeParamBoundType::LIFETIME:
 	  {
 	    const Lifetime &l = (const Lifetime &) *b.get ();
 
-	    auto bl = new Lifetime (l.get_lifetime_type (),
-				    l.get_lifetime_name (), l.get_locus ());
-	    std::unique_ptr<TypeParamBound> bound (bl);
-	    type_param_bounds.push_back (std::move (bound));
+	    type_param_bounds.emplace_back (
+	      new Lifetime (l.get_lifetime_type (), l.get_lifetime_name (),
+			    l.get_locus ()));
 	  }
 	  break;
 	}
@@ -709,18 +703,14 @@ Builder::new_generic_args (GenericArgs &args)
   location_t locus = args.get_locus ();
 
   for (const auto &lifetime : args.get_lifetime_args ())
-    {
-      Lifetime l = new_lifetime (lifetime);
-      lifetime_args.push_back (std::move (l));
-    }
+    lifetime_args.push_back (new_lifetime (lifetime));
 
   for (auto &binding : args.get_binding_args ())
     {
       Type &t = *binding.get_type_ptr ().get ();
       std::unique_ptr<Type> ty = t.reconstruct ();
-      GenericArgsBinding b (binding.get_identifier (), std::move (ty),
-			    binding.get_locus ());
-      binding_args.push_back (std::move (b));
+      binding_args.emplace_back (binding.get_identifier (), std::move (ty),
+				 binding.get_locus ());
     }
 
   for (auto &arg : args.get_generic_args ())

gcc/rust/ast/rust-ast-collector.cc

@@ -76,13 +76,13 @@ TokenCollector::trailing_comma ()
 void
 TokenCollector::newline ()
 {
-  tokens.push_back ({CollectItem::Kind::Newline});
+  tokens.emplace_back (CollectItem::Kind::Newline);
 }
 
 void
 TokenCollector::indentation ()
 {
-  tokens.push_back ({indent_level});
+  tokens.emplace_back (indent_level);
 }
 
 void
@@ -101,7 +101,7 @@ TokenCollector::decrement_indentation ()
 void
 TokenCollector::comment (std::string comment)
 {
-  tokens.push_back ({comment});
+  tokens.emplace_back (comment);
 }
 
 void
@@ -355,7 +355,8 @@ TokenCollector::visit (MaybeNamedParam &param)
 void
 TokenCollector::visit (Token &tok)
 {
-  std::string data = tok.get_tok_ptr ()->has_str () ? tok.get_str () : "";
+  std::string data
+    = tok.get_tok_ptr ()->should_have_str () ? tok.get_str () : "";
   switch (tok.get_id ())
     {
     case IDENTIFIER:
@@ -2649,13 +2650,13 @@ TokenCollector::visit (StructPattern &pattern)
 // void TokenCollector::visit(TupleStructItems& ){}
 
 void
-TokenCollector::visit (TupleStructItemsNoRange &pattern)
+TokenCollector::visit (TupleStructItemsNoRest &pattern)
 {
   visit_items_joined_by_separator (pattern.get_patterns ());
 }
 
 void
-TokenCollector::visit (TupleStructItemsRange &pattern)
+TokenCollector::visit (TupleStructItemsHasRest &pattern)
 {
   for (auto &lower : pattern.get_lower_patterns ())
     {
@@ -2682,13 +2683,13 @@ TokenCollector::visit (TupleStructPattern &pattern)
 // {}
 
 void
-TokenCollector::visit (TuplePatternItemsMultiple &pattern)
+TokenCollector::visit (TuplePatternItemsNoRest &pattern)
 {
   visit_items_joined_by_separator (pattern.get_patterns (), COMMA);
 }
 
 void
-TokenCollector::visit (TuplePatternItemsRanged &pattern)
+TokenCollector::visit (TuplePatternItemsHasRest &pattern)
 {
   for (auto &lower : pattern.get_lower_patterns ())
     {

gcc/rust/ast/rust-ast-collector.h

@@ -370,12 +370,12 @@ class TokenCollector : public ASTVisitor
   void visit (StructPatternFieldIdent &field);
   void visit (StructPattern &pattern);
   // void visit(TupleStructItems& tuple_items);
-  void visit (TupleStructItemsNoRange &tuple_items);
-  void visit (TupleStructItemsRange &tuple_items);
+  void visit (TupleStructItemsNoRest &tuple_items);
+  void visit (TupleStructItemsHasRest &tuple_items);
   void visit (TupleStructPattern &pattern);
   // void visit(TuplePatternItems& tuple_items);
-  void visit (TuplePatternItemsMultiple &tuple_items);
-  void visit (TuplePatternItemsRanged &tuple_items);
+  void visit (TuplePatternItemsNoRest &tuple_items);
+  void visit (TuplePatternItemsHasRest &tuple_items);
   void visit (TuplePattern &pattern);
   void visit (GroupedPattern &pattern);
   void visit (SlicePatternItemsNoRest &items);

gcc/rust/ast/rust-ast-formatting.h

@@ -19,6 +19,9 @@
 #ifndef RUST_AST_FORMATTING_H
 #define RUST_AST_FORMATTING_H
 
+#include "rust-ast.h"
+#include "rust-system.h"
+
 namespace Rust {
 namespace AST {
 

gcc/rust/ast/rust-ast-fragment.cc

@@ -107,29 +107,42 @@ Fragment::should_expand () const
 bool
 Fragment::is_expression_fragment () const
 {
-  return is_single_fragment_of_kind (SingleASTNode::NodeType::EXPRESSION);
+  return is_single_fragment_of_kind (SingleASTNode::Kind::Expr);
 }
 
 bool
 Fragment::is_type_fragment () const
 {
-  return is_single_fragment_of_kind (SingleASTNode::NodeType::TYPE);
+  return is_single_fragment_of_kind (SingleASTNode::Kind::Type);
+}
+
+bool
+Fragment::is_pattern_fragment () const
+{
+  return is_single_fragment_of_kind (SingleASTNode::Kind::Pattern);
 }
 
 std::unique_ptr<Expr>
 Fragment::take_expression_fragment ()
 {
-  assert_single_fragment (SingleASTNode::NodeType::EXPRESSION);
+  assert_single_fragment (SingleASTNode::Kind::Expr);
   return nodes[0].take_expr ();
 }
 
 std::unique_ptr<Type>
 Fragment::take_type_fragment ()
 {
-  assert_single_fragment (SingleASTNode::NodeType::TYPE);
+  assert_single_fragment (SingleASTNode::Kind::Type);
   return nodes[0].take_type ();
 }
 
+std::unique_ptr<Pattern>
+Fragment::take_pattern_fragment ()
+{
+  assert_single_fragment (SingleASTNode::Kind::Pattern);
+  return nodes[0].take_pattern ();
+}
+
 void
 Fragment::accept_vis (ASTVisitor &vis)
 {
@@ -144,21 +157,22 @@ Fragment::is_single_fragment () const
 }
 
 bool
-Fragment::is_single_fragment_of_kind (SingleASTNode::NodeType expected) const
+Fragment::is_single_fragment_of_kind (SingleASTNode::Kind expected) const
 {
   return is_single_fragment () && nodes[0].get_kind () == expected;
 }
 
 void
-Fragment::assert_single_fragment (SingleASTNode::NodeType expected) const
-{
-  static const std::map<SingleASTNode::NodeType, const char *> str_map = {
-    {SingleASTNode::NodeType::ASSOC_ITEM, "associated item"},
-    {SingleASTNode::NodeType::ITEM, "item"},
-    {SingleASTNode::NodeType::TYPE, "type"},
-    {SingleASTNode::NodeType::EXPRESSION, "expr"},
-    {SingleASTNode::NodeType::STMT, "stmt"},
-    {SingleASTNode::NodeType::EXTERN, "extern"},
+Fragment::assert_single_fragment (SingleASTNode::Kind expected) const
+{
+  static const std::map<SingleASTNode::Kind, const char *> str_map = {
+    {SingleASTNode::Kind::Assoc, "associated item"},
+    {SingleASTNode::Kind::Item, "item"},
+    {SingleASTNode::Kind::Type, "type"},
+    {SingleASTNode::Kind::Expr, "expr"},
+    {SingleASTNode::Kind::Stmt, "stmt"},
+    {SingleASTNode::Kind::Extern, "extern"},
+    {SingleASTNode::Kind::Pattern, "pattern"},
   };
 
   auto actual = nodes[0].get_kind ();

gcc/rust/ast/rust-ast-fragment.h

@@ -86,9 +86,11 @@ class Fragment
 
   bool is_expression_fragment () const;
   bool is_type_fragment () const;
+  bool is_pattern_fragment () const;
 
   std::unique_ptr<Expr> take_expression_fragment ();
   std::unique_ptr<Type> take_type_fragment ();
+  std::unique_ptr<Pattern> take_pattern_fragment ();
 
   void accept_vis (ASTVisitor &vis);
 
@@ -119,8 +121,8 @@ class Fragment
    * one Node will be extracted from the `nodes` vector
    */
   bool is_single_fragment () const;
-  bool is_single_fragment_of_kind (SingleASTNode::NodeType expected) const;
-  void assert_single_fragment (SingleASTNode::NodeType expected) const;
+  bool is_single_fragment_of_kind (SingleASTNode::Kind expected) const;
+  void assert_single_fragment (SingleASTNode::Kind expected) const;
 };
 
 enum class InvocKind

gcc/rust/ast/rust-ast-full-decls.h

@@ -240,12 +240,12 @@ class StructPatternFieldIdent;
 class StructPatternElements;
 class StructPattern;
 class TupleStructItems;
-class TupleStructItemsNoRange;
-class TupleStructItemsRange;
+class TupleStructItemsNoRest;
+class TupleStructItemsHasRest;
 class TupleStructPattern;
 class TuplePatternItems;
-class TuplePatternItemsMultiple;
-class TuplePatternItemsRanged;
+class TuplePatternItemsNoRest;
+class TuplePatternItemsHasRest;
 class TuplePattern;
 class GroupedPattern;
 class SlicePatternItemsNoRest;