P3385

P3385.md

@@ -0,0 +1,72 @@
+# Attributes reflection (P3385)
+
+## Support
+
+- Standard attribute
+- String literal attribute argument
+
+## Implementation note
+
+### Syntactic to semantic attribute
+
+In different places we need to traverse back to syntactic attributes from semantic ones, after they were attached to constructs. This happen when for example we write
+
+```cpp
+struct [[nodiscard("yep"), deprecated("dont use me")]] Foo {};
+constexpr auto r = ^^ Foo;
+enum class [[ [: r :] ]] E { /* stuff */ };
+```
+
+At this point `r` expose `Attr`, not `ParsedAtr`.
+As a workaround we add a link back to the syntactic form from the semantic one. The backlink is something we make available in the `Attr` class *but* it is not always the case that we set that backlink.
+
+    Why ? The practical use case of traversing back to the syntactic form is (so far) to easily retrieve the arguments, and because we only want to demonstrate support of string arguments for standard attributes, we only set those backlinks in two cases: `[[nodiscard("arg")]]` and `[[deprecated("arg")]]`.
+
+With that "design", the challenge becomes to keep those syntactic pieces alive longer than they should, and the clutch we went with is this _thing_
+
+```cpp
+struct AttributeScratchpad {
+  AttributeFactory factory;
+  ParsedAttributes attributes;
+  ArgsVector ArgExprs;
+  bool argFound;
+  AttributeScratchpad() : factory(), attributes(factory), ArgExprs(), argFound(false) {}
+};
+```
+
+The idea is to keep that `AttributeFactory` alive and hopefully the parsed attributes they own arent falling off the map. Then when we create a semantic attribute, we make sure to have a static-ish syntactic version we can refer to, for ex in the handling of `[[nodiscard]]`
+
+```cpp
+  // AL is the parsedAttribute
+  static struct AttributeScratchpad {
+    AttributeFactory factory;
+    ParsedAttributes attributes;
+    ArgsVector ArgExprs;
+    bool argFound;
+    AttributeScratchpad() : factory(), attributes(factory), ArgExprs(), argFound(false) {}
+  } scratchpad;
+  if (scratchpad.argFound = AL.getNumArgs() != 0; scratchpad.argFound) {
+    scratchpad.ArgExprs.push_back(AL.getArg(0));
+  } else {
+    scratchpad.ArgExprs.clear();
+  }
+  auto * stashedSyntacticAttribute = scratchpad.attributes.addNew(
+    const_cast<IdentifierInfo*>(AL.getAttrName()),
+    AL.getRange(),
+    nullptr,
+    AL.getLoc(),
+    scratchpad.ArgExprs.data(), scratchpad.argFound,
+    AL.getForm()
+  );
+
+  D->addAttr(::new (S.Context) DeprecatedAttr(S.Context, AL, Str, Replacement), stashedSyntacticAttribute);
+```
+
+#### Alternative
+
+The hack above is quite terrible, especially because in the end we're only doing it to get back our args...
+Some alternatives are
+
+- Lift: Lift the `ArgsVector` up into the `Attr` class
+- Codegen: Augment the codegen in `ClangAttrEmitter` to offer an implementation for `getArgs()` defined virtually in base `Attr` (Thx Dan).
+- condition-a-looza: When we get back an `Attr*` we can do a bunch of `if (WarnUnusedResultAttr::classOf(attr)) { /* cast to WarnUnusedResultAttr*...` then we call the relevant getter `attr->getMessage()`

clang/include/clang/AST/APValue.h

@@ -40,6 +40,7 @@ template <typename T> class BasicReaderBase;
   class Expr;
   class FieldDecl;
   class NamespaceDecl;
+  class ParsedAttr;
   struct PrintingPolicy;
   class Type;
   class ValueDecl;
@@ -489,6 +490,10 @@ class APValue {
     return isReflection() && getReflectionKind() == ReflectionKind::Annotation;
   }
 
+  bool isReflectedAttribute() const {
+    return isReflection() && getReflectionKind() == ReflectionKind::Attribute;
+  }
+
   void dump() const;
   void dump(raw_ostream &OS, const ASTContext &Context) const;
 
@@ -678,6 +683,7 @@ class APValue {
   CXXBaseSpecifier *getReflectedBaseSpecifier() const;
   TagDataMemberSpec *getReflectedDataMemberSpec() const;
   CXX26AnnotationAttr *getReflectedAnnotation() const;
+  ParsedAttr *getReflectedAttribute() const;
 
   void setInt(APSInt I) {
     assert(isInt() && "Invalid accessor");

clang/include/clang/AST/Attr.h

@@ -37,6 +37,7 @@ class ASTContext;
 class AttributeCommonInfo;
 class FunctionDecl;
 class OMPTraitInfo;
+class ParsedAttr;
 
 /// Attr - This represents one attribute.
 class Attr : public AttributeCommonInfo {
@@ -60,6 +61,8 @@ class Attr : public AttributeCommonInfo {
   LLVM_PREFERRED_TYPE(bool)
   unsigned InheritEvenIfAlreadyPresent : 1;
 
+  const ParsedAttr* Backlink;
+
   void *operator new(size_t bytes) noexcept {
     llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
   }
@@ -82,7 +85,7 @@ class Attr : public AttributeCommonInfo {
        attr::Kind AK, bool IsLateParsed)
       : AttributeCommonInfo(CommonInfo), AttrKind(AK), Inherited(false),
         IsPackExpansion(false), Implicit(false), IsLateParsed(IsLateParsed),
-        InheritEvenIfAlreadyPresent(false) {}
+        InheritEvenIfAlreadyPresent(false), Backlink(nullptr) {}
 
 public:
   attr::Kind getKind() const { return static_cast<attr::Kind>(AttrKind); }
@@ -109,6 +112,16 @@ class Attr : public AttributeCommonInfo {
 
   bool isLateParsed() const { return IsLateParsed; }
 
+  // Backlink to the syntactic form of the attribute
+  const ParsedAttr* fromParsedAttr() const { return Backlink; }
+
+  // FIXME p3385, garbage design
+  void setParsedAttr(const ParsedAttr* parsedAttr) {
+    // Note that backlink can be null (for delayed splice attribute for ex)
+    assert(Backlink == nullptr && "backlink should not be reassigned");
+    Backlink = parsedAttr;
+  }
+
   // Pretty print this attribute.
   void printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const;
 

clang/include/clang/AST/DeclBase.h

@@ -57,6 +57,7 @@ class Module;
 class NamedDecl;
 class ObjCContainerDecl;
 class ObjCMethodDecl;
+class ParsedAttr;
 struct PrintingPolicy;
 class RecordDecl;
 class SourceManager;
@@ -535,6 +536,8 @@ class alignas(8) Decl {
   const AttrVec &getAttrs() const;
   void dropAttrs();
   void addAttr(Attr *A);
+  void addAttr(Attr *A, const ParsedAttr* pA);
+
 
   using attr_iterator = AttrVec::const_iterator;
   using attr_range = llvm::iterator_range<attr_iterator>;

clang/include/clang/AST/ExprCXX.h

@@ -5321,7 +5321,8 @@ class BuiltinBitCastExpr final
 };
 
 /// Represents a C++2c reflect expression (P2996). The operand of the expression
-/// is either a type, an expression, a template-name, or a namespace.
+/// is either a type, an expression, a template-name, an attribute or a
+/// namespace.
 class CXXReflectExpr : public Expr {
   enum class OperandKind {
     Unset,
@@ -5408,12 +5409,12 @@ class CXXReflectExpr : public Expr {
 /// reflections (P2996). Arguments vary by function.
 class CXXMetafunctionExpr : public Expr {
 public:
-  // Type of callback provided to executing metafunctinons to help evaluate an
+  // Type of callback provided to executing metafunctions to help evaluate an
   // expression in the current constant evaluation context.
   using EvaluateFn = std::function<bool(APValue &, const Expr *,
                                         bool ConvertToRValue)>;
 
-  // Type of callback provided to report a diagnistc to the evaluation context.
+  // Type of callback provided to report a diagnostic to the evaluation context.
   using DiagnoseFn = std::function<PartialDiagnostic &(SourceLocation,
                                                        unsigned)>;
 

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -2991,6 +2991,7 @@ DEF_TRAVERSE_STMT(CXXReflectExpr, {
     case ReflectionKind::Namespace:
     case ReflectionKind::BaseSpecifier:
     case ReflectionKind::DataMemberSpec:
+    case ReflectionKind::Attribute: // TODO P3385 ?
       break;
     }
   }

clang/include/clang/AST/Reflection.h

@@ -48,7 +48,7 @@ enum class ReflectionKind {
   ///
   /// Corresponds to an APValue (plus a QualType).
   Object,
-  
+
   /// \brief A reflection of a value (i.e., the result of a prvalue).
   ///
   /// Corresponds to an APValue (plus a QualType).
@@ -102,8 +102,10 @@ enum class ReflectionKind {
 
   /// \brief A reflection of an annotation (P2996 ext).
   Annotation,
-};
 
+  /// \brief A reflection of a standard attribute (P3385).
+  Attribute,
+};
 
 /// \brief Representation of a hypothetical data member, which could be used to
 /// complete an incomplete class definition using the 'std::meta::define_class'

clang/include/clang/Basic/Attr.td

@@ -3442,6 +3442,13 @@ def ObjCRequiresPropertyDefs : InheritableAttr {
   let SimpleHandler = 1;
 }
 
+def DelayedSplice : InheritableAttr {
+  let Spellings = [Clang<"DelayedSplice">];
+  let Args = [ExprArgument<"SpliceExpression">];
+  let Subjects = SubjectList<[FunctionLike, Type]>;
+  let Documentation = [InternalOnly];
+}
+
 def Unused : InheritableAttr {
   let Spellings = [CXX11<"", "maybe_unused", 201603>, GCC<"unused">,
                    C23<"", "maybe_unused", 202106>];

clang/include/clang/Basic/DiagnosticFrontendKinds.td

@@ -105,6 +105,9 @@ def err_fe_reflection_incompatible_with_blocks : Error<
 def err_fe_parameter_reflection_without_reflection : Error<
     "cannot specify '-fparameter-reflection' without '-freflection'">,
     DefaultFatal;
+def err_fe_attribute_reflection_without_reflection : Error<
+    "cannot specify '-fattribute-reflection' without '-freflection'">,
+    DefaultFatal;
 def err_fe_dependency_file_requires_MT : Error<
     "-dependency-file requires at least one -MT or -MQ option">;
 def err_fe_invalid_plugin_name : Error<

clang/include/clang/Basic/DiagnosticMetafnKinds.td

@@ -18,7 +18,7 @@ def metafn_no_associated_property : Note<
   "%0 has no %select{type|parent}1">;
 def metafn_cannot_query_property : Note<"cannot query the "
   "%select{type|object|value|size|alignment|parameters|return type|"
-           "annotations}0 of %1">;
+           "annotations|attributes}0 of %1">;
 
 // Ranges of entities.
 def metafn_cannot_introspect_type : Note<
@@ -89,6 +89,11 @@ def metafn_value_not_structural_type : Note<
 def metafn_result_not_representable : Note<
   "provided %select{value|object}0 cannot be represented by a reflection">;
 
+def metafn_p3385_trace_execution_checkpoint : Warning<
+  "(p3385-metafn) trace_execution_checkpoint %0">;
+def metafn_p3385_non_standard_attribute : Warning<
+  "(p3385-metafn) Non standard attribute discovered %0">;
+
 // Class definition.
 def metafn_name_invalid_identifier : Note<
   "provided name '%0' is not a valid identifier">;

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1746,6 +1746,24 @@ def err_annotation_with_using : Error<
   "annotations are not permitted following an attribute-using-prefix">;
 }
 
+let CategoryName = "P3385" in {
+
+def p3385_trace_attribute_parsed : Warning<
+  "(p3385-Parse) found attribute to parse following caret operator">;
+def p3385_trace_empty_attributes_list : Warning<
+  "(p3385-Parse) reflection of an empty attribute list">;
+def p3385_trace_execution_checkpoint : Warning<
+  "(p3385-Parse) trace_execution_checkpoint %0">;
+def p3385_delayed_splice_attr : Warning<
+  "(p3385-Sema) Found delayed splice attribute while instantiating %0">;
+def p3385_err_attributes_list : Error<
+  "(p3385-Parse) reflection of attribute list is not supported, found %0 attributes">;
+def p3385_err_attribute_splicing_error : Error<
+  "(p3385-Parse) error while splicing attributes reflection: %0">;
+def p3385_err_attribute_splicing_with_using_namespace_error : Error<
+  "(p3385-Parse) using prefix with splice expression is not supported: %0">;
+}
+
 let CategoryName = "Generics Issue" in {
 
 def err_objc_expected_type_parameter : Error<

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -3173,6 +3173,9 @@ def note_dependent_splice_explicit_this_may_fix : Note<
 def err_cannot_expand_over_type : Error<
   "cannot expand over an expression of type %0">;
 
+def p3385_sema_trace_execution_checkpoint : Warning<
+  "(p3385-Sema) trace_execution_checkpoint %0">;
+
 // C++11 char16_t/char32_t
 def warn_cxx98_compat_unicode_type : Warning<
   "'%0' type specifier is incompatible with C++98">,

clang/include/clang/Basic/Features.def

@@ -310,6 +310,7 @@ FEATURE(cxx_abi_relative_vtable, LangOpts.CPlusPlus && LangOpts.RelativeCXXABIVT
 FEATURE(reflection, LangOpts.Reflection)
 FEATURE(reflection_new_syntax, LangOpts.ReflectionNewSyntax)
 FEATURE(parameter_reflection, LangOpts.ParameterReflection)
+FEATURE(attribute_reflection, LangOpts.AttributeReflection)
 FEATURE(expansion_statements, LangOpts.ExpansionStatements)
 FEATURE(annotation_attributes, LangOpts.AnnotationAttributes)
 FEATURE(consteval_blocks, LangOpts.ConstevalBlocks)

clang/include/clang/Basic/LangOptions.def

@@ -314,6 +314,7 @@ LANGOPT(OpenACC           , 1, 0, "OpenACC Enabled")
 LANGOPT(Reflection          , 1, 0, "Experimental C++26 Reflection")
 LANGOPT(ReflectionNewSyntax , 1, 0, "New syntax for C++26 Reflection")
 LANGOPT(ParameterReflection , 1, 0, "Augments C++26 Reflection with function parameter reflection")
+LANGOPT(AttributeReflection , 1, 0, "Augments C++26 Reflection with standard attribute reflection")
 LANGOPT(ExpansionStatements , 1, 0, "Experimental C++26 Expansion Statements")
 LANGOPT(AnnotationAttributes, 1, 0, "Experimental C++26 support for annotations")
 LANGOPT(ConstevalBlocks,      1, 0, "Experimental C++26 support for consteval blocks")

clang/include/clang/Driver/Options.td

@@ -3504,6 +3504,11 @@ defm parameter_reflection : BoolFOption<"parameter-reflection",
   PosFlag<SetTrue, [], [ClangOption, CC1Option],
           "Enable proposed parameter reflection as described by P3096">,
   NegFlag<SetFalse>>;
+defm attribute_reflection : BoolFOption<"attribute-reflection",
+  LangOpts<"AttributeReflection">, DefaultFalse,
+  PosFlag<SetTrue, [], [ClangOption, CC1Option],
+          "Enable proposed parameter reflection as described by P3385">,
+  NegFlag<SetFalse>>;
 defm expansion_statements : BoolFOption<"expansion-statements",
   LangOpts<"ExpansionStatements">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption, CC1Option],

clang/include/clang/Parse/Parser.h

@@ -316,6 +316,8 @@ class Parser : public CodeCompletionHandler {
 
   /// Factory object for creating ParsedAttr objects.
   AttributeFactory AttrFactory;
+  /// FIXNE P3385
+  ParsedAttributes Attrs;
 
   /// Gathers and cleans up TemplateIdAnnotations when parsing of a
   /// top-level declaration is finished.
@@ -3047,6 +3049,11 @@ class Parser : public CodeCompletionHandler {
     ParseCXX11AttributeSpecifierInternal(Attrs, OpenMPTokens, EndLoc);
     ReplayOpenMPAttributeTokens(OpenMPTokens);
   }
+
+  bool tryParseSpliceAttrSpecifier(ParsedAttributes &Attrs,
+                                   SourceLocation *EndLoc = nullptr);
+  /// Try parsing a splice expression when inside an attribute specifier
+
   void ParseCXX11Attributes(ParsedAttributes &attrs);
   /// Parses a C++11 (or C23)-style attribute argument list. Returns true
   /// if this results in adding an attribute to the ParsedAttributes list.

clang/include/clang/Sema/Sema.h

@@ -35,6 +35,7 @@
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/AttrSubjectMatchRules.h"
+#include "clang/Basic/AttributeCommonInfo.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CapturedStmt.h"
 #include "clang/Basic/Cuda.h"
@@ -15173,6 +15174,7 @@ class Sema final : public SemaBase {
   ExprResult ActOnCXXReflectExpr(SourceLocation OpLoc,
                                  ParsedTemplateArgument Template);
   ExprResult ActOnCXXReflectExpr(SourceLocation OpLoc, CXXSpliceExpr *E);
+  ExprResult ActOnCXXReflectExpr(SourceLocation OpLoc, ParsedAttr *a);
 
   ExprResult ActOnCXXMetafunction(SourceLocation KwLoc,
                                   SourceLocation LParenLoc,
@@ -15222,6 +15224,7 @@ class Sema final : public SemaBase {
   ExprResult BuildCXXReflectExpr(SourceLocation OperatorLoc,
                                  SourceLocation OperandLoc,
                                  TemplateName Template);
+  ExprResult BuildCXXReflectExpr(SourceLocation OperatorLoc, ParsedAttr *A);
 
   // Reflection of expression operands.
   ExprResult BuildCXXReflectExpr(SourceLocation OperatorLoc, Expr *E);