Fake PR to test the upstreaming of commit up to gerris/rebase-upstream/2026-03-18

gcc/rust/Make-lang.in

@@ -94,6 +94,7 @@ GRS_OBJS = \
     rust/rust-compile-resolve-path.o \
     rust/rust-macro-expand.o \
     rust/rust-cfg-strip.o \
+    rust/rust-early-cfg-strip.o \
     rust/rust-expand-visitor.o \
     rust/rust-ast-builder.o \
     rust/rust-derive.o \
@@ -205,6 +206,7 @@ GRS_OBJS = \
     rust/rust-hir-type-check-path.o \
     rust/rust-unsafe-checker.o \
     rust/rust-hir-pattern-analysis.o \
+    rust/rust-intrinsic-handlers.o \
     rust/rust-compile-intrinsic.o \
     rust/rust-compile-pattern.o \
     rust/rust-compile-fnparam.o \
@@ -229,6 +231,8 @@ GRS_OBJS = \
     rust/rust-builtins.o \
     rust/rust-feature.o \
     rust/rust-feature-gate.o \
+    rust/rust-feature-store.o \
+    rust/rust-feature-collector.o \
     rust/rust-ast-validation.o \
     rust/rust-dir-owner.o \
     rust/rust-unicode.o \

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

@@ -181,6 +181,11 @@ TokenCollector::visit (Attribute &attrib)
 	      visit (static_cast<AttrInputMacro &> (attrib.get_attr_input ()));
 	      break;
 	    }
+	  case AST::AttrInput::AttrInputType::EXPR:
+	    {
+	      visit (static_cast<AttrInputExpr &> (attrib.get_attr_input ()));
+	      break;
+	    }
 	  case AST::AttrInput::AttrInputType::META_ITEM:
 	    {
 	      visit (static_cast<AttrInputMetaItemContainer &> (
@@ -907,6 +912,13 @@ TokenCollector::visit (AttrInputMacro &macro)
   });
 }
 
+void
+TokenCollector::visit (AttrInputExpr &attr)
+{
+  describe_node (std::string ("AttrInputExpr"),
+		 [this, &attr] () { visit (attr.get_expr ()); });
+}
+
 void
 TokenCollector::visit (MetaItemLitExpr &item)
 {

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

@@ -292,6 +292,7 @@ class TokenCollector : public ASTVisitor
   void visit (LiteralExpr &expr);
   void visit (AttrInputLiteral &attr_input);
   void visit (AttrInputMacro &attr_input);
+  void visit (AttrInputExpr &attr_input);
   void visit (MetaItemLitExpr &meta_item);
   void visit (MetaItemPathExpr &meta_item);
   void visit (BorrowExpr &expr);

gcc/rust/ast/rust-ast-dump.cc

@@ -105,3 +105,16 @@ debug (Rust::AST::Visitable &v)
 {
   Rust::AST::Dump::debug (v);
 }
+
+void
+debug (Rust::AST::Crate &crate)
+{
+  for (auto &inner_attr : crate.get_inner_attrs ())
+    {
+      debug (inner_attr);
+    }
+  for (auto &item : crate.items)
+    {
+      debug (*item);
+    }
+}

gcc/rust/ast/rust-ast-dump.h

@@ -143,5 +143,6 @@ class Dump
 
 // In the global namespace to make it easier to call from debugger
 void debug (Rust::AST::Visitable &v);
+void debug (Rust::AST::Crate &v);
 
 #endif // !RUST_AST_DUMP_H

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

@@ -34,7 +34,7 @@ class DelimTokenTree;
 class PathSegment;
 class SimplePathSegment;
 class SimplePath;
-struct Attribute;
+class Attribute;
 class MetaItemInner;
 class AttrInputMetaItemContainer;
 class MetaItem;

gcc/rust/ast/rust-ast-visitor.cc

@@ -194,6 +194,14 @@ DefaultASTVisitor::visit (AST::LiteralExpr &expr)
   visit_outer_attrs (expr);
 }
 
+void
+DefaultASTVisitor::visit (AST::Attribute &attribute)
+{
+  visit (attribute.get_path ());
+  if (attribute.has_attr_input ())
+    visit (attribute.get_attr_input ());
+}
+
 void
 DefaultASTVisitor::visit (AST::AttrInputLiteral &attr_input)
 {
@@ -206,6 +214,12 @@ DefaultASTVisitor::visit (AST::AttrInputMacro &attr_input)
   visit (attr_input.get_macro ());
 }
 
+void
+DefaultASTVisitor::visit (AST::AttrInputExpr &attr_input)
+{
+  visit (attr_input.get_expr ());
+}
+
 void
 DefaultASTVisitor::visit (AST::MetaItemLitExpr &meta_item)
 {

gcc/rust/ast/rust-ast-visitor.h

@@ -39,6 +39,7 @@ class ASTVisitor
 
   // rust-ast.h
   // virtual void visit(AttrInput& attr_input) = 0;
+  virtual void visit (AST::Attribute &attribute) = 0;
   // virtual void visit(TokenTree& token_tree) = 0;
   // virtual void visit(MacroMatch& macro_match) = 0;
   virtual void visit (Token &tok) = 0;
@@ -72,6 +73,7 @@ class ASTVisitor
   virtual void visit (LiteralExpr &expr) = 0;
   virtual void visit (AttrInputLiteral &attr_input) = 0;
   virtual void visit (AttrInputMacro &attr_input) = 0;
+  virtual void visit (AttrInputExpr &attr_input) = 0;
   virtual void visit (MetaItemLitExpr &meta_item) = 0;
   virtual void visit (MetaItemPathExpr &meta_item) = 0;
   virtual void visit (BorrowExpr &expr) = 0;
@@ -267,6 +269,7 @@ class DefaultASTVisitor : public ASTVisitor
   virtual void visit (AST::QualifiedPathInType &path) override;
   virtual void visit (AST::LiteralExpr &expr) override;
   virtual void visit (AST::AttrInputLiteral &attr_input) override;
+  virtual void visit (AST::AttrInputExpr &attr_input) override;
   virtual void visit (AST::AttrInputMacro &attr_input) override;
   virtual void visit (AST::MetaItemLitExpr &meta_item) override;
   virtual void visit (AST::MetaItemPathExpr &meta_item) override;
@@ -444,7 +447,7 @@ class DefaultASTVisitor : public ASTVisitor
   virtual void visit (AST::StructPatternElements &spe);
   virtual void visit (AST::MaybeNamedParam &param);
 
-  void visit (AST::Attribute &attribute) {}
+  virtual void visit (AST::Attribute &attribute) override;
 
   template <typename T> void visit_outer_attrs (T &node)
   {

gcc/rust/ast/rust-ast.cc

@@ -243,6 +243,12 @@ Crate::inject_extern_crate (std::string name)
 		      {}, UNKNOWN_LOCATION)));
 }
 
+void
+Crate::inject_inner_attribute (Attribute attribute)
+{
+  inner_attrs.push_back (attribute);
+}
+
 std::string
 Attribute::as_string () const
 {
@@ -253,6 +259,12 @@ Attribute::as_string () const
     return path_str + attr_input->as_string ();
 }
 
+void
+Attribute::accept_vis (ASTVisitor &vis)
+{
+  vis.visit (*this);
+}
+
 bool
 Attribute::is_derive () const
 {
@@ -302,8 +314,9 @@ Attribute::get_traits_to_derive ()
 			auto word = static_cast<AST::MetaWord *> (meta_item);
 			// Convert current word to path
 			current = std::make_unique<AST::MetaItemPath> (
-			  AST::MetaItemPath (
-			    AST::SimplePath (word->get_ident ())));
+			  AST::MetaItemPath (AST::SimplePath::from_str (
+			    word->get_ident ().as_string (),
+			    word->get_locus ())));
 			auto path
 			  = static_cast<AST::MetaItemPath *> (current.get ());
 
@@ -332,6 +345,7 @@ Attribute::get_traits_to_derive ()
     case AST::AttrInput::TOKEN_TREE:
     case AST::AttrInput::LITERAL:
     case AST::AttrInput::MACRO:
+    case AST::AttrInput::EXPR:
       rust_unreachable ();
       break;
     }
@@ -3340,6 +3354,29 @@ AttrInputMetaItemContainer::as_string () const
   return str + ")";
 }
 
+AttrInputExpr::AttrInputExpr (const AttrInputExpr &oth)
+  : expr (oth.expr->clone_expr ())
+{}
+
+AttrInputExpr &
+AttrInputExpr::operator= (const AttrInputExpr &oth)
+{
+  expr = oth.expr->clone_expr ();
+  return *this;
+}
+
+std::string
+AttrInputExpr::as_string () const
+{
+  return expr->as_string ();
+}
+
+void
+AttrInputExpr::accept_vis (ASTVisitor &vis)
+{
+  vis.visit (*this);
+}
+
 std::string
 AttrInputMacro::as_string () const
 {
@@ -4169,10 +4206,8 @@ MetaListNameValueStr::to_attribute () const
 Attribute
 MetaItemPathExpr::to_attribute () const
 {
-  rust_assert (expr->is_literal ());
-  auto &lit = static_cast<LiteralExpr &> (*expr);
-  return Attribute (path, std::unique_ptr<AttrInputLiteral> (
-			    new AttrInputLiteral (lit)));
+  auto input = std::make_unique<AttrInputExpr> (expr->clone_expr ());
+  return Attribute (path, std::move (input));
 }
 
 std::vector<Attribute>
@@ -4188,13 +4223,9 @@ AttrInputMetaItemContainer::separate_cfg_attrs () const
 
   for (auto it = items.begin () + 1; it != items.end (); ++it)
     {
-      if ((*it)->get_kind () == MetaItemInner::Kind::MetaItem
-	  && static_cast<MetaItem &> (**it).get_item_kind ()
-	       == MetaItem::ItemKind::PathExpr
-	  && !static_cast<MetaItemPathExpr &> (**it).get_expr ().is_literal ())
-	continue;
+      auto &item = **it;
 
-      Attribute attr = (*it)->to_attribute ();
+      Attribute attr = item.to_attribute ();
       if (attr.is_empty ())
 	{
 	  /* TODO should this be an error that causes us to chuck out

gcc/rust/ast/rust-ast.h

@@ -26,6 +26,7 @@
 #include "rust-location.h"
 #include "rust-diagnostics.h"
 #include "rust-keyword-values.h"
+#include "rust-cloneable.h"
 
 namespace Rust {
 // TODO: remove typedefs and make actual types for these
@@ -565,9 +566,8 @@ struct Visibility
 
 // aka Attr
 // Attribute AST representation
-struct Attribute
+class Attribute : public Visitable
 {
-private:
   SimplePath path;
 
   // bool has_attr_input;
@@ -577,6 +577,8 @@ struct Attribute
 
   bool inner_attribute;
 
+  NodeId node_id;
+
   // TODO: maybe a variable storing whether attr input is parsed or not
 
 public:
@@ -587,7 +589,8 @@ struct Attribute
   Attribute (SimplePath path, std::unique_ptr<AttrInput> input,
 	     location_t locus = UNDEF_LOCATION, bool inner_attribute = false)
     : path (std::move (path)), attr_input (std::move (input)), locus (locus),
-      inner_attribute (inner_attribute)
+      inner_attribute (inner_attribute),
+      node_id (Analysis::Mappings::get ().get_next_node_id ())
   {}
 
   bool is_derive () const;
@@ -685,11 +688,13 @@ struct Attribute
 
   bool is_inner_attribute () const { return inner_attribute; }
 
-  // no visitor pattern as not currently polymorphic
+  void accept_vis (ASTVisitor &vis) override;
 
   const SimplePath &get_path () const { return path; }
   SimplePath &get_path () { return path; }
 
+  NodeId get_node_id () { return node_id; }
+
   // Call to parse attribute body to meta item syntax.
   void parse_attr_to_meta_item ();
 
@@ -719,6 +724,7 @@ class AttrInput : public Visitable
 public:
   enum AttrInputType
   {
+    EXPR,
     LITERAL,
     MACRO,
     META_ITEM,
@@ -2117,6 +2123,7 @@ struct Crate final : public GlobContainer
   }
 
   void inject_extern_crate (std::string name);
+  void inject_inner_attribute (Attribute attribute);
 
   NodeId get_node_id () const { return node_id; }
   const std::vector<Attribute> &get_inner_attrs () const { return inner_attrs; }
@@ -2139,6 +2146,19 @@ struct Crate final : public GlobContainer
 };
 
 } // namespace AST
+
+template <> struct CloneableDelegate<std::unique_ptr<AST::Pattern>>
+{
+  static std::unique_ptr<AST::Pattern>
+  clone (const std::unique_ptr<AST::Pattern> &other)
+  {
+    if (other == nullptr)
+      return nullptr;
+    else
+      return other->clone_pattern ();
+  }
+};
+
 } // namespace Rust
 
 namespace std {

gcc/rust/ast/rust-expr.h

@@ -169,6 +169,47 @@ class AttrInputLiteral : public AttrInput
   }
 };
 
+class AttrInputExpr : public AttrInput
+{
+  std::unique_ptr<Expr> expr;
+
+public:
+  AttrInputExpr (std::unique_ptr<Expr> expr) : expr (std::move (expr)) {}
+
+  AttrInputExpr (const AttrInputExpr &oth);
+
+  AttrInputExpr (AttrInputExpr &&oth) : expr (std::move (oth.expr)) {}
+
+  AttrInputType get_attr_input_type () const final override
+  {
+    return AttrInput::AttrInputType::EXPR;
+  }
+
+  AttrInputExpr &operator= (const AttrInputExpr &oth);
+
+  AttrInputExpr &operator= (AttrInputExpr &&oth)
+  {
+    expr = std::move (oth.expr);
+    return *this;
+  }
+
+  std::string as_string () const override;
+
+  void accept_vis (ASTVisitor &vis) override;
+
+  bool check_cfg_predicate (const Session &) const override { return false; }
+
+  // assuming this is like AttrInputLiteral
+  bool is_meta_item () const override { return false; }
+
+  Expr &get_expr () { return *expr; }
+
+  AttrInputExpr *clone_attr_input_impl () const override
+  {
+    return new AttrInputExpr (*this);
+  }
+};
+
 // Like an AttrInputLiteral, but stores a MacroInvocation
 class AttrInputMacro : public AttrInput
 {