[RFC][clang] Add attribute-like keywords

[rsandifo-arm]

Summary

https://reviews.llvm.org/D127762 adds Clang support for some new SME features. These features allow code to attach semantic information to certain types and declarations. In the current SME ACLE specification, this information is conveyed using GNU-style attributes. (Since the information is semantic, it clearly couldn't be conveyed by standard attributes.)

Although GNU-style attributes are in practice often used to carry semantic information, there is a big drawback to this approach: compilers that don't understand the attributes will emit a warning rather than an error. This is true of both Clang and GCC, and is compounded by the fact that warnings for unknown standard attributes and unknown GNU attributes are conflated into a single warning option. (Arguably an error would have
been more appropriate for GNU attributes, given its historically broad use. But no more than a warning is warranted for standard attributes.)

A slightly hacky, old-school compromise would be to have the compiler automatically define a preprocessor macro that expands to a GNU-style attribute. This still retains the advantage of using an existing mechanism (GNU attributes) to convey the information, but has the additional advantage that older compilers will reject the code. However, it can tend to make diagnostic messages less readable.

A more robust approach would be to add new keywords. This should give a better user experience than the two alternatives described above. However, it would mean having to define new parsing rules that are specific to the SME extension. Two drawbacks with this approach are:

1. The parsing rules would need to be kept up-to-date as the language evolves.

2. If other extensions (besides SME) need to define similar parsing rules for their information, there's a risk that different sets of rules will handle corner cases differently, which loses the consistency that the standard attribute syntax brings.

I think the risk of (2) is significant. There are quite a few existing extensions (including AArch64 ones) that use GNU attributes to describe semantics, and if all those extensions had used keywords instead, it seems unlikely that they would have agreed on common rules.

If the SME information were not semantic, standard attributes would be the obvious and ideal way of conveying it. It's also possible to envisage a version of the standard that defined a syntactic gloss that could be added to an attribute to indicate that the attribute cannot be ignored. An implementation would then be required to issue a diagnostic for glossed attributes that it didn't understand.

Using these hypothetical glossed attributes for semantic information would have two big benefits: (a) the standard would define all the necessary production rules and (b) the standard would define exactly what each (glossed) attribute appertains to.

The idea of this patch is get these same two benefits using keywords. It adds the concept of “attribute-like keywords” that can appear exactly where a standard attribute can appear. No exceptions either way are allowed: there are no situations in which one of the two can appear and the other can't.

This makes the parsing rules a very simple extension to the standard. They adapt mechanically as the standard evolves.

Also, the keywords are defined to appertain to exactly the same thing that an attribute would appertain to. Again, no exceptions are allowed. For example, there is no “sliding” of attribute-like keywords from declarations to types.

This does mean that the attribute-like keywords are accepted for parsing purposes in many more places than necessary for SME. However, the compiler would need to reject the keywords in those positions whatever happens, and treating them as wannabe attributes seems no worse than the alternative. In some cases it might even be better. For example, __arm_streaming would make conceptual sense as a statement attribute, so someone who takes a “try-it-and-see” approach might write:

__arm_streaming { …block-of-code…; }

In fact, we did consider supporting this originally. The reason for rejecting it was that it was too difficult to implement, rather than because it didn't make conceptual sense.

The patch is quite large. However, it should be a one-off, up-front cost. Adding extra attribute-like keywords would just require (lexing) updates to TokenKinds.def and Tokens.h. There should be no need for changes in the parser itself.

One slight disadvantage of this approach is that it isn't possible to use #pragma clang attribute with the keywords. Perhaps we could add that in future, if it turns out to be useful.

The approach taken in the patch is that the keywords can be used with any language version. If standard attributes were added in language version Y, the keyword rules for version X<Y are the same as they were for version Y (to the extent possible). Any extensions beyond Y are handled in the same way for both keywords and attributes. This ensures that C++17 (for example) is not treated differently from versions that have yet to be defined.

The SME attributes do not take arguments, but in principle it would be possible to define keywords that do take arguments. Support for this could be added later, when it's needed.

Some notes on the implementation:

• The patch emits errors rather than warnings for diagnostics that relate to keywords.

• Where possible, the patch drops “attribute” from the diagnostics relating to keywords.

• One exception to the previous point is that warnings about C++ extensions do still mention attributes. The use there seemed OK since the diagnostics are noting a change in the production rules.

• Although the patch updates warn_attribute_wrong_decl_type_str, warn_attribute_wrong_decl_type, and warn_attribute_wrong_decl_type, only the error forms of these strings are used for keywords.

• I couldn't trigger the warnings in checkUnusedDeclAttributes(), even for existing attributes. An assert on the warnings caused no failures in the testsuite. I think in practice all standard attributes would be diagnosed before this.

• The patch drops a call to standardAttributesAllowed in ParseFunctionDeclarator. This is because MaybeParseCXX11Attributes checks the same thing itself, where appropriate.

• A lot of the error messages relating to the SME keywords refer to K&R functions, even for C++. It's pretty easy to fix that, but it's logically separate work. A lot of the expected errors therefore end on “only applies to”. I can go back and tighten this once the K&R thing is fixed.

• The new tests are based on c2x-attributes.c and cxx0x-attributes.cpp. The C++ test also incorporates a version of cxx11-base-spec-attributes.cpp. The FIXMEs are carried across from the originals.

[rsandifo-arm]

Reupload with proper linting. No change in code.

Sorry for the noise!

[rsandifo-arm]

Ping. If this approach is acceptable, I think we could use it for future ACLE features too (rather than the GNU attributes that we've used previously).

[aaron.ballman]

Roping in Erich as the attributes code owner. In general, I think this is going in roughly the right direction. One concern I have is that the distinction between a keyword spelling for an attribute is now a bit harder. We have keyword attributes and we have attribute-like keywords, and it's hard to know when it's appropriate to use one over another. From what I can tell, it seems that the biggest distinction between the two is automatic parsing or not and diagnostic wording (please correct me if I'm missing something!). If I'm correct, then I don't think we want an additional attribute syntax enumeration for this (it's still AS_Keyword), but we should surface this via Attr.td/tablegen so that the Keyword spelling can opt into the extra generality (or perhaps we want the default to be all keyword attributes get the general behavior and we make a few existing attributes opt out).

clang/include/clang/Basic/AttributeCommonInfo.h

55

I think it would help to describe how this differs from AS_Keyword and AS_ContextSensitiveKeyword as I would expect these to have considerable overlap.

clang/include/clang/Basic/TokenKinds.h

105–107

This strikes me as something that should be handled via tablegen -- the spelling used in Attr.td should show what kind of attribute spelling it is (regular keyword or not).

[aaron.ballman]

One thing that might also help is to split this into a few stages. 1) Add the new general functionality, 2) Replacing the existing implementation of keyword attributes with the new functionality where possible, 3) Add new attributes using the new functionality. It seems to me that we should be able to replace a bunch of our existing keyword attributes with the newer generalized approach (I'm thinking about ones like the calling convention attributes specifically, but we've got others as well), and that will help us prove the design as well as simplify the compiler implementation. WDYT?

[erichkeane]

In D139028#4150761, @aaron.ballman wrote:

One thing that might also help is to split this into a few stages. 1) Add the new general functionality, 2) Replacing the existing implementation of keyword attributes with the new functionality where possible, 3) Add new attributes using the new functionality. It seems to me that we should be able to replace a bunch of our existing keyword attributes with the newer generalized approach (I'm thinking about ones like the calling convention attributes specifically, but we've got others as well), and that will help us prove the design as well as simplify the compiler implementation. WDYT?

I think this is an absolute necessity for me. I also find myself wondering if the 3 'keyword' types of attributes hold their own weight individually.

[rsandifo-arm]

Thanks @aaron.ballman and @erichkeane for the comments. I'll split it into stages and use tablegen more, like you say.

In D139028#4150761, @aaron.ballman wrote:

One thing that might also help is to split this into a few stages. 1) Add the new general functionality, 2) Replacing the existing implementation of keyword attributes with the new functionality where possible, 3) Add new attributes using the new functionality. It seems to me that we should be able to replace a bunch of our existing keyword attributes with the newer generalized approach (I'm thinking about ones like the calling convention attributes specifically, but we've got others as well), and that will help us prove the design as well as simplify the compiler implementation. WDYT?

I've tried to go through the existing keyword attributes, but unfortunately, I don't think any of them match the new scheme exactly:

__declspec

I don't think anyone was suggesting we try to convert this :-) but for completeness:

int __declspec(align(16)) a1; // OK, but standard attribute rules would say this appertains to the type
int a2 __declspec();          // Not valid, unlike for standard decl attributes

__forceinline

int __forceinline a1() { return 1; } // OK, but standard attribute rules would say this appertains to the type
int a2 __forceinline() { return 1; } // Not valid, but would be for standard decl attributes

Calling convention keywords

These are generally DeclOrType attributes, with attributes sliding from the decl to the type where necessary.

__stdcall int a1();   // OK, but appertains to the decl and relies on sliding behaviour
int a2 __stdcall();   // Not valid, but is another place to put standard decl attributes
int a3() __stdcall;   // Not valid, but is another place to put standard type attributes
int (__stdcall a4)(); // OK, but standard attributes aren't allowed in this position
extern int (*const __stdcall volatile a5) (); // OK, but standard attributes wouldn't be allowed here

Nullability keywords

Like the calling-convention keywords, the nullability keywords appertain to types but are allowed in some (but not all) positions that would normally appertain to decls:

using ptr = int *;
_Nullable ptr a1; // OK, but appertains to the decl and relies on sliding behaviour
ptr a2 _Nullable; // Not valid, but is another place to put standard decl attributes
extern int *const _Nullable volatile a3; // OK, but a standard attribute wouldn't be allowed here

The same distinction applies to Microsoft pointer attributes.

Would it be OK just to use the new scheme for new attributes?

[rsandifo-arm]

Superceded by D148700

clang/examples/Attribute/Attribute.cpp

ExampleAttrInfo() {
     Spellings = S;
   }
 
   bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr,
                             const Decl *D) const override {
     // This attribute appertains to functions only.
     if (!isa<FunctionDecl>(D)) {
       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
-          << Attr << "functions";
+          << Attr << 0 << "functions";
       return false;
     }
     return true;
   }
 
   AttrHandling handleDeclAttribute(Sema &S, Decl *D,
                                    const ParsedAttr &Attr) const override {
     // Check if the decl is at file scope.

clang/examples/CallSuperAttribute/CallSuperAttrInfo.cpp

CallSuperAttrInfo() {
     Spellings = S;
   }
 
   bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr,
                             const Decl *D) const override {
     const auto *TheMethod = dyn_cast_or_null<CXXMethodDecl>(D);
     if (!TheMethod || !TheMethod->isVirtual()) {
       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
-          << Attr << "virtual functions";
+          << Attr << 0 << "virtual functions";
       return false;
     }
     MarkedMethods.insert(TheMethod);
     return true;
   }
   AttrHandling handleDeclAttribute(Sema &S, Decl *D,
                                    const ParsedAttr &Attr) const override {
     // No need to add an attr object (usually an `AnnotateAttr` is added).

clang/include/clang/Basic/Attr.td

 }
 
 def AArch64VectorPcs: DeclOrTypeAttr {
   let Spellings = [Clang<"aarch64_vector_pcs">];
   let Documentation = [AArch64VectorPcsDocs];
 }
 
 def ArmStreamingCompatible : TypeAttr, TargetSpecificAttr<TargetAArch64SME> {
-  let Spellings = [GNU<"arm_streaming_compatible">];
+  let Spellings = [Keyword<"__arm_streaming_compatible">];
   let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>;
   let Documentation = [ArmSmeStreamingCompatibleDocs];
 }
 
 def ArmStreaming : TypeAttr, TargetSpecificAttr<TargetAArch64SME> {
-  let Spellings = [GNU<"arm_streaming">];
+  let Spellings = [Keyword<"__arm_streaming">];
   let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>;
   let Documentation = [ArmSmeStreamingDocs];
 }
 
 def ArmLocallyStreaming : InheritableAttr, TargetSpecificAttr<TargetAArch64SME> {
-  let Spellings = [GNU<"arm_locally_streaming">];
+  let Spellings = [Keyword<"__arm_locally_streaming">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [ArmSmeLocallyStreamingDocs];
 }
 
 def ArmSharedZA : TypeAttr, TargetSpecificAttr<TargetAArch64SME> {
-  let Spellings = [GNU<"arm_shared_za">];
+  let Spellings = [Keyword<"__arm_shared_za">];
   let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>;
   let Documentation = [ArmSmeSharedZADocs];
 }
 
 def ArmPreservesZA : TypeAttr, TargetSpecificAttr<TargetAArch64SME> {
-  let Spellings = [GNU<"arm_preserves_za">];
+  let Spellings = [Keyword<"__arm_preserves_za">];
   let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>;
   let Documentation = [ArmSmePreservesZADocs];
 }
 
 def ArmNewZA : TypeAttr, TargetSpecificAttr<TargetAArch64SME> {
-  let Spellings = [GNU<"arm_new_za">];
+  let Spellings = [Keyword<"__arm_new_za">];
   let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>;
   let Documentation = [ArmSmeNewZADocs];
 }
 
 def AArch64SVEPcs: DeclOrTypeAttr {
   let Spellings = [Clang<"aarch64_sve_pcs">];
   let Documentation = [AArch64SVEPcsDocs];
 }

clang/include/clang/Basic/AttributeCommonInfo.h

enum Syntax {
 
     // Note TableGen depends on the order above.  Do not add or change the order
     // without adding related code to TableGen/ClangAttrEmitter.cpp.
     /// Context-sensitive version of a keyword attribute.
     AS_ContextSensitiveKeyword,
 
     /// <vardecl> : <semantic>
     AS_HLSLSemantic,
+
+    /// A keyword that can appear wherever a standard attribute can appear.
+    AS_AttributeLikeKeyword,
   };
   enum Kind {
 #define PARSED_ATTR(NAME) AT_##NAME,
 #include "clang/Sema/AttrParsedAttrList.inc"
 #undef PARSED_ATTR
     NoSemaHandlerAttribute,
     IgnoredAttribute,
     UnknownAttribute,
public:
   bool isKeywordAttribute() const {
     return SyntaxUsed == AS_Keyword || SyntaxUsed == AS_ContextSensitiveKeyword;
   }
 
   bool isContextSensitiveKeywordAttribute() const {
     return SyntaxUsed == AS_ContextSensitiveKeyword;
   }
 
+  bool isAttributeLikeKeyword() const {
+    return SyntaxUsed == AS_AttributeLikeKeyword;
+  }
+
   unsigned getAttributeSpellingListIndex() const {
     assert((isAttributeSpellingListCalculated() || AttrName) &&
            "Spelling cannot be found");
     return isAttributeSpellingListCalculated()
                ? SpellingIndex
                : calculateAttributeSpellingListIndex();
   }
   void setAttributeSpellingListIndex(unsigned V) { SpellingIndex = V; }

clang/include/clang/Basic/DiagnosticCommonKinds.td

 def err_module_prebuilt : Error<
   "error in loading module '%0' from prebuilt module path">, DefaultFatal;
 def err_module_rebuild_finalized : Error<
   "cannot rebuild module '%0' as it is already finalized">, DefaultFatal;
 def note_pragma_entered_here : Note<"#pragma entered here">;
 def note_decl_hiding_tag_type : Note<
   "%1 %0 is hidden by a non-type declaration of %0 here">;
 def err_attribute_not_type_attr : Error<
-  "%0 attribute cannot be applied to types">;
+  "%0%select{ attribute|}1 cannot be applied to types">;
 def err_enum_template : Error<"enumeration cannot be a template">;
 
 def warn_cxx20_compat_consteval : Warning<
   "'consteval' specifier is incompatible with C++ standards before C++20">,
   InGroup<CXX20Compat>, DefaultIgnore;
 def warn_missing_type_specifier : Warning<
   "type specifier missing, defaults to 'int'">,
   InGroup<ImplicitInt>, DefaultIgnore;

 def err_opencl_unknown_type_specifier : Error<
   "%0 does not support the '%1' "
   "%select{type qualifier|storage class specifier}2">;
 
 def warn_unknown_attribute_ignored : Warning<
   "unknown attribute %0 ignored">, InGroup<UnknownAttributes>;
 def warn_attribute_ignored : Warning<"%0 attribute ignored">,
   InGroup<IgnoredAttributes>;
+def err_keyword_not_supported_on_target : Error<
+  "%0 is not supported on this target">;
 def err_use_of_tag_name_without_tag : Error<
   "must use '%1' tag to refer to type %0%select{| in this scope}2">;
 
 def duplicate_declspec : TextSubstitution<
   "duplicate '%0' declaration specifier">;
 
 def ext_duplicate_declspec : Extension<"%sub{duplicate_declspec}0">,
   InGroup<DuplicateDeclSpecifier>;

clang/include/clang/Basic/DiagnosticParseKinds.td

def warn_cxx14_compat_using_attribute_ns : Warning<
   "default scope specifier for attributes is incompatible with C++ standards "
   "before C++17">, InGroup<CXXPre17Compat>, DefaultIgnore;
 def ext_using_attribute_ns : ExtWarn<
   "default scope specifier for attributes is a C++17 extension">,
   InGroup<CXX17>;
 def err_using_attribute_ns_conflict : Error<
   "attribute with scope specifier cannot follow default scope specifier">;
 def err_attributes_not_allowed : Error<"an attribute list cannot appear here">;
+def err_keyword_not_allowed : Error<"%0 cannot appear here">;
 def ext_cxx11_attr_placement : ExtWarn<
-  "ISO C++ does not allow an attribute list to appear here">,
+  "ISO C++ does not allow %select{an attribute list|%1}0 to appear here">,
   InGroup<DiagGroup<"cxx-attribute-extension">>;
 def err_attributes_misplaced : Error<"misplaced attributes; expected attributes here">;
+def err_keyword_misplaced : Error<"misplaced %0; expected %0 here">;
 def err_l_square_l_square_not_attribute : Error<
   "C++11 only allows consecutive left square brackets when "
   "introducing an attribute">;
 def err_attribute_argument_parm_pack_not_supported : Error<
   "attribute %0 does not support argument pack expansion">;
 def err_ms_declspec_type : Error<
   "__declspec attributes must be an identifier or string literal">;
 def err_ms_property_no_getter_or_putter : Error<

 def err_lambda_capture_misplaced_ellipsis : Error<
   "ellipsis in pack %select{|init-}0capture must appear %select{after|before}0 "
   "the name of the capture">;
 def err_lambda_capture_multiple_ellipses : Error<
   "multiple ellipses in pack capture">;
 def err_capture_default_first : Error<
   "capture default must be first">;
 def ext_decl_attrs_on_lambda : ExtWarn<
-  "an attribute specifier sequence in this position is a C++2b extension">,
-  InGroup<CXX2b>;
+  "%select{an attribute specifier sequence|%1}0 in this position "
+  "is a C++2b extension">, InGroup<CXX2b>;
 def ext_lambda_missing_parens : ExtWarn<
   "lambda without a parameter clause is a C++2b extension">,
   InGroup<CXX2b>;
 def warn_cxx20_compat_decl_attrs_on_lambda : Warning<
-  "an attribute specifier sequence in this position is incompatible with C++ "
-  "standards before C++2b">, InGroup<CXXPre2bCompat>, DefaultIgnore;
+  "%select{an attribute specifier sequence|%1}0 in this position "
+  "is incompatible with C++ standards before C++2b">,
+  InGroup<CXXPre2bCompat>, DefaultIgnore;
 
 // C++17 lambda expressions
 def err_expected_star_this_capture : Error<
   "expected 'this' following '*' in lambda capture list">;
 
 // C++17 constexpr lambda expressions
 def warn_cxx14_compat_constexpr_on_lambda : Warning<
   "constexpr on lambda expressions is incompatible with C++ standards before C++17">,

 
 let CategoryName = "Modules Issue" in {
 def err_unexpected_module_decl : Error<
   "module declaration can only appear at the top level">;
 def err_module_expected_ident : Error<
   "expected a module name after '%select{module|import}0'">;
 def err_attribute_not_module_attr : Error<
   "%0 attribute cannot be applied to a module">;
+def err_keyword_not_module_attr : Error<
+  "%0 cannot be applied to a module">;
 def err_attribute_not_import_attr : Error<
   "%0 attribute cannot be applied to a module import">;
+def err_keyword_not_import_attr : Error<
+  "%0 cannot be applied to a module import">;
 def err_module_expected_semi : Error<
   "expected ';' after module name">;
 def err_global_module_introducer_not_at_start : Error<
   "'module;' introducing a global module fragment can appear only "
   "at the start of the translation unit">;
 def err_module_fragment_exported : Error<
   "%select{global|private}0 module fragment cannot be exported">;
 def err_private_module_fragment_expected_semi : Error<

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_musttail_scope : Error<
   "cannot perform a tail call from this return statement">;
 def err_musttail_no_variadic : Error<
   "%0 attribute may not be used with variadic functions">;
 
 def err_nsobject_attribute : Error<
   "'NSObject' attribute is for pointer types only">;
 def err_attributes_are_not_compatible : Error<
-  "%0 and %1 attributes are not compatible">;
+  "%0 and %1%select{ attributes|}2 are not compatible">;
 def err_attribute_invalid_argument : Error<
   "%select{a reference type|an array type|a non-vector or "
   "non-vectorizable scalar type}0 is an invalid argument to attribute %1">;
 def err_attribute_wrong_number_arguments : Error<
   "%0 attribute %plural{0:takes no arguments|1:takes one argument|"
   ":requires exactly %1 arguments}1">;
 def err_attribute_wrong_number_arguments_for : Error <
   "%0 attribute references function %1, which %plural{0:takes no arguments|1:takes one argument|"

 def note_attribute_has_no_effect_on_infinite_loop_here : Note<
   "annotating the infinite loop here">;
 def warn_attribute_has_no_effect_on_compile_time_if : Warning<
   "attribute %0 has no effect when annotating an 'if %select{constexpr|consteval}1' statement">,
    InGroup<IgnoredAttributes>;
 def note_attribute_has_no_effect_on_compile_time_if_here : Note<
   "annotating the 'if %select{constexpr|consteval}0' statement here">;
 def err_decl_attribute_invalid_on_stmt : Error<
-  "%0 attribute cannot be applied to a statement">;
+  "%0%select{ attribute|}1 cannot be applied to a statement">;
 def err_attribute_invalid_on_decl : Error<
-  "%0 attribute cannot be applied to a declaration">;
+  "%0%select{ attribute|}1 cannot be applied to a declaration">;
 def warn_type_attribute_deprecated_on_decl : Warning<
   "applying attribute %0 to a declaration is deprecated; apply it to the type instead">,
   InGroup<DeprecatedAttributes>;
 def warn_declspec_attribute_ignored : Warning<
   "attribute %0 is ignored, place it after "
   "\"%select{class|struct|interface|union|enum}1\" to apply attribute to "
   "type declaration">, InGroup<IgnoredAttributes>;
 def warn_attribute_precede_definition : Warning<
def err_attribute_weakref_not_static : Error<
   "weakref declaration must have internal linkage">;
 def err_attribute_weakref_not_global_context : Error<
   "weakref declaration of %0 must be in a global context">;
 def err_attribute_weakref_without_alias : Error<
   "weakref declaration of %0 must also have an alias attribute">;
 def err_alias_not_supported_on_darwin : Error <
   "aliases are not supported on darwin">;
 def warn_attribute_wrong_decl_type_str : Warning<
-  "%0 attribute only applies to %1">, InGroup<IgnoredAttributes>;
+  "%0%select{ attribute|}1 only applies to %2">, InGroup<IgnoredAttributes>;
 def err_attribute_wrong_decl_type_str : Error<
   warn_attribute_wrong_decl_type_str.Summary>;
 def warn_attribute_wrong_decl_type : Warning<
-  "%0 attribute only applies to %select{"
+  "%0%select{ attribute|}1 only applies to %select{"
   "functions"
   "|unions"
   "|variables and functions"
   "|functions and methods"
   "|functions, methods and blocks"
   "|functions, methods, and parameters"
   "|variables"
   "|variables and fields"
   "|variables, data members and tag types"
   "|types and namespaces"
   "|variables, functions and classes"
   "|kernel functions"
-  "|non-K&R-style functions}1">,
+  "|non-K&R-style functions}2">,
   InGroup<IgnoredAttributes>;
 def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Summary>;
 def warn_type_attribute_wrong_type : Warning<
   "'%0' only applies to %select{function|pointer|"
   "Objective-C object or block pointer}1 types; type here is %2">,
   InGroup<IgnoredAttributes>;
+def err_type_attribute_wrong_type : Error<
+  warn_type_attribute_wrong_type.Summary>;
 def warn_incomplete_encoded_type : Warning<
   "encoding of %0 type is incomplete because %1 component has unknown encoding">,
   InGroup<DiagGroup<"encode-type">>;
 def warn_gnu_inline_attribute_requires_inline : Warning<
   "'gnu_inline' attribute requires function to be marked 'inline',"
   " attribute ignored">,
   InGroup<IgnoredAttributes>;
 def warn_gnu_inline_cplusplus_without_extern : Warning<
def err_objc_precise_lifetime_bad_type : Error<
   "objc_precise_lifetime only applies to retainable types; type here is %0">;
 def warn_objc_precise_lifetime_meaningless : Error<
   "objc_precise_lifetime is not meaningful for "
   "%select{__unsafe_unretained|__autoreleasing}0 objects">;
 def err_invalid_pcs : Error<"invalid PCS type">;
 def warn_attribute_not_on_decl : Warning<
   "%0 attribute ignored when parsing type">, InGroup<IgnoredAttributes>;
 def err_base_specifier_attribute : Error<
-  "%0 attribute cannot be applied to a base specifier">;
+  "%0%select{ attribute|}1 cannot be applied to a base specifier">;
 def warn_declspec_allocator_nonpointer : Warning<
   "ignoring __declspec(allocator) because the function return type %0 is not "
   "a pointer or reference type">, InGroup<IgnoredAttributes>;
 def err_cconv_incomplete_param_type : Error<
   "parameter %0 must have a complete type to use function %1 with the %2 "
   "calling convention">;
 def err_attribute_output_parameter : Error<
   "attribute only applies to output parameters">;

clang/include/clang/Basic/TokenKinds.h

 }
 
 /// Return true if this is any of tok::annot_* kinds.
 bool isAnnotation(TokenKind K);
 
 /// Return true if this is an annotation token representing a pragma.
 bool isPragmaAnnotation(TokenKind K);
 
+/// Return true if K is a keyword that is parsed in the same position as
+/// a C++11 attribute, but that has semantic meaning and so is not suitable
+/// to be a true attribute.
+inline bool isAttributeLikeKeyword(TokenKind K) {
+  return K >= tok::kw___arm_streaming && K <= tok::kw___arm_preserves_za;
+}
+
 } // end namespace tok
 } // end namespace clang
 
 namespace llvm {
 template <> struct DenseMapInfo<clang::tok::PPKeywordKind> {
   static inline clang::tok::PPKeywordKind getEmptyKey() {
     return clang::tok::PPKeywordKind::pp_not_keyword;
   }

clang/include/clang/Basic/TokenKinds.def

 ALIAS("__volatile__" , volatile   , KEYALL)
 
 // Type nullability.
 KEYWORD(_Nonnull                 , KEYALL)
 KEYWORD(_Nullable                , KEYALL)
 KEYWORD(_Nullable_result         , KEYALL)
 KEYWORD(_Null_unspecified        , KEYALL)
 
+// Keywords that are parsed in the same position as C++11 attributes,
+// but that have semantic meaning and so would not make suitable standard
+// attributes themselves.  This list needs to be kept in sync with
+// isAttributeLikeKeyword in TokenKinds.h.
+KEYWORD(__arm_streaming             , KEYALL)
+KEYWORD(__arm_streaming_compatible  , KEYALL)
+KEYWORD(__arm_locally_streaming     , KEYALL)
+KEYWORD(__arm_new_za                , KEYALL)
+KEYWORD(__arm_shared_za             , KEYALL)
+KEYWORD(__arm_preserves_za          , KEYALL)
+
 // Microsoft extensions which should be disabled in strict conformance mode
 KEYWORD(__ptr64                       , KEYMS)
 KEYWORD(__ptr32                       , KEYMS)
 KEYWORD(__sptr                        , KEYMS)
 KEYWORD(__uptr                        , KEYMS)
 KEYWORD(__w64                         , KEYMS)
 KEYWORD(__uuidof                      , KEYMS | KEYBORLAND)
 KEYWORD(__try                         , KEYMS | KEYBORLAND)

clang/include/clang/Lex/Token.h

public:
 
   /// Return true if this is a "literal", like a numeric
   /// constant, string, etc.
   bool isLiteral() const {
     return tok::isLiteral(getKind());
   }
 
   /// Return true if this is any of tok::annot_* kind tokens.
-  bool isAnnotation() const {
-    return tok::isAnnotation(getKind());
+  bool isAnnotation() const { return tok::isAnnotation(getKind()); }
+
+  /// Return true if K is a keyword that is parsed in the same position as
+  /// a C++11 attribute, but that has semantic meaning and so is not suitable
+  /// to be a true attribute.
+  bool isAttributeLikeKeyword() const {
+    return tok::isAttributeLikeKeyword(getKind());
   }
 
   /// Return a source location identifier for the specified
   /// offset in the current file.
   SourceLocation getLocation() const {
     return SourceLocation::getFromRawEncoding(Loc);
   }
   unsigned getLength() const {

clang/include/clang/Parse/Parser.h

private:
   void ParseBlockId(SourceLocation CaretLoc);
 
   /// Are [[]] attributes enabled?
   bool standardAttributesAllowed() const {
     const LangOptions &LO = getLangOpts();
     return LO.DoubleSquareBracketAttributes;
   }
 
+  /// Should the next token be treated as a [[]] attribute, or a keyword
+  /// that behaves like one?  The former is only true if [[]] attributes
+  /// are enabled, whereas the latter is true whenever such a keyword appears.
+  /// The arguments are as for isCXX11AttributeSpecifier.
+  bool isAllowedCXX11AttributeSpecifier(bool Disambiguate = false,
+                                        bool OuterMightBeMessageSend = false) {
+    return (Tok.isAttributeLikeKeyword() ||
+            (standardAttributesAllowed() &&
+             isCXX11AttributeSpecifier(Disambiguate, OuterMightBeMessageSend)));
+  }
+
   // Check for the start of an attribute-specifier-seq in a context where an
   // attribute is not allowed.
   bool CheckProhibitedCXX11Attribute() {
     assert(Tok.is(tok::l_square));
     if (!standardAttributesAllowed() || NextToken().isNot(tok::l_square))
       return false;
     return DiagnoseProhibitedCXX11Attribute();
   }
 
   bool DiagnoseProhibitedCXX11Attribute();
   void CheckMisplacedCXX11Attribute(ParsedAttributes &Attrs,
                                     SourceLocation CorrectLocation) {
+    if (!Tok.isAttributeLikeKeyword()) {
       if (!standardAttributesAllowed())
         return;
       if ((Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square)) &&
           Tok.isNot(tok::kw_alignas))
         return;
+    }
     DiagnoseMisplacedCXX11Attribute(Attrs, CorrectLocation);
   }
   void DiagnoseMisplacedCXX11Attribute(ParsedAttributes &Attrs,
                                        SourceLocation CorrectLocation);
 
   void stripTypeAttributesOffDeclSpec(ParsedAttributes &Attrs, DeclSpec &DS,
                                       Sema::TagUseKind TUK);
 
   // FixItLoc = possible correct location for the attributes
   void ProhibitAttributes(ParsedAttributes &Attrs,
                           SourceLocation FixItLoc = SourceLocation()) {
     if (Attrs.Range.isInvalid())
       return;
-    DiagnoseProhibitedAttributes(Attrs.Range, FixItLoc);
+    DiagnoseProhibitedAttributes(Attrs, FixItLoc);
     Attrs.clear();
   }
 
   void ProhibitAttributes(ParsedAttributesView &Attrs,
                           SourceLocation FixItLoc = SourceLocation()) {
     if (Attrs.Range.isInvalid())
       return;
-    DiagnoseProhibitedAttributes(Attrs.Range, FixItLoc);
+    DiagnoseProhibitedAttributes(Attrs, FixItLoc);
     Attrs.clearListOnly();
   }
-  void DiagnoseProhibitedAttributes(const SourceRange &Range,
+  void DiagnoseProhibitedAttributes(const ParsedAttributesView &Attrs,
                                     SourceLocation FixItLoc);
 
   // Forbid C++11 and C2x attributes that appear on certain syntactic locations
   // which standard permits but we don't supported yet, for example, attributes
   // appertain to decl specifiers.
   // For the most cases we don't want to warn on unknown type attributes, but
   // left them to later diagnoses. However, for a few cases like module
   // declarations and module import declarations, we should do it.
-  void ProhibitCXX11Attributes(ParsedAttributes &Attrs, unsigned DiagID,
+  void ProhibitCXX11Attributes(ParsedAttributes &Attrs, unsigned AttrDiagID,
+                               unsigned KeywordDiagId,
                                bool DiagnoseEmptyAttrs = false,
                                bool WarnOnUnknownAttrs = false);
 
   /// Skip C++11 and C2x attributes and return the end location of the
   /// last one.
   /// \returns SourceLocation() if there are no attributes.
   SourceLocation SkipCXX11Attributes();
 
private:
   /// Such situations should use the specific attribute parsing functionality.
   void ParseAttributes(unsigned WhichAttrKinds, ParsedAttributes &Attrs,
                        LateParsedAttrList *LateAttrs = nullptr);
   /// \brief Possibly parse attributes based on what syntaxes are desired,
   /// allowing for the order to vary.
   bool MaybeParseAttributes(unsigned WhichAttrKinds, ParsedAttributes &Attrs,
                             LateParsedAttrList *LateAttrs = nullptr) {
     if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec) ||
-        (standardAttributesAllowed() && isCXX11AttributeSpecifier())) {
+        isAllowedCXX11AttributeSpecifier()) {
       ParseAttributes(WhichAttrKinds, Attrs, LateAttrs);
       return true;
     }
     return false;
   }
 
   void MaybeParseGNUAttributes(Declarator &D,
                                LateParsedAttrList *LateAttrs = nullptr) {
void ReplayOpenMPAttributeTokens(CachedTokens &OpenMPTokens) {
     if (!OpenMPTokens.empty()) {
       PP.EnterToken(Tok, /*IsReinject*/ true);
       PP.EnterTokenStream(OpenMPTokens, /*DisableMacroExpansion*/ true,
                           /*IsReinject*/ true);
       ConsumeAnyToken(/*ConsumeCodeCompletionTok*/ true);
     }
   }
   void MaybeParseCXX11Attributes(Declarator &D) {
-    if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
+    if (isAllowedCXX11AttributeSpecifier()) {
       ParsedAttributes Attrs(AttrFactory);
       ParseCXX11Attributes(Attrs);
       D.takeAttributes(Attrs);
     }
   }
 
   bool MaybeParseCXX11Attributes(ParsedAttributes &Attrs,
                                  bool OuterMightBeMessageSend = false) {
-    if (standardAttributesAllowed() &&
-        isCXX11AttributeSpecifier(false, OuterMightBeMessageSend)) {
+    if (isAllowedCXX11AttributeSpecifier(false, OuterMightBeMessageSend)) {
       ParseCXX11Attributes(Attrs);
       return true;
     }
     return false;
   }
 
   void ParseOpenMPAttributeArgs(IdentifierInfo *AttrName,
                                 CachedTokens &OpenMPTokens);

clang/include/clang/Sema/DeclSpec.h

Declarator(const DeclSpec &DS, const ParsedAttributesView &DeclarationAttrs,
         Redeclaration(false), Extension(false), ObjCIvar(false),
         ObjCWeakProperty(false), InlineStorageUsed(false),
         HasInitializer(false), Attrs(DS.getAttributePool().getFactory()),
         DeclarationAttrs(DeclarationAttrs), AsmLabel(nullptr),
         TrailingRequiresClause(nullptr),
         InventedTemplateParameterList(nullptr) {
     assert(llvm::all_of(DeclarationAttrs,
                         [](const ParsedAttr &AL) {
-                          return AL.isStandardAttributeSyntax();
+                          return (AL.isStandardAttributeSyntax() ||
+                                  AL.isAttributeLikeKeyword());
                         }) &&
-           "DeclarationAttrs may only contain [[]] attributes");
+           "DeclarationAttrs may only contain [[]] and keyword attributes");
   }
 
   ~Declarator() {
     clear();
   }
   /// getDeclSpec - Return the declaration-specifier that this declarator was
   /// declared with.
   const DeclSpec &getDeclSpec() const { return DS; }
if (!getAttributes().empty() || !getDeclarationAttributes().empty() ||
         getDeclSpec().hasAttributes())
       return true;
     for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i)
       if (!getTypeObject(i).getAttrs().empty())
         return true;
     return false;
   }
 
-  /// Return a source range list of C++11 attributes associated
-  /// with the declarator.
-  void getCXX11AttributeRanges(SmallVectorImpl<SourceRange> &Ranges) {
-    for (const ParsedAttr &AL : Attrs)
-      if (AL.isCXX11Attribute())
-        Ranges.push_back(AL.getRange());
-  }
-
   void setAsmLabel(Expr *E) { AsmLabel = E; }
   Expr *getAsmLabel() const { return AsmLabel; }
 
   void setExtension(bool Val = true) { Extension = Val; }
   bool getExtension() const { return Extension; }
 
   void setObjCIvar(bool Val = true) { ObjCIvar = Val; }
   bool isObjCIvar() const { return ObjCIvar; }

clang/lib/AST/TypePrinter.cpp

void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
 
   OS << ')';
 
   FunctionType::ExtInfo Info = T->getExtInfo();
 
   if ((T->getAArch64SMEAttributes() &
        FunctionType::SME_PStateSMCompatibleMask) &&
       !InsideCCAttribute)
-    OS << " __attribute__((arm_streaming_compatible))";
+    OS << " __arm_streaming_compatible";
   if ((T->getAArch64SMEAttributes() & FunctionType::SME_PStateSMEnabledMask) &&
       !InsideCCAttribute)
-    OS << " __attribute__((arm_streaming))";
+    OS << " __arm_streaming";
   if ((T->getAArch64SMEAttributes() & FunctionType::SME_PStateZANewMask) &&
       !InsideCCAttribute)
-    OS << " __attribute__((arm_new_za))";
+    OS << " __arm_new_za";
   if ((T->getAArch64SMEAttributes() & FunctionType::SME_PStateZASharedMask) &&
       !InsideCCAttribute)
-    OS << " __attribute__((arm_shared_za))";
+    OS << " __arm_shared_za";
   if ((T->getAArch64SMEAttributes() &
        FunctionType::SME_PStateZAPreservedMask) &&
       !InsideCCAttribute)
-    OS << " __attribute__((arm_preserves_za))";
+    OS << " __arm_preserves_za";
 
   printFunctionAfter(Info, OS);
 
   if (!T->getMethodQuals().empty())
     OS << " " << T->getMethodQuals().getAsString();
 
   switch (T->getRefQualifier()) {
   case RQ_None:

clang/lib/Parse/ParseDecl.cpp

 
 /// We have found the opening square brackets of a C++11
 /// attribute-specifier in a location where an attribute is not permitted, but
 /// we know where the attributes ought to be written. Parse them anyway, and
 /// provide a fixit moving them to the right place.
 void Parser::DiagnoseMisplacedCXX11Attribute(ParsedAttributes &Attrs,
                                              SourceLocation CorrectLocation) {
   assert((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) ||
-         Tok.is(tok::kw_alignas));
+         Tok.is(tok::kw_alignas) || Tok.isAttributeLikeKeyword());
 
   // Consume the attributes.
+  auto Keyword =
+      Tok.isAttributeLikeKeyword() ? Tok.getIdentifierInfo() : nullptr;
   SourceLocation Loc = Tok.getLocation();
   ParseCXX11Attributes(Attrs);
   CharSourceRange AttrRange(SourceRange(Loc, Attrs.Range.getEnd()), true);
   // FIXME: use err_attributes_misplaced
-  Diag(Loc, diag::err_attributes_not_allowed)
+  (Keyword ? Diag(Loc, diag::err_keyword_not_allowed) << Keyword
+           : Diag(Loc, diag::err_attributes_not_allowed))
       << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
       << FixItHint::CreateRemoval(AttrRange);
 }
 
 void Parser::DiagnoseProhibitedAttributes(
-    const SourceRange &Range, const SourceLocation CorrectLocation) {
+    const ParsedAttributesView &Attrs, const SourceLocation CorrectLocation) {
+  auto *FirstAttr = Attrs.empty() ? nullptr : &Attrs.front();
   if (CorrectLocation.isValid()) {
-    CharSourceRange AttrRange(Range, true);
-    Diag(CorrectLocation, diag::err_attributes_misplaced)
+    CharSourceRange AttrRange(Attrs.Range, true);
+    (FirstAttr && FirstAttr->isAttributeLikeKeyword()
+         ? Diag(CorrectLocation, diag::err_keyword_misplaced) << FirstAttr
+         : Diag(CorrectLocation, diag::err_attributes_misplaced))
         << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
         << FixItHint::CreateRemoval(AttrRange);
-  } else
-    Diag(Range.getBegin(), diag::err_attributes_not_allowed) << Range;
+  } else {
+    const SourceRange &Range = Attrs.Range;
+    (FirstAttr && FirstAttr->isAttributeLikeKeyword()
+         ? Diag(Range.getBegin(), diag::err_keyword_not_allowed) << FirstAttr
+         : Diag(Range.getBegin(), diag::err_attributes_not_allowed))
+        << Range;
+  }
 }
 
-void Parser::ProhibitCXX11Attributes(ParsedAttributes &Attrs, unsigned DiagID,
+void Parser::ProhibitCXX11Attributes(ParsedAttributes &Attrs,
+                                     unsigned AttrDiagID,
+                                     unsigned KeywordDiagID,
                                      bool DiagnoseEmptyAttrs,
                                      bool WarnOnUnknownAttrs) {
 
   if (DiagnoseEmptyAttrs && Attrs.empty() && Attrs.Range.isValid()) {
     // An attribute list has been parsed, but it was empty.
     // This is the case for [[]].
     const auto &LangOpts = getLangOpts();
     auto &SM = PP.getSourceManager();
     Token FirstLSquare;
     Lexer::getRawToken(Attrs.Range.getBegin(), FirstLSquare, SM, LangOpts);
 
     if (FirstLSquare.is(tok::l_square)) {
       llvm::Optional<Token> SecondLSquare =
           Lexer::findNextToken(FirstLSquare.getLocation(), SM, LangOpts);
 
       if (SecondLSquare && SecondLSquare->is(tok::l_square)) {
         // The attribute range starts with [[, but is empty. So this must
         // be [[]], which we are supposed to diagnose because
         // DiagnoseEmptyAttrs is true.
-        Diag(Attrs.Range.getBegin(), DiagID) << Attrs.Range;
+        Diag(Attrs.Range.getBegin(), AttrDiagID) << Attrs.Range;
         return;
       }
     }
   }
 
   for (const ParsedAttr &AL : Attrs) {
+    if (AL.isAttributeLikeKeyword()) {
+      Diag(AL.getLoc(), KeywordDiagID) << AL;
+      AL.setInvalid();
+      continue;
+    }
     if (!AL.isCXX11Attribute() && !AL.isC2xAttribute())
       continue;
     if (AL.getKind() == ParsedAttr::UnknownAttribute) {
       if (WarnOnUnknownAttrs)
         Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
             << AL << AL.getRange();
     } else {
-      Diag(AL.getLoc(), DiagID) << AL;
+      Diag(AL.getLoc(), AttrDiagID) << AL;
       AL.setInvalid();
     }
   }
 }
 
 void Parser::DiagnoseCXX11AttributeExtension(ParsedAttributes &Attrs) {
   for (const ParsedAttr &PA : Attrs) {
-    if (PA.isCXX11Attribute() || PA.isC2xAttribute())
-      Diag(PA.getLoc(), diag::ext_cxx11_attr_placement) << PA << PA.getRange();
+    if (PA.isCXX11Attribute() || PA.isC2xAttribute() ||
+        PA.isAttributeLikeKeyword())
+      Diag(PA.getLoc(), diag::ext_cxx11_attr_placement)
+          << PA.isAttributeLikeKeyword() << PA << PA.getRange();
   }
 }
 
 // Usually, `__attribute__((attrib)) class Foo {} var` means that attribute
 // applies to var, not the type Foo.
 // As an exception to the rule, __declspec(align(...)) before the
 // class-key affects the type instead of the variable.
 // Also, Microsoft-style [attributes] seem to affect the type instead of the
case tok::colon:
       // this is a bit-field.
       return Context == DeclaratorContext::Member ||
              (getLangOpts().CPlusPlus && Context == DeclaratorContext::File);
 
     case tok::identifier: // Possible virt-specifier.
       return getLangOpts().CPlusPlus11 && isCXX11VirtSpecifier(NextToken());
 
     default:
-      return false;
+      return Tok.isAttributeLikeKeyword();
     }
 
   default:
-    return false;
+    return Tok.isAttributeLikeKeyword();
   }
 }
 
 /// Skip until we reach something which seems like a sensible place to pick
 /// up parsing after a malformed declaration. This will sometimes stop sooner
 /// than SkipUntil(tok::r_brace) would, but will never stop later.
 void Parser::SkipMalformedDecl() {
   while (true) {
while (true) {
     // Turn off usual access checking for template specializations and
     // instantiations.
     bool IsTemplateSpecOrInst =
         (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
          TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
 
     switch (Tok.getKind()) {
     default:
+      if (Tok.isAttributeLikeKeyword())
+        goto Attribute;
+
     DoneWithDeclSpec:
       if (!AttrsLastTime)
         ProhibitAttributes(attrs);
       else {
         // Reject C++11 / C2x attributes that aren't type attributes.
         for (const ParsedAttr &PA : attrs) {
-          if (!PA.isCXX11Attribute() && !PA.isC2xAttribute())
+          if (!PA.isCXX11Attribute() && !PA.isC2xAttribute() &&
+              !PA.isAttributeLikeKeyword())
             continue;
           if (PA.getKind() == ParsedAttr::UnknownAttribute)
             // We will warn about the unknown attribute elsewhere (in
             // SemaDeclAttr.cpp)
             continue;
           // GCC ignores this attribute when placed on the DeclSpec in [[]]
           // syntax, so we do the same.
           if (PA.getKind() == ParsedAttr::AT_VectorSize) {
             Diag(PA.getLoc(), diag::warn_attribute_ignored) << PA;
             PA.setInvalid();
             continue;
           }
           // We reject AT_LifetimeBound and AT_AnyX86NoCfCheck, even though they
           // are type attributes, because we historically haven't allowed these
           // to be used as type attributes in C++11 / C2x syntax.
           if (PA.isTypeAttr() && PA.getKind() != ParsedAttr::AT_LifetimeBound &&
               PA.getKind() != ParsedAttr::AT_AnyX86NoCfCheck)
             continue;
-          Diag(PA.getLoc(), diag::err_attribute_not_type_attr) << PA;
+          Diag(PA.getLoc(), diag::err_attribute_not_type_attr)
+              << PA << PA.isAttributeLikeKeyword();
           PA.setInvalid();
         }
 
         DS.takeAttributesFrom(attrs);
       }
 
       // If this is not a declaration specifier token, we're done reading decl
       // specifiers.  First verify that DeclSpec's are consistent.
       DS.Finish(Actions, Policy);
       return;
 
     case tok::l_square:
     case tok::kw_alignas:
-      if (!standardAttributesAllowed() || !isCXX11AttributeSpecifier())
+      if (!isAllowedCXX11AttributeSpecifier())
         goto DoneWithDeclSpec;
 
+    Attribute:
       ProhibitAttributes(attrs);
       // FIXME: It would be good to recover by accepting the attributes,
       //        but attempting to do that now would cause serious
       //        madness in terms of diagnostics.
       attrs.clear();
       attrs.Range = SourceRange();
 
       ParseCXX11Attributes(attrs);
void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
   //
   // If we parsed any other bits, reject them now.
   //
   // MSVC and (for now at least) Objective-C permit a full enum-specifier
   // or opaque-enum-declaration anywhere.
   if (IsElaboratedTypeSpecifier && !getLangOpts().MicrosoftExt &&
       !getLangOpts().ObjC) {
     ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+                            diag::err_keyword_not_allowed,
                             /*DiagnoseEmptyAttrs=*/true);
     if (BaseType.isUsable())
       Diag(BaseRange.getBegin(), diag::ext_enum_base_in_type_specifier)
           << (AllowEnumSpecifier == AllowDefiningTypeSpec::Yes) << BaseRange;
     else if (ScopedEnumKWLoc.isValid())
       Diag(ScopedEnumKWLoc, diag::ext_elaborated_enum_class)
         << FixItHint::CreateRemoval(ScopedEnumKWLoc) << IsScopedUsingClassTag;
   }
if (Tok.isNot(tok::identifier)) {
       break;
     }
     IdentifierInfo *Ident = Tok.getIdentifierInfo();
     SourceLocation IdentLoc = ConsumeToken();
 
     // If attributes exist after the enumerator, parse them.
     ParsedAttributes attrs(AttrFactory);
     MaybeParseGNUAttributes(attrs);
-    if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
+    if (isAllowedCXX11AttributeSpecifier()) {
       if (getLangOpts().CPlusPlus)
         Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
                                     ? diag::warn_cxx14_compat_ns_enum_attribute
                                     : diag::ext_ns_enum_attribute)
             << 1 /*enumerator*/;
       ParseCXX11Attributes(attrs);
     }
 

 /// [C++0x]    attribute-specifier[opt] is allowed before cv-qualifier-seq
 ///              [ only if AttReqs & AR_CXX11AttributesParsed ]
 /// Note: vendor can be GNU, MS, etc and can be explicitly controlled via
 /// AttrRequirements bitmask values.
 void Parser::ParseTypeQualifierListOpt(
     DeclSpec &DS, unsigned AttrReqs, bool AtomicAllowed,
     bool IdentifierRequired,
     Optional<llvm::function_ref<void()>> CodeCompletionHandler) {
-  if (standardAttributesAllowed() && (AttrReqs & AR_CXX11AttributesParsed) &&
-      isCXX11AttributeSpecifier()) {
+  if ((AttrReqs & AR_CXX11AttributesParsed) &&
+      isAllowedCXX11AttributeSpecifier()) {
     ParsedAttributes Attrs(AttrFactory);
     ParseCXX11Attributes(Attrs);
     DS.takeAttributesFrom(Attrs);
   }
 
   SourceLocation EndLoc;
 
   while (true) {
if (Tok.is(tok::l_paren)) {
         Actions.ActOnStartFunctionDeclarationDeclarator(D,
                                                         TemplateParameterDepth);
       ParseFunctionDeclarator(D, attrs, T, IsAmbiguous);
       if (IsFunctionDeclaration)
         Actions.ActOnFinishFunctionDeclarationDeclarator(D);
       PrototypeScope.Exit();
     } else if (Tok.is(tok::l_square)) {
       ParseBracketDeclarator(D);
+    } else if (Tok.isAttributeLikeKeyword()) {
+      // For consistency with attribute parsing.
+      Diag(Tok, diag::err_keyword_not_allowed) << Tok.getIdentifierInfo();
+      ConsumeToken();
     } else if (Tok.is(tok::kw_requires) && D.hasGroupingParens()) {
       // This declarator is declaring a function, but the requires clause is
       // in the wrong place:
       //   void (f() requires true);
       // instead of
       //   void f() requires true;
       // or
       //   void (f()) requires true;
if (getLangOpts().CPlusPlus) {
           StartLoc = D.getDeclSpec().getTypeSpecTypeLoc();
         LocalEndLoc = Tok.getLocation();
         SourceRange Range;
         TrailingReturnType =
             ParseTrailingReturnType(Range, D.mayBeFollowedByCXXDirectInit());
         TrailingReturnTypeLoc = Range.getBegin();
         EndLoc = Range.getEnd();
       }
-    } else if (standardAttributesAllowed()) {
+    } else {
       MaybeParseCXX11Attributes(FnAttrs);
     }
   }
 
   // Collect non-parameter declarations from the prototype if this is a function
   // declaration. They will be moved into the scope of the function. Only do
   // this in C and not C++, where the decls will continue to live in the
   // surrounding context.

clang/lib/Parse/ParseDeclCXX.cpp

bool Parser::ParseUsingDeclarator(DeclaratorContext Context,
   //   specified after the nested-name-specifier is the same as the identifier
   //   or the simple-template-id's template-name in the last component of the
   //   nested-name-specifier, the name is [...] considered to name the
   //   constructor.
   if (getLangOpts().CPlusPlus11 && Context == DeclaratorContext::Member &&
       Tok.is(tok::identifier) &&
       (NextToken().is(tok::semi) || NextToken().is(tok::comma) ||
        NextToken().is(tok::ellipsis) || NextToken().is(tok::l_square) ||
+       NextToken().isAttributeLikeKeyword() ||
        NextToken().is(tok::kw___attribute)) &&
       D.SS.isNotEmpty() && LastII == Tok.getIdentifierInfo() &&
       !D.SS.getScopeRep()->getAsNamespace() &&
       !D.SS.getScopeRep()->getAsNamespaceAlias()) {
     SourceLocation IdLoc = ConsumeToken();
     ParsedType Type =
         Actions.getInheritingConstructorName(D.SS, IdLoc, *LastII);
     D.Name.setConstructorName(Type, IdLoc, IdLoc);
Parser::DeclGroupPtrTy Parser::ParseUsingDeclaration(
   bool InvalidDeclarator = ParseUsingDeclarator(Context, D);
 
   ParsedAttributes Attrs(AttrFactory);
   MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs);
 
   // If we had any misplaced attributes from earlier, this is where they
   // should have been written.
   if (MisplacedAttrs.Range.isValid()) {
-    Diag(MisplacedAttrs.Range.getBegin(), diag::err_attributes_not_allowed)
+    auto *FirstAttr =
+        MisplacedAttrs.empty() ? nullptr : &MisplacedAttrs.front();
+    auto &Range = MisplacedAttrs.Range;
+    (FirstAttr && FirstAttr->isAttributeLikeKeyword()
+         ? Diag(Range.getBegin(), diag::err_keyword_not_allowed) << FirstAttr
+         : Diag(Range.getBegin(), diag::err_attributes_not_allowed))
         << FixItHint::CreateInsertionFromRange(
-               Tok.getLocation(),
-               CharSourceRange::getTokenRange(MisplacedAttrs.Range))
-        << FixItHint::CreateRemoval(MisplacedAttrs.Range);
+               Tok.getLocation(), CharSourceRange::getTokenRange(Range))
+        << FixItHint::CreateRemoval(Range);
     Attrs.takeAllFrom(MisplacedAttrs);
   }
 
   // Maybe this is an alias-declaration.
   if (Tok.is(tok::equal) || InInitStatement) {
     if (InvalidDeclarator) {
       SkipUntil(tok::semi);
       return nullptr;

 
 /// Determine whether the following tokens are valid after a type-specifier
 /// which could be a standalone declaration. This will conservatively return
 /// true if there's any doubt, and is appropriate for insert-';' fixits.
 bool Parser::isValidAfterTypeSpecifier(bool CouldBeBitfield) {
   // This switch enumerates the valid "follow" set for type-specifiers.
   switch (Tok.getKind()) {
   default:
+    if (Tok.isAttributeLikeKeyword())
+      return true;
     break;
   case tok::semi:              // struct foo {...} ;
   case tok::star:              // struct foo {...} *         P;
   case tok::amp:               // struct foo {...} &         R = ...
   case tok::ampamp:            // struct foo {...} &&        R = ...
   case tok::identifier:        // struct foo {...} V         ;
   case tok::r_paren:           //(struct foo {...} )         {4}
   case tok::coloncolon:        // struct foo {...} ::        a::b;
if (DS.isFriendSpecified()) {
       TUK = Sema::TUK_Friend;
     } else {
       // Okay, this is a class definition.
       TUK = Sema::TUK_Definition;
     }
   } else if (isClassCompatibleKeyword() &&
              (NextToken().is(tok::l_square) ||
               NextToken().is(tok::kw_alignas) ||
+              NextToken().isAttributeLikeKeyword() ||
               isCXX11VirtSpecifier(NextToken()) != VirtSpecifiers::VS_None)) {
     // We can't tell if this is a definition or reference
     // until we skipped the 'final' and C++11 attribute specifiers.
     TentativeParsingAction PA(*this);
 
     // Skip the 'final', abstract'... keywords.
     while (isClassCompatibleKeyword()) {
       ConsumeToken();
     }
 
     // Skip C++11 attribute specifiers.
     while (true) {
       if (Tok.is(tok::l_square) && NextToken().is(tok::l_square)) {
         ConsumeBracket();
         if (!SkipUntil(tok::r_square, StopAtSemi))
           break;
       } else if (Tok.is(tok::kw_alignas) && NextToken().is(tok::l_paren)) {
         ConsumeToken();
         ConsumeParen();
         if (!SkipUntil(tok::r_paren, StopAtSemi))
           break;
+      } else if (Tok.isAttributeLikeKeyword()) {
+        ConsumeToken();
       } else {
         break;
       }
     }
 
     if (Tok.isOneOf(tok::l_brace, tok::colon))
       TUK = Sema::TUK_Definition;
     else
#include "clang/Basic/TransformTypeTraits.def"
   if (TUK != Sema::TUK_Reference) {
     // If this is not a reference, then the only possible
     // valid place for C++11 attributes to appear here
     // is between class-key and class-name. If there are
     // any attributes after class-name, we try a fixit to move
     // them to the right place.
     SourceRange AttrRange = Attributes.Range;
     if (AttrRange.isValid()) {
-      Diag(AttrRange.getBegin(), diag::err_attributes_not_allowed)
+      auto *FirstAttr = Attributes.empty() ? nullptr : &Attributes.front();
+      auto Loc = AttrRange.getBegin();
+      (FirstAttr && FirstAttr->isAttributeLikeKeyword()
+           ? Diag(Loc, diag::err_keyword_not_allowed) << FirstAttr
+           : Diag(Loc, diag::err_attributes_not_allowed))
           << AttrRange
           << FixItHint::CreateInsertionFromRange(
                  AttrFixitLoc, CharSourceRange(AttrRange, true))
           << FixItHint::CreateRemoval(AttrRange);
 
       // Recover by adding misplaced attributes to the attribute list
       // of the class so they can be applied on the class later.
       attrs.takeAllFrom(Attributes);
if (TemplateId) {
     ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
                                        TemplateId->NumArgs);
     if (TemplateId->isInvalid()) {
       // Can't build the declaration.
     } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
                TUK == Sema::TUK_Declaration) {
       // This is an explicit instantiation of a class template.
       ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+                              diag::err_keyword_not_allowed,
                               /*DiagnoseEmptyAttrs=*/true);
 
       TagOrTempResult = Actions.ActOnExplicitInstantiation(
           getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc,
           TagType, StartLoc, SS, TemplateId->Template,
           TemplateId->TemplateNameLoc, TemplateId->LAngleLoc, TemplateArgsPtr,
           TemplateId->RAngleLoc, attrs);
 
       // Friend template-ids are treated as references unless
       // they have template headers, in which case they're ill-formed
       // (FIXME: "template <class T> friend class A<T>::B<int>;").
       // We diagnose this error in ActOnClassTemplateSpecialization.
     } else if (TUK == Sema::TUK_Reference ||
                (TUK == Sema::TUK_Friend &&
                 TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) {
       ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+                              diag::err_keyword_not_allowed,
                               /*DiagnoseEmptyAttrs=*/true);
       TypeResult = Actions.ActOnTagTemplateIdType(
           TUK, TagType, StartLoc, SS, TemplateId->TemplateKWLoc,
           TemplateId->Template, TemplateId->TemplateNameLoc,
           TemplateId->LAngleLoc, TemplateArgsPtr, TemplateId->RAngleLoc);
     } else {
       // This is an explicit specialization or a class template
       // partial specialization.
if (TemplateId) {
     ProhibitAttributes(attrs);
 
     TagOrTempResult = Actions.ActOnExplicitInstantiation(
         getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc,
         TagType, StartLoc, SS, Name, NameLoc, attrs);
   } else if (TUK == Sema::TUK_Friend &&
              TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) {
     ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+                            diag::err_keyword_not_allowed,
                             /*DiagnoseEmptyAttrs=*/true);
 
     TagOrTempResult = Actions.ActOnTemplatedFriendTag(
         getCurScope(), DS.getFriendSpecLoc(), TagType, StartLoc, SS, Name,
         NameLoc, attrs,
         MultiTemplateParamsArg(TemplateParams ? &(*TemplateParams)[0] : nullptr,
                                TemplateParams ? TemplateParams->size() : 0));
   } else {
     if (TUK != Sema::TUK_Declaration && TUK != Sema::TUK_Definition)
       ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
+                              diag::err_keyword_not_allowed,
                               /* DiagnoseEmptyAttrs=*/true);
 
     if (TUK == Sema::TUK_Definition &&
         TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
       // If the declarator-id is not a template-id, issue a diagnostic and
       // recover by ignoring the 'template' keyword.
       Diag(Tok, diag::err_template_defn_explicit_instantiation)
           << 1 << FixItHint::CreateRemoval(TemplateInfo.TemplateLoc);
while (true) {
 
     NamedDecl *ThisDecl = nullptr;
     if (DS.isFriendSpecified()) {
       // C++11 [dcl.attr.grammar] p4: If an attribute-specifier-seq appertains
       // to a friend declaration, that declaration shall be a definition.
       //
       // Diagnose attributes that appear in a friend member function declarator:
       //   friend int foo [[]] ();
-      SmallVector<SourceRange, 4> Ranges;
-      DeclaratorInfo.getCXX11AttributeRanges(Ranges);
-      for (SmallVectorImpl<SourceRange>::iterator I = Ranges.begin(),
-                                                  E = Ranges.end();
-           I != E; ++I)
-        Diag((*I).getBegin(), diag::err_attributes_not_allowed) << *I;
+      for (const ParsedAttr &AL : DeclaratorInfo.getAttributes())
+        if (AL.isCXX11Attribute() || AL.isAttributeLikeKeyword()) {
+          auto Loc = AL.getRange().getBegin();
+          (AL.isAttributeLikeKeyword()
+               ? Diag(Loc, diag::err_keyword_not_allowed) << AL
+               : Diag(Loc, diag::err_attributes_not_allowed))
+              << AL.getRange();
+        }
 
       ThisDecl = Actions.ActOnFriendFunctionDecl(getCurScope(), DeclaratorInfo,
                                                  TemplateParams);
     } else {
       ThisDecl = Actions.ActOnCXXMemberDeclarator(
           getCurScope(), AS, DeclaratorInfo, TemplateParams, BitfieldSize.get(),
           VS, HasInClassInit);
 
void Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs,
                                                   CachedTokens &OpenMPTokens,
                                                   SourceLocation *EndLoc) {
   if (Tok.is(tok::kw_alignas)) {
     Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas);
     ParseAlignmentSpecifier(Attrs, EndLoc);
     return;
   }
 
+  if (Tok.isAttributeLikeKeyword()) {
+    SourceLocation Loc = Tok.getLocation();
+    IdentifierInfo *AttrName = Tok.getIdentifierInfo();
+    Attrs.addNew(AttrName, Loc, nullptr, Loc, nullptr, 0,
+                 ParsedAttr::AS_AttributeLikeKeyword);
+    ConsumeToken();
+    return;
+  }
+
   assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square) &&
          "Not a double square bracket attribute list");
 
   SourceLocation OpenLoc = Tok.getLocation();
   Diag(OpenLoc, diag::warn_cxx98_compat_attribute);
 
   ConsumeBracket();
   checkCompoundToken(OpenLoc, tok::l_square, CompoundToken::AttrBegin);
if (ExpectAndConsume(tok::r_square))
     SkipUntil(tok::r_square);
 }
 
 /// ParseCXX11Attributes - Parse a C++11 or C2x attribute-specifier-seq.
 ///
 /// attribute-specifier-seq:
 ///       attribute-specifier-seq[opt] attribute-specifier
 void Parser::ParseCXX11Attributes(ParsedAttributes &Attrs) {
-  assert(standardAttributesAllowed());
+  assert(standardAttributesAllowed() || Tok.isAttributeLikeKeyword());
 
   SourceLocation StartLoc = Tok.getLocation();
   SourceLocation EndLoc = StartLoc;
 
   do {
     ParseCXX11AttributeSpecifier(Attrs, &EndLoc);
-  } while (isCXX11AttributeSpecifier());
+  } while (isAllowedCXX11AttributeSpecifier());
 
   Attrs.Range = SourceRange(StartLoc, EndLoc);
 }
 
 void Parser::DiagnoseAndSkipCXX11Attributes() {
+  auto Keyword =
+      Tok.isAttributeLikeKeyword() ? Tok.getIdentifierInfo() : nullptr;
   // Start and end location of an attribute or an attribute list.
   SourceLocation StartLoc = Tok.getLocation();
   SourceLocation EndLoc = SkipCXX11Attributes();
 
   if (EndLoc.isValid()) {
     SourceRange Range(StartLoc, EndLoc);
-    Diag(StartLoc, diag::err_attributes_not_allowed) << Range;
+    (Keyword ? Diag(StartLoc, diag::err_keyword_not_allowed) << Keyword
+             : Diag(StartLoc, diag::err_attributes_not_allowed))
+        << Range;
   }
 }
 
 SourceLocation Parser::SkipCXX11Attributes() {
   SourceLocation EndLoc;
 
   if (!isCXX11AttributeSpecifier())
     return EndLoc;
 
   do {
     if (Tok.is(tok::l_square)) {
       BalancedDelimiterTracker T(*this, tok::l_square);
       T.consumeOpen();
       T.skipToEnd();
       EndLoc = T.getCloseLocation();
+    } else if (Tok.isAttributeLikeKeyword()) {
+      EndLoc = Tok.getLocation();
+      ConsumeToken();
     } else {
       assert(Tok.is(tok::kw_alignas) && "not an attribute specifier");
       ConsumeToken();
       BalancedDelimiterTracker T(*this, tok::l_paren);
       if (!T.consumeOpen())
         T.skipToEnd();
       EndLoc = T.getCloseLocation();
     }

clang/lib/Parse/ParseExprCXX.cpp

if (Tok.is(tok::less)) {
     }
   }
 
   // Implement WG21 P2173, which allows attributes immediately before the
   // lambda declarator and applies them to the corresponding function operator
   // or operator template declaration. We accept this as a conforming extension
   // in all language modes that support lambdas.
   if (isCXX11AttributeSpecifier()) {
+    if (Tok.isAttributeLikeKeyword())
       Diag(Tok, getLangOpts().CPlusPlus2b
                     ? diag::warn_cxx20_compat_decl_attrs_on_lambda
-                  : diag::ext_decl_attrs_on_lambda);
+                    : diag::ext_decl_attrs_on_lambda)
+          << 1 << Tok.getIdentifierInfo();
+    else
+      Diag(Tok, getLangOpts().CPlusPlus2b
+                    ? diag::warn_cxx20_compat_decl_attrs_on_lambda
+                    : diag::ext_decl_attrs_on_lambda)
+          << 0 << "";
     MaybeParseCXX11Attributes(D);
   }
 
   TypeResult TrailingReturnType;
   SourceLocation TrailingReturnTypeLoc;
 
   auto ParseLambdaSpecifiers =
       [&](SourceLocation LParenLoc, SourceLocation RParenLoc,
if (Tok.is(tok::l_paren)) {
     if (Tok.is(tok::kw_requires))
       ParseTrailingRequiresClause(D);
   } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
                          tok::kw_constexpr, tok::kw_consteval, tok::kw_static,
                          tok::kw___private, tok::kw___global, tok::kw___local,
                          tok::kw___constant, tok::kw___generic,
                          tok::kw_groupshared, tok::kw_requires,
                          tok::kw_noexcept) ||
+             Tok.isAttributeLikeKeyword() ||
              (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
     if (!getLangOpts().CPlusPlus2b)
       // It's common to forget that one needs '()' before 'mutable', an
       // attribute specifier, the result type, or the requires clause. Deal with
       // this.
       Diag(Tok, diag::ext_lambda_missing_parens)
           << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
 

clang/lib/Parse/ParsePragma.cpp

void Parser::HandlePragmaAttribute() {
   ParsedAttributes &Attrs = Info->Attributes;
   Attrs.clearListOnly();
 
   auto SkipToEnd = [this]() {
     SkipUntil(tok::eof, StopBeforeMatch);
     ConsumeToken();
   };
 
-  if (Tok.is(tok::l_square) && NextToken().is(tok::l_square)) {
+  if ((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) ||
+      Tok.isAttributeLikeKeyword()) {
     // Parse the CXX11 style attribute.
     ParseCXX11AttributeSpecifier(Attrs);
   } else if (Tok.is(tok::kw___attribute)) {
     ConsumeToken();
     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
                          "attribute"))
       return SkipToEnd();
     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "("))

clang/lib/Parse/ParseStmt.cpp

case tok::kw_return:              // C99 6.8.6.4: return-statement
     break;
   case tok::kw_co_return:            // C++ Coroutines: co_return statement
     Res = ParseReturnStatement();
     SemiError = "co_return";
     break;
 
   case tok::kw_asm: {
     for (const ParsedAttr &AL : CXX11Attrs)
-      Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
+      // Could be relaxed if any statement attribute-like keywords are
+      // added later.
+      (AL.isAttributeLikeKeyword()
+           ? Diag(AL.getRange().getBegin(), diag::err_keyword_not_allowed)
+           : Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored))
+          << AL;
     // Prevent these from being interpreted as statement attributes later on.
     CXX11Attrs.clear();
     ProhibitAttributes(GNUAttrs);
     bool msAsm = false;
     Res = ParseAsmStatement(msAsm);
     if (msAsm) return Res;
     SemiError = "asm";
     break;

clang/lib/Parse/ParseTentative.cpp

 ///     attribute-argument-clause:
 ///         '(' balanced-token-seq ')'
 Parser::CXX11AttributeKind
 Parser::isCXX11AttributeSpecifier(bool Disambiguate,
                                   bool OuterMightBeMessageSend) {
   if (Tok.is(tok::kw_alignas))
     return CAK_AttributeSpecifier;
 
+  if (Tok.isAttributeLikeKeyword())
+    return CAK_AttributeSpecifier;
+
   if (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square))
     return CAK_NotAttributeSpecifier;
 
   // No tentative parsing if we don't need to look for ']]' or a lambda.
   if (!Disambiguate && !getLangOpts().ObjC)
     return CAK_AttributeSpecifier;
 
   // '[[using ns: ...]]' is an attribute.
if (IsAttribute)
     return CAK_AttributeSpecifier;
 
   // Case 3: Message send.
   return CAK_NotAttributeSpecifier;
 }
 
 bool Parser::TrySkipAttributes() {
   while (Tok.isOneOf(tok::l_square, tok::kw___attribute, tok::kw___declspec,
-                     tok::kw_alignas)) {
+                     tok::kw_alignas) ||
+         Tok.isAttributeLikeKeyword()) {
     if (Tok.is(tok::l_square)) {
       ConsumeBracket();
       if (Tok.isNot(tok::l_square))
         return false;
       ConsumeBracket();
       if (!SkipUntil(tok::r_square) || Tok.isNot(tok::r_square))
         return false;
       // Note that explicitly checking for `[[` and `]]` allows to fail as
       // expected in the case of the Objective-C message send syntax.
       ConsumeBracket();
+    } else if (Tok.isAttributeLikeKeyword()) {
+      ConsumeToken();
     } else {
       ConsumeToken();
       if (Tok.isNot(tok::l_paren))
         return false;
       ConsumeParen();
       if (!SkipUntil(tok::r_paren))
         return false;
     }

clang/lib/Parse/Parser.cpp

if (Tok.is(tok::colon)) {
     else if (ParseModuleName(ModuleLoc, Partition, /*IsImport*/ false))
       return nullptr;
   }
 
   // We don't support any module attributes yet; just parse them and diagnose.
   ParsedAttributes Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
   ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr,
+                          diag::err_keyword_not_module_attr,
                           /*DiagnoseEmptyAttrs=*/false,
                           /*WarnOnUnknownAttrs=*/true);
 
   ExpectAndConsumeSemi(diag::err_module_expected_semi);
 
   return Actions.ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path, Partition,
                                  ImportState);
 }
if (Tok.is(tok::header_name)) {
     if (ParseModuleName(ImportLoc, Path, /*IsImport*/ true))
       return nullptr;
   }
 
   ParsedAttributes Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
   // We don't support any module import attributes yet.
   ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr,
+                          diag::err_keyword_not_import_attr,
                           /*DiagnoseEmptyAttrs=*/false,
                           /*WarnOnUnknownAttrs=*/true);
 
   if (PP.hadModuleLoaderFatalFailure()) {
     // With a fatal failure in the module loader, we abort parsing.
     cutOffParsing();
     return nullptr;
   }

clang/lib/Sema/ParsedAttr.cpp

 
 bool ParsedAttr::isKnownToGCC() const { return getInfo().IsKnownToGCC; }
 
 bool ParsedAttr::isSupportedByPragmaAttribute() const {
   return getInfo().IsSupportedByPragmaAttribute;
 }
 
 bool ParsedAttr::slidesFromDeclToDeclSpecLegacyBehavior() const {
+  if (isAttributeLikeKeyword())
+    // The appurtenance rules are applied strictly for all attribute-like
+    // keywords.
+    return false;
+
   assert(isStandardAttributeSyntax());
 
   // We have historically allowed some type attributes with standard attribute
   // syntax to slide to the decl-specifier-seq, so we have to keep supporting
   // it. This property is consciously not defined as a flag in Attr.td because
   // we don't want new attributes to specify it.
   //
   // Note: No new entries should be added to this list. Entries should be

clang/lib/Sema/Sema.cpp

if (WeakIDs.second.empty())
       continue;
 
     Decl *PrevDecl = LookupSingleName(TUScope, WeakIDs.first, SourceLocation(),
                                       LookupOrdinaryName);
     if (PrevDecl != nullptr &&
         !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
       for (const auto &WI : WeakIDs.second)
         Diag(WI.getLocation(), diag::warn_attribute_wrong_decl_type)
-            << "'weak'" << ExpectedVariableOrFunction;
+            << "'weak'" << 0 << ExpectedVariableOrFunction;
     else
       for (const auto &WI : WeakIDs.second)
         Diag(WI.getLocation(), diag::warn_weak_identifier_undeclared)
             << WeakIDs.first;
   }
 
   if (LangOpts.CPlusPlus11 &&
       !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))

clang/lib/Sema/SemaDecl.cpp

Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
   // Attributes should be placed after tag to apply to type declaration.
   if (!DS.getAttributes().empty() || !DeclAttrs.empty()) {
     DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
     if (TypeSpecType == DeclSpec::TST_class ||
         TypeSpecType == DeclSpec::TST_struct ||
         TypeSpecType == DeclSpec::TST_interface ||
         TypeSpecType == DeclSpec::TST_union ||
         TypeSpecType == DeclSpec::TST_enum) {
-      for (const ParsedAttr &AL : DS.getAttributes())
+      for (const ParsedAttr &AL : DS.getAttributes()) {
+        assert(!AL.isAttributeLikeKeyword() &&
+               "Failed to diagnose misplaced attribute-like keywords");
         Diag(AL.getLoc(), diag::warn_declspec_attribute_ignored)
             << AL << GetDiagnosticTypeSpecifierID(TypeSpecType);
-      for (const ParsedAttr &AL : DeclAttrs)
+      }
+      for (const ParsedAttr &AL : DeclAttrs) {
+        assert(!AL.isAttributeLikeKeyword() &&
+               "Failed to diagnose misplaced attribute-like keywords");
         Diag(AL.getLoc(), diag::warn_declspec_attribute_ignored)
             << AL << GetDiagnosticTypeSpecifierID(TypeSpecType);
       }
     }
+  }
 
   return TagD;
 }
 
 /// We are trying to inject an anonymous member into the given scope;
 /// check if there's an existing declaration that can't be overloaded.
 ///
 /// \return true if this is a forbidden redeclaration

clang/lib/Sema/SemaDeclAttr.cpp

 //===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements decl-related attribute processing.
static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr,
   return true;
 }
 
 /// Diagnose mutually exclusive attributes when present on a given
 /// declaration. Returns true if diagnosed.
 template <typename AttrTy>
 static bool checkAttrMutualExclusion(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (const auto *A = D->getAttr<AttrTy>()) {
-    S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A;
+    S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
+        << AL << A
+        << (AL.isAttributeLikeKeyword() || A->isAttributeLikeKeyword());
     S.Diag(A->getLocation(), diag::note_conflicting_attribute);
     return true;
   }
   return false;
 }
 
 template <typename AttrTy>
 static bool checkAttrMutualExclusion(Sema &S, Decl *D, const Attr &AL) {
   if (const auto *A = D->getAttr<AttrTy>()) {
-    S.Diag(AL.getLocation(), diag::err_attributes_are_not_compatible) << &AL
-                                                                      << A;
+    S.Diag(AL.getLocation(), diag::err_attributes_are_not_compatible)
+        << &AL << A
+        << (AL.isAttributeLikeKeyword() || A->isAttributeLikeKeyword());
     S.Diag(A->getLocation(), diag::note_conflicting_attribute);
     return true;
   }
   return false;
 }
 
 /// Check if IdxExpr is a valid parameter index for a function or
 /// instance method D.  May output an error.
if (-1 != Err) {
       return;
     }
 
     // Check we don't have a conflict with another ownership attribute.
     for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
       // Cannot have two ownership attributes of different kinds for the same
       // index.
       if (I->getOwnKind() != K && llvm::is_contained(I->args(), Idx)) {
-        S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << I;
+        S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
+            << AL << I
+            << (AL.isAttributeLikeKeyword() || I->isAttributeLikeKeyword());
         return;
       } else if (K == OwnershipAttr::Returns &&
                  I->getOwnKind() == OwnershipAttr::Returns) {
         // A returns attribute conflicts with any other returns attribute using
         // a different index.
         if (!llvm::is_contained(I->args(), Idx)) {
           S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
               << I->args_begin()->getSourceIndex();
if (Arch != llvm::Triple::x86 &&
           << AL << Triple.getArchName();
       return;
     }
 
     // This form is not allowed to be written on a member function (static or
     // nonstatic) when in Microsoft compatibility mode.
     if (S.getLangOpts().MSVCCompat && isa<CXXMethodDecl>(D)) {
       S.Diag(AL.getLoc(), diag::err_attribute_wrong_decl_type_str)
-          << AL << "non-member functions";
+          << AL << 0 << "non-member functions";
       return;
     }
   }
 
   D->addAttr(::new (S.Context) NakedAttr(S.Context, AL));
 }
 
 static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
   if (hasDeclarator(D)) return;
 
   if (!isa<ObjCMethodDecl>(D)) {
     S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type)
-        << Attrs << ExpectedFunctionOrMethod;
+        << Attrs << 0 << ExpectedFunctionOrMethod;
     return;
   }
 
   D->addAttr(::new (S.Context) NoReturnAttr(S.Context, Attrs));
 }
 
 static void handleStandardNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &A) {
   // The [[_Noreturn]] spelling is deprecated in C2x, so if that was used,
bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) {
   }
 
   return false;
 }
 
 bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
   // Check whether the attribute is valid on the current target.
   if (!AL.existsInTarget(Context.getTargetInfo())) {
-    Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
+    Diag(AL.getLoc(), AL.isAttributeLikeKeyword()
+                          ? diag::err_keyword_not_supported_on_target
+                          : diag::warn_unknown_attribute_ignored)
         << AL << AL.getRange();
     AL.setInvalid();
     return true;
   }
 
   return false;
 }
 
 static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
 
   // The checking path for 'noreturn' and 'analyzer_noreturn' are different
   // because 'analyzer_noreturn' does not impact the type.
   if (!isFunctionOrMethodOrBlock(D)) {
     ValueDecl *VD = dyn_cast<ValueDecl>(D);
     if (!VD || (!VD->getType()->isBlockPointerType() &&
                 !VD->getType()->isFunctionPointerType())) {
-      S.Diag(AL.getLoc(), AL.isStandardAttributeSyntax()
-                              ? diag::err_attribute_wrong_decl_type
-                              : diag::warn_attribute_wrong_decl_type)
-          << AL << ExpectedFunctionMethodOrBlock;
+      S.Diag(AL.getLoc(),
+             (AL.isStandardAttributeSyntax() || AL.isAttributeLikeKeyword()
+                  : diag::warn_attribute_wrong_decl_type))
+          << AL << 0 << ExpectedFunctionMethodOrBlock;
       return;
     }
   }
 
   D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(S.Context, AL));
 }
 
 // PS3 PPU-specific.
static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL,
                                  bool isTypeVisibility) {
   // Visibility attributes don't mean anything on a typedef.
   if (isa<TypedefNameDecl>(D)) {
     S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
     return;
   }
 
   // 'type_visibility' can only go on a type or namespace.
-  if (isTypeVisibility &&
-      !(isa<TagDecl>(D) ||
-        isa<ObjCInterfaceDecl>(D) ||
+  if (isTypeVisibility && !(isa<TagDecl>(D) || isa<ObjCInterfaceDecl>(D) ||
                             isa<NamespaceDecl>(D))) {
     S.Diag(AL.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
-        << AL << ExpectedTypeOrNamespace;
+        << AL << 0 << ExpectedTypeOrNamespace;
     return;
   }
 
   // Check that the argument is a string literal.
   StringRef TypeStr;
   SourceLocation LiteralLoc;
   if (!S.checkStringLiteralArgumentAttr(AL, 0, TypeStr, &LiteralLoc))
     return;
if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
                                          ->castAs<FunctionType>();
       if (!cast<FunctionProtoType>(FT)->isVariadic()) {
         int m = Ty->isFunctionPointerType() ? 0 : 1;
         S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
         return;
       }
     } else {
       S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
-          << AL << ExpectedFunctionMethodOrBlock;
+          << AL << 0 << ExpectedFunctionMethodOrBlock;
       return;
     }
   } else {
     S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
-        << AL << ExpectedFunctionMethodOrBlock;
+        << AL << 0 << ExpectedFunctionMethodOrBlock;
     return;
   }
   D->addAttr(::new (S.Context) SentinelAttr(S.Context, AL, sentinel, nullPos));
 }
 
 static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (D->getFunctionType() &&
       D->getFunctionType()->getReturnType()->isVoidType() &&
       !isa<CXXConstructorDecl>(D)) {
     S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 0;
     return;
   }
   if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
     if (MD->getReturnType()->isVoidType()) {
       S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 1;
       return;
     }
 
   StringRef Str;
   if (AL.isStandardAttributeSyntax() && !AL.getScopeName()) {
     // The standard attribute cannot be applied to variable declarations such
     // as a function pointer.
     if (isa<VarDecl>(D))
       S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str)
-          << AL << "functions, classes, or enumerations";
+          << AL << 0 << "functions, classes, or enumerations";
 
     // If this is spelled as the standard C++17 attribute, but not in C++17,
     // warn about using it as an extension. If there are attribute arguments,
     // then claim it's a C++2a extension instead.
     // FIXME: If WG14 does not seem likely to adopt the same feature, add an
     // extension warning for C2x mode.
     const LangOptions &LO = S.getLangOpts();
     if (AL.getNumArgs() == 1) {
if (isDef)
       S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition)
         << "weak_import";
     else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
              (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
               (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
       // Nothing to warn about here.
     } else
       S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
-          << AL << ExpectedVariableOrFunction;
+          << AL << 0 << ExpectedVariableOrFunction;
 
     return;
   }
 
   D->addAttr(::new (S.Context) WeakImportAttr(S.Context, AL));
 }
 
 // Handles reqd_work_group_size and work_group_size_hint.
ErrorAttr *Sema::mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI,
   if (const auto *EA = D->getAttr<ErrorAttr>()) {
     std::string NewAttr = CI.getNormalizedFullName();
     assert((NewAttr == "error" || NewAttr == "warning") &&
            "unexpected normalized full name");
     bool Match = (EA->isError() && NewAttr == "error") ||
                  (EA->isWarning() && NewAttr == "warning");
     if (!Match) {
       Diag(EA->getLocation(), diag::err_attributes_are_not_compatible)
-          << CI << EA;
+          << CI << EA << 0;
       Diag(CI.getLoc(), diag::note_conflicting_attribute);
       return nullptr;
     }
     if (EA->getUserDiagnostic() != NewUserDiagnostic) {
       Diag(CI.getLoc(), diag::warn_duplicate_attribute) << EA;
       Diag(EA->getLoc(), diag::note_previous_attribute);
     }
     D->dropAttr<ErrorAttr>();
static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   RecordDecl *RD = nullptr;
   const auto *TD = dyn_cast<TypedefNameDecl>(D);
   if (TD && TD->getUnderlyingType()->isUnionType())
     RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
   else
     RD = dyn_cast<RecordDecl>(D);
 
   if (!RD || !RD->isUnion()) {
-    S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL
-                                                              << ExpectedUnion;
+    S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
+        << AL << 0 << ExpectedUnion;
     return;
   }
 
   if (!RD->isCompleteDefinition()) {
     if (!RD->isBeingDefined())
       S.Diag(AL.getLoc(),
              diag::warn_transparent_union_attribute_not_definition);
     return;
if (isa<ParmVarDecl>(D)) {
         DiagKind = 2;
     } else if (const auto *FD = dyn_cast<FieldDecl>(D)) {
       if (FD->isBitField())
         DiagKind = 3;
     } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
       if (ED->getLangOpts().CPlusPlus)
         DiagKind = 4;
     } else if (!isa<TagDecl>(D)) {
-      Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
+      Diag(AttrLoc, diag::err_attribute_wrong_decl_type)
+          << &TmpAttr << 0
           << (TmpAttr.isC11() ? ExpectedVariableOrField
                               : ExpectedVariableFieldOrTag);
       return;
     }
     if (DiagKind != -1) {
       Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
         << &TmpAttr << DiagKind;
       return;
     }
   }

 
 InternalLinkageAttr *Sema::mergeInternalLinkageAttr(Decl *D,
                                                     const ParsedAttr &AL) {
   if (const auto *VD = dyn_cast<VarDecl>(D)) {
     // Attribute applies to Var but not any subclass of it (like ParmVar,
     // ImplicitParm or VarTemplateSpecialization).
     if (VD->getKind() != Decl::Var) {
       Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
-          << AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
-                                            : ExpectedVariableOrFunction);
+          << AL << 0
+          << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
       return nullptr;
     }
     // Attribute does not apply to non-static local variables.
     if (VD->hasLocalStorage()) {
       Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
       return nullptr;
     }
   }
 
   return ::new (Context) InternalLinkageAttr(Context, AL);
 }
 InternalLinkageAttr *
 Sema::mergeInternalLinkageAttr(Decl *D, const InternalLinkageAttr &AL) {
   if (const auto *VD = dyn_cast<VarDecl>(D)) {
     // Attribute applies to Var but not any subclass of it (like ParmVar,
     // ImplicitParm or VarTemplateSpecialization).
     if (VD->getKind() != Decl::Var) {
       Diag(AL.getLocation(), diag::warn_attribute_wrong_decl_type)
-          << &AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
-                                             : ExpectedVariableOrFunction);
+          << &AL << 0
+          << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
       return nullptr;
     }
     // Attribute does not apply to non-static local variables.
     if (VD->hasLocalStorage()) {
       Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
       return nullptr;
     }
   }
MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI) {
   return ::new (Context) MinSizeAttr(Context, CI);
 }
 
 SwiftNameAttr *Sema::mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA,
                                         StringRef Name) {
   if (const auto *PrevSNA = D->getAttr<SwiftNameAttr>()) {
     if (PrevSNA->getName() != Name && !PrevSNA->isImplicit()) {
       Diag(PrevSNA->getLocation(), diag::err_attributes_are_not_compatible)
-          << PrevSNA << &SNA;
+          << PrevSNA << &SNA << 0;
       Diag(SNA.getLoc(), diag::note_conflicting_attribute);
     }
 
     D->dropAttr<SwiftNameAttr>();
   }
   return ::new (Context) SwiftNameAttr(Context, SNA, Name);
 }
 
static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   // Diagnostic is emitted elsewhere: here we store the (valid) AL
   // in the Decl node for syntactic reasoning, e.g., pretty-printing.
   CallingConv CC;
   if (S.CheckCallingConvAttr(AL, CC, /*FD*/nullptr))
     return;
 
   if (!isa<ObjCMethodDecl>(D)) {
     S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
-        << AL << ExpectedFunctionOrMethod;
+        << AL << AL.isAttributeLikeKeyword() << ExpectedFunctionOrMethod;
     return;
   }
 
   switch (AL.getKind()) {
   case ParsedAttr::AT_FastCall:
     D->addAttr(::new (S.Context) FastCallAttr(S.Context, AL));
     return;
   case ParsedAttr::AT_StdCall:
if (AL.getKind() == ParsedAttr::AT_Owner) {
     if (checkAttrMutualExclusion<PointerAttr>(S, D, AL))
       return;
     if (const auto *OAttr = D->getAttr<OwnerAttr>()) {
       const Type *ExistingDerefType = OAttr->getDerefTypeLoc()
                                           ? OAttr->getDerefType().getTypePtr()
                                           : nullptr;
       if (ExistingDerefType != ParmType.getTypePtrOrNull()) {
         S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
-            << AL << OAttr;
+            << AL << OAttr << 0;
         S.Diag(OAttr->getLocation(), diag::note_conflicting_attribute);
       }
       return;
     }
     for (Decl *Redecl : D->redecls()) {
       Redecl->addAttr(::new (S.Context) OwnerAttr(S.Context, AL, DerefTypeLoc));
     }
   } else {
     if (checkAttrMutualExclusion<OwnerAttr>(S, D, AL))
       return;
     if (const auto *PAttr = D->getAttr<PointerAttr>()) {
       const Type *ExistingDerefType = PAttr->getDerefTypeLoc()
                                           ? PAttr->getDerefType().getTypePtr()
                                           : nullptr;
       if (ExistingDerefType != ParmType.getTypePtrOrNull()) {
         S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
-            << AL << PAttr;
+            << AL << PAttr << 0;
         S.Diag(PAttr->getLocation(), diag::note_conflicting_attribute);
       }
       return;
     }
     for (Decl *Redecl : D->redecls()) {
       Redecl->addAttr(::new (S.Context)
                           PointerAttr(S.Context, AL, DerefTypeLoc));
     }

 void Sema::AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI,
                                ParameterABI abi) {
 
   QualType type = cast<ParmVarDecl>(D)->getType();
 
   if (auto existingAttr = D->getAttr<ParameterABIAttr>()) {
     if (existingAttr->getABI() != abi) {
       Diag(CI.getLoc(), diag::err_attributes_are_not_compatible)
-          << getParameterABISpelling(abi) << existingAttr;
+          << getParameterABISpelling(abi) << existingAttr << 0;
       Diag(existingAttr->getLocation(), diag::note_conflicting_attribute);
       return;
     }
   }
 
   switch (abi) {
   case ParameterABI::Ordinary:
     llvm_unreachable("explicit attribute for ordinary parameter ABI?");
if (!AL.isArgIdent(0)) {
     return;
   }
 
   if (!AL.checkExactlyNumArgs(S, 1))
     return;
 
   if (!isa<VarDecl>(D)) {
     S.Diag(AL.getLoc(), diag::err_attribute_wrong_decl_type)
-        << AL << ExpectedVariable;
+        << AL << 0 << ExpectedVariable;
     return;
   }
 
   IdentifierInfo *PointerKind = AL.getArgAsIdent(0)->Ident;
   TypeSourceInfo *MatchingCTypeLoc = nullptr;
   S.GetTypeFromParser(AL.getMatchingCType(), &MatchingCTypeLoc);
   assert(MatchingCTypeLoc && "no type source info for attribute argument");
 
if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
     case ParsedAttr::AT_OSReturnsRetained:
     case ParsedAttr::AT_OSReturnsNotRetained:
     case ParsedAttr::AT_CFReturnsRetained:
     case ParsedAttr::AT_CFReturnsNotRetained:
       ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
       break;
     }
     S.Diag(D->getBeginLoc(), diag::warn_attribute_wrong_decl_type)
-        << AL.getRange() << AL << ExpectedDeclKind;
+        << AL.getRange() << AL << 0 << ExpectedDeclKind;
     return;
   }
 
   bool TypeOK;
   bool Cf;
   unsigned ParmDiagID = 2; // Pointer-to-CF-pointer
   switch (AL.getKind()) {
   default: llvm_unreachable("invalid ownership attribute");
if (notify) {
       // modification of existing declaration
       if (ASTMutationListener *L = S.getASTMutationListener())
         L->AddedAttributeToRecord(BoxableAttr, RD);
     }
   }
 }
 
 static void handleObjCOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
-  if (hasDeclarator(D)) return;
+  if (hasDeclarator(D))
+    return;
 
   S.Diag(D->getBeginLoc(), diag::err_attribute_wrong_decl_type)
-      << AL.getRange() << AL << ExpectedVariable;
+      << AL.getRange() << AL << 0 << ExpectedVariable;
 }
 
 static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
                                           const ParsedAttr &AL) {
   const auto *VD = cast<ValueDecl>(D);
   QualType QT = VD->getType();
 
   if (!QT->isDependentType() &&
if (const auto *Method = dyn_cast<ObjCMethodDecl>(D)) {
       Params = Method->parameters().slice(0, ParamCount);
     } else {
       const auto *F = cast<FunctionDecl>(D);
 
       ParamCount = F->getNumParams();
       Params = F->parameters();
 
       if (!F->hasWrittenPrototype()) {
-        Diag(Loc, diag::warn_attribute_wrong_decl_type) << AL
-            << ExpectedFunctionWithProtoType;
+        Diag(Loc, diag::warn_attribute_wrong_decl_type)
+            << AL << 0 << ExpectedFunctionWithProtoType;
         return false;
       }
     }
 
     // The async name drops the last callback parameter.
     if (IsAsync) {
       if (ParamCount == 0) {
         Diag(Loc, diag::warn_attr_swift_name_decl_missing_params)
static void handleSwiftNewType(Sema &S, Decl *D, const ParsedAttr &AL) {
   IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
   if (!SwiftNewTypeAttr::ConvertStrToNewtypeKind(II->getName(), Kind)) {
     S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
     return;
   }
 
   if (!isa<TypedefNameDecl>(D)) {
     S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str)
-        << AL << "typedefs";
+        << AL << 0 << "typedefs";
     return;
   }
 
   D->addAttr(::new (S.Context) SwiftNewTypeAttr(S.Context, AL, Kind));
 }
 
 static void handleSwiftAsyncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (!AL.isArgIdent(0)) {
static void handleARMInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   D->addAttr(::new (S.Context) ARMInterruptAttr(S.Context, AL, Kind));
 }
 
 static void handleMSP430InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   // MSP430 'interrupt' attribute is applied to
   // a function with no parameters and void return type.
   if (!isFunctionOrMethod(D)) {
     S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
-        << "'interrupt'" << ExpectedFunctionOrMethod;
+        << "'interrupt'" << 0 << ExpectedFunctionOrMethod;
     return;
   }
 
   if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
     S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
         << /*MSP430*/ 1 << 0;
     return;
   }
static void handleMipsInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   // c) Must have the 'void' return type.
   // d) Cannot have the 'mips16' attribute, as that instruction set
   //    lacks the 'eret' instruction.
   // e) The attribute itself must either have no argument or one of the
   //    valid interrupt types, see [MipsInterruptDocs].
 
   if (!isFunctionOrMethod(D)) {
     S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
-        << "'interrupt'" << ExpectedFunctionOrMethod;
+        << "'interrupt'" << 0 << ExpectedFunctionOrMethod;
     return;
   }
 
   if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
     S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
         << /*MIPS*/ 0 << 0;
     return;
   }
static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   // b) Must have the 'void' return type.
   // c) Must take 1 or 2 arguments.
   // d) The 1st argument must be a pointer.
   // e) The 2nd argument (if any) must be an unsigned integer.
   if (!isFunctionOrMethod(D) || !hasFunctionProto(D) || isInstanceMethod(D) ||
       CXXMethodDecl::isStaticOverloadedOperator(
           cast<NamedDecl>(D)->getDeclName().getCXXOverloadedOperator())) {
     S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
-        << AL << ExpectedFunctionWithProtoType;
+        << AL << 0 << ExpectedFunctionWithProtoType;
     return;
   }
   // Interrupt handler must have void return type.
   if (!getFunctionOrMethodResultType(D)->isVoidType()) {
     S.Diag(getFunctionOrMethodResultSourceRange(D).getBegin(),
            diag::err_anyx86_interrupt_attribute)
         << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
                 ? 0
static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   }
   D->addAttr(::new (S.Context) AnyX86InterruptAttr(S.Context, AL));
   D->addAttr(UsedAttr::CreateImplicit(S.Context));
 }
 
 static void handleAVRInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (!isFunctionOrMethod(D)) {
     S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
-        << "'interrupt'" << ExpectedFunction;
+        << "'interrupt'" << 0 << ExpectedFunction;
     return;
   }
 
   if (!AL.checkExactlyNumArgs(S, 0))
     return;
 
   handleSimpleAttribute<AVRInterruptAttr>(S, D, AL);
 }
 
 static void handleAVRSignalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (!isFunctionOrMethod(D)) {
     S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
-        << "'signal'" << ExpectedFunction;
+        << "'signal'" << 0 << ExpectedFunction;
     return;
   }
 
   if (!AL.checkExactlyNumArgs(S, 0))
     return;
 
   handleSimpleAttribute<AVRSignalAttr>(S, D, AL);
 }

 }
 
 BTFDeclTagAttr *Sema::mergeBTFDeclTagAttr(Decl *D, const BTFDeclTagAttr &AL) {
   if (hasBTFDeclTagAttr(D, AL.getBTFDeclTag()))
     return nullptr;
   return ::new (Context) BTFDeclTagAttr(Context, AL, AL.getBTFDeclTag());
 }
 
-static void handleWebAssemblyExportNameAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+static void handleWebAssemblyExportNameAttr(Sema &S, Decl *D,
+                                            const ParsedAttr &AL) {
   if (!isFunctionOrMethod(D)) {
     S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
-        << "'export_name'" << ExpectedFunction;
+        << "'export_name'" << 0 << ExpectedFunction;
     return;
   }
 
   auto *FD = cast<FunctionDecl>(D);
   if (FD->isThisDeclarationADefinition()) {
     S.Diag(D->getLocation(), diag::err_alias_is_definition) << FD << 0;
     return;
   }
static void handleRISCVInterruptAttr(Sema &S, Decl *D,
   // - Must be a function.
   // - Must have no parameters.
   // - Must have the 'void' return type.
   // - The attribute itself must either have no argument or one of the
   //   valid interrupt types, see [RISCVInterruptDocs].
 
   if (D->getFunctionType() == nullptr) {
     S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
-      << "'interrupt'" << ExpectedFunction;
+        << "'interrupt'" << 0 << ExpectedFunction;
     return;
   }
 
   if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
     S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
       << /*RISC-V*/ 2 << 0;
     return;
   }
static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D,
   // Also don't warn on function pointer typedefs.
   const auto *TD = dyn_cast<TypedefNameDecl>(D);
   if (TD && (TD->getUnderlyingType()->isFunctionPointerType() ||
     TD->getUnderlyingType()->isFunctionType()))
     return;
   // Attribute can only be applied to function types.
   if (!isa<FunctionDecl>(D)) {
     S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
-        << AL << ExpectedFunction;
+        << AL << 0 << ExpectedFunction;
     return;
   }
 
   D->addAttr(::new (S.Context) X86ForceAlignArgPointerAttr(S.Context, AL));
 }
 
 static void handleLayoutVersion(Sema &S, Decl *D, const ParsedAttr &AL) {
   uint32_t Version;
static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D,
   normalizeName(AttrName);
   StringRef SanitizerName = llvm::StringSwitch<StringRef>(AttrName)
                                 .Case("no_address_safety_analysis", "address")
                                 .Case("no_sanitize_address", "address")
                                 .Case("no_sanitize_thread", "thread")
                                 .Case("no_sanitize_memory", "memory");
   if (isGlobalVar(D) && SanitizerName != "address")
     S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
-        << AL << ExpectedFunction;
+        << AL << 0 << ExpectedFunction;
 
   // FIXME: Rather than create a NoSanitizeSpecificAttr, this creates a
   // NoSanitizeAttr object; but we need to calculate the correct spelling list
   // index rather than incorrectly assume the index for NoSanitizeSpecificAttr
   // has the same spellings as the index for NoSanitizeAttr. We don't have a
   // general way to "translate" between the two, so this hack attempts to work
   // around the issue with hard-coded indices. This is critical for calling
   // getSpelling() or prettyPrint() on the resulting semantic attribute object
if (AL.getSyntax() == ParsedAttr::AS_CXX11 && !Options.IncludeCXX11Attributes)
     return;
 
   // Unknown attributes are automatically warned on. Target-specific attributes
   // which do not apply to the current target architecture are treated as
   // though they were unknown attributes.
   if (AL.getKind() == ParsedAttr::UnknownAttribute ||
       !AL.existsInTarget(S.Context.getTargetInfo())) {
     S.Diag(AL.getLoc(),
-           AL.isDeclspecAttribute()
+           AL.isAttributeLikeKeyword()
+               ? (unsigned)diag::err_keyword_not_supported_on_target
+           : AL.isDeclspecAttribute()
                ? (unsigned)diag::warn_unhandled_ms_attribute_ignored
                : (unsigned)diag::warn_unknown_attribute_ignored)
         << AL << AL.getRange();
     return;
   }
 
   // Check if argument population must delayed to after template instantiation.
   bool MustDelayArgs = MustDelayAttributeArguments(AL);
default:
     if (AL.getInfo().handleDeclAttribute(S, D, AL) != ParsedAttrInfo::NotHandled)
       break;
     if (!AL.isStmtAttr()) {
       assert(AL.isTypeAttr() && "Non-type attribute not handled");
     }
     if (AL.isTypeAttr()) {
       if (Options.IgnoreTypeAttributes)
         break;
-      if (!AL.isStandardAttributeSyntax()) {
+      if (!AL.isStandardAttributeSyntax() && !AL.isAttributeLikeKeyword()) {
         // Non-[[]] type attributes are handled in processTypeAttrs(); silently
         // move on.
         break;
       }
 
       // According to the C and C++ standards, we should never see a
       // [[]] type attribute on a declaration. However, we have in the past
       // allowed some type attributes to "slide" to the `DeclSpec`, so we need
if (AL.isTypeAttr()) {
         break;
       }
     }
     // N.B., ClangAttrEmitter.cpp emits a diagnostic helper that ensures a
     // statement attribute is not written on a declaration, but this code is
     // needed for type attributes as well as statement attributes in Attr.td
     // that do not list any subjects.
     S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
-        << AL << D->getLocation();
+        << AL << AL.isAttributeLikeKeyword() << D->getLocation();
     break;
   case ParsedAttr::AT_Interrupt:
     handleInterruptAttr(S, D, AL);
     break;
   case ParsedAttr::AT_X86ForceAlignArgPointer:
     handleX86ForceAlignArgPointerAttr(S, D, AL);
     break;
   case ParsedAttr::AT_DLLExport:
if (const auto *A = D->getAttr<ReqdWorkGroupSizeAttr>()) {
       Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
       D->setInvalidDecl();
     } else if (const auto *A = D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
       Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
       D->setInvalidDecl();
     } else if (!D->hasAttr<CUDAGlobalAttr>()) {
       if (const auto *A = D->getAttr<AMDGPUFlatWorkGroupSizeAttr>()) {
         Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
-            << A << ExpectedKernelFunction;
+            << A << 0 << ExpectedKernelFunction;
         D->setInvalidDecl();
       } else if (const auto *A = D->getAttr<AMDGPUWavesPerEUAttr>()) {
         Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
-            << A << ExpectedKernelFunction;
+            << A << 0 << ExpectedKernelFunction;
         D->setInvalidDecl();
       } else if (const auto *A = D->getAttr<AMDGPUNumSGPRAttr>()) {
         Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
-            << A << ExpectedKernelFunction;
+            << A << 0 << ExpectedKernelFunction;
         D->setInvalidDecl();
       } else if (const auto *A = D->getAttr<AMDGPUNumVGPRAttr>()) {
         Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
-            << A << ExpectedKernelFunction;
+            << A << 0 << ExpectedKernelFunction;
         D->setInvalidDecl();
       }
     }
   }
 
   // Do this check after processing D's attributes because the attribute
   // objc_method_family can change whether the given method is in the init
   // family, and it can be applied after objc_designated_initializer. This is a
if (AL.isUsedAsTypeAttr() || AL.isInvalid())
       continue;
     if (AL.getKind() == ParsedAttr::IgnoredAttribute)
       continue;
 
     if (AL.getKind() == ParsedAttr::UnknownAttribute) {
       S.Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
           << AL << AL.getRange();
     } else {
-      S.Diag(AL.getLoc(), diag::warn_attribute_not_on_decl) << AL
-                                                            << AL.getRange();
+      S.Diag(AL.getLoc(), diag::warn_attribute_not_on_decl)
+          << AL << AL.getRange();
     }
   }
 }
 
 /// checkUnusedDeclAttributes - Given a declarator which is not being
 /// used to build a declaration, complain about any decl attributes
 /// which might be lying around on it.
 void Sema::checkUnusedDeclAttributes(Declarator &D) {

clang/lib/Sema/SemaDeclCXX.cpp

BaseResult Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
   // We haven't yet attached the base specifiers.
   Class->setIsParsingBaseSpecifiers();
 
   // We do not support any C++11 attributes on base-specifiers yet.
   // Diagnose any attributes we see.
   for (const ParsedAttr &AL : Attributes) {
     if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
       continue;
-    Diag(AL.getLoc(), AL.getKind() == ParsedAttr::UnknownAttribute
-                          ? (unsigned)diag::warn_unknown_attribute_ignored
-                          : (unsigned)diag::err_base_specifier_attribute)
+    if (AL.getKind() == ParsedAttr::UnknownAttribute)
+      Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
           << AL << AL.getRange();
+    else
+      Diag(AL.getLoc(), diag::err_base_specifier_attribute)
+          << AL << AL.isAttributeLikeKeyword() << AL.getRange();
   }
 
   TypeSourceInfo *TInfo = nullptr;
   GetTypeFromParser(basetype, &TInfo);
 
   if (EllipsisLoc.isInvalid() &&
       DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
                                       UPPC_BaseType))

clang/lib/Sema/SemaStmtAttr.cpp

static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A,
   // Unknown attributes are automatically warned on. Target-specific attributes
   // which do not apply to the current target architecture are treated as
   // though they were unknown attributes.
   const TargetInfo *Aux = S.Context.getAuxTargetInfo();
   if (A.getKind() == ParsedAttr::UnknownAttribute ||
       !(A.existsInTarget(S.Context.getTargetInfo()) ||
         (S.Context.getLangOpts().SYCLIsDevice && Aux &&
          A.existsInTarget(*Aux)))) {
-    S.Diag(A.getLoc(), A.isDeclspecAttribute()
+    S.Diag(A.getLoc(), A.isAttributeLikeKeyword()
+                           ? (unsigned)diag::err_keyword_not_supported_on_target
+                       : A.isDeclspecAttribute()
                            ? (unsigned)diag::warn_unhandled_ms_attribute_ignored
                            : (unsigned)diag::warn_unknown_attribute_ignored)
         << A << A.getRange();
     return nullptr;
   }
 
   if (S.checkCommonAttributeFeatures(St, A))
     return nullptr;
case ParsedAttr::AT_Likely:
     return handleLikely(S, St, A, Range);
   case ParsedAttr::AT_Unlikely:
     return handleUnlikely(S, St, A, Range);
   default:
     // N.B., ClangAttrEmitter.cpp emits a diagnostic helper that ensures a
     // declaration attribute is not written on a statement, but this code is
     // needed for attributes in Attr.td that do not list any subjects.
     S.Diag(A.getRange().getBegin(), diag::err_decl_attribute_invalid_on_stmt)
-        << A << St->getBeginLoc();
+        << A << A.isAttributeLikeKeyword() << St->getBeginLoc();
     return nullptr;
   }
 }
 
 void Sema::ProcessStmtAttributes(Stmt *S, const ParsedAttributes &InAttrs,
                                  SmallVectorImpl<const Attr *> &OutAttrs) {
   for (const ParsedAttr &AL : InAttrs) {
     if (const Attr *A = ProcessStmtAttribute(*this, S, AL, InAttrs.Range))
       OutAttrs.push_back(A);
   }
 
   CheckForIncompatibleAttributes(*this, OutAttrs);
 }

clang/lib/Sema/SemaType.cpp

static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr,
   if (useExpansionLoc && loc.isMacroID() && II) {
     if (II->isStr("strong")) {
       if (S.findMacroSpelling(loc, "__strong")) name = "__strong";
     } else if (II->isStr("weak")) {
       if (S.findMacroSpelling(loc, "__weak")) name = "__weak";
     }
   }
 
-  S.Diag(loc, diag::warn_type_attribute_wrong_type) << name << WhichType
-    << type;
+  S.Diag(loc, attr.isAttributeLikeKeyword()
+                  ? diag::err_type_attribute_wrong_type
+                  : diag::warn_type_attribute_wrong_type)
+      << name << WhichType << type;
 }
 
 // objc_gc applies to Objective-C pointers or, otherwise, to the
 // smallest available pointer type (i.e. 'void*' in 'void**').
 #define OBJC_POINTER_TYPE_ATTRS_CASELIST                                       \
   case ParsedAttr::AT_ObjCGC:                                                  \
   case ParsedAttr::AT_ObjCOwnership
 
static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state,
                                               QualType &declSpecType) {
   // The called functions in this loop actually remove things from the current
   // list, so iterating over the existing list isn't possible.  Instead, make a
   // non-owning copy and iterate over that.
   ParsedAttributesView AttrsCopy{state.getDeclarator().getAttributes()};
   for (ParsedAttr &attr : AttrsCopy) {
     // Do not distribute [[]] attributes. They have strict rules for what
     // they appertain to.
-    if (attr.isStandardAttributeSyntax())
+    if (attr.isStandardAttributeSyntax() || attr.isAttributeLikeKeyword())
       continue;
 
     switch (attr.getKind()) {
     OBJC_POINTER_TYPE_ATTRS_CASELIST:
       distributeObjCPointerTypeAttrFromDeclarator(state, attr, declSpecType);
       break;
 
     FUNCTION_TYPE_ATTRS_CASELIST:
static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &State,
   }
   Attrs[NewAttrKind] = true;
 
   // You cannot have both __sptr and __uptr on the same type, nor can you
   // have __ptr32 and __ptr64.
   if (Attrs[attr::Ptr32] && Attrs[attr::Ptr64]) {
     S.Diag(PAttr.getLoc(), diag::err_attributes_are_not_compatible)
         << "'__ptr32'"
-        << "'__ptr64'";
+        << "'__ptr64'" << 0;
     return true;
   } else if (Attrs[attr::SPtr] && Attrs[attr::UPtr]) {
     S.Diag(PAttr.getLoc(), diag::err_attributes_are_not_compatible)
         << "'__sptr'"
-        << "'__uptr'";
+        << "'__uptr'" << 0;
     return true;
   }
 
   // Check the raw (i.e., desugared) Canonical type to see if it
   // is a pointer type.
   if (!isa<PointerType>(Desugared)) {
     // Pointer type qualifiers can only operate on pointer types, but not
     // pointer-to-member types.
static bool checkMutualExclusion(TypeProcessingState &state,
   auto OtherAttr = std::find_if(
       state.getCurrentAttributes().begin(), state.getCurrentAttributes().end(),
       [OtherKind](const ParsedAttr &A) { return A.getKind() == OtherKind; });
   if (OtherAttr == state.getCurrentAttributes().end() || OtherAttr->isInvalid())
     return false;
 
   Sema &S = state.getSema();
   S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
-      << *OtherAttr << Attr;
+      << *OtherAttr << Attr
+      << (OtherAttr->isAttributeLikeKeyword() || Attr.isAttributeLikeKeyword());
   S.Diag(OtherAttr->getLoc(), diag::note_conflicting_attribute);
   Attr.setInvalid();
   return true;
 }
 
 /// Process an individual function attribute.  Returns true to
 /// indicate that the attribute was handled, false if it wasn't.
 static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
if (attr.getKind() == ParsedAttr::AT_Regparm) {
     if (!unwrapped.isFunctionType())
       return false;
 
     // Diagnose regparm with fastcall.
     const FunctionType *fn = unwrapped.get();
     CallingConv CC = fn->getCallConv();
     if (CC == CC_X86FastCall) {
       S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
-        << FunctionType::getNameForCallConv(CC)
-        << "regparm";
+          << FunctionType::getNameForCallConv(CC) << "regparm" << 0;
       attr.setInvalid();
       return true;
     }
 
     FunctionType::ExtInfo EI =
       unwrapped.get()->getExtInfo().withRegParm(value);
     type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
     return true;
static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
   CallingConv CCOld = fn->getCallConv();
   Attr *CCAttr = getCCTypeAttr(S.Context, attr);
 
   if (CCOld != CC) {
     // Error out on when there's already an attribute on the type
     // and the CCs don't match.
     if (S.getCallingConvAttributedType(type)) {
       S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
           << FunctionType::getNameForCallConv(CC)
-        << FunctionType::getNameForCallConv(CCOld);
+          << FunctionType::getNameForCallConv(CCOld) << 0;
       attr.setInvalid();
       return true;
     }
   }
 
   // Diagnose use of variadic functions with calling conventions that
   // don't support them (e.g. because they're callee-cleanup).
   // We delay warning about this on unprototyped function declarations
if (FnP && FnP->isVariadic()) {
       return S.Diag(attr.getLoc(), diag::err_cconv_varargs)
              << FunctionType::getNameForCallConv(CC);
     }
   }
 
   // Also diagnose fastcall with regparm.
   if (CC == CC_X86FastCall && fn->getHasRegParm()) {
     S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
-        << "regparm" << FunctionType::getNameForCallConv(CC_X86FastCall);
+        << "regparm" << FunctionType::getNameForCallConv(CC_X86FastCall) << 0;
     attr.setInvalid();
     return true;
   }
 
   // Modify the CC from the wrapped function type, wrap it all back, and then
   // wrap the whole thing in an AttributedType as written.  The modified type
   // might have a different CC if we ignored the attribute.
   QualType Equivalent;
static void processTypeAttrs(TypeProcessingState &state, QualType &type,
   // over that.
   ParsedAttributesView AttrsCopy{attrs};
   for (ParsedAttr &attr : AttrsCopy) {
 
     // Skip attributes that were marked to be invalid.
     if (attr.isInvalid())
       continue;
 
-    if (attr.isStandardAttributeSyntax()) {
+    if (attr.isStandardAttributeSyntax() || attr.isAttributeLikeKeyword()) {
       // [[gnu::...]] attributes are treated as declaration attributes, so may
       // not appertain to a DeclaratorChunk. If we handle them as type
       // attributes, accept them in that position and diagnose the GCC
       // incompatibility.
       if (attr.isGNUScope()) {
+        assert(attr.isStandardAttributeSyntax());
         bool IsTypeAttr = attr.isTypeAttr();
         if (TAL == TAL_DeclChunk) {
           state.getSema().Diag(attr.getLoc(),
                                IsTypeAttr
                                    ? diag::warn_gcc_ignores_type_attr
                                    : diag::warn_cxx11_gnu_attribute_on_type)
               << attr;
           if (!IsTypeAttr)
if (attr.isStandardAttributeSyntax() || attr.isAttributeLikeKeyword()) {
       }
     }
 
     // If this is an attribute we can handle, do so now,
     // otherwise, add it to the FnAttrs list for rechaining.
     switch (attr.getKind()) {
     default:
       // A [[]] attribute on a declarator chunk must appertain to a type.
-      if (attr.isStandardAttributeSyntax() && TAL == TAL_DeclChunk) {
+      if ((attr.isStandardAttributeSyntax() || attr.isAttributeLikeKeyword()) &&
+          TAL == TAL_DeclChunk) {
         state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr)
-            << attr;
+            << attr << attr.isAttributeLikeKeyword();
         attr.setUsedAsTypeAttr();
       }
       break;
 
     case ParsedAttr::UnknownAttribute:
       if (attr.isStandardAttributeSyntax()) {
         state.getSema().Diag(attr.getLoc(),
                              diag::warn_unknown_attribute_ignored)
// clang, so revert to attribute-based handling for C.
       if (!state.getSema().getLangOpts().CPlusPlus)
         break;
       [[fallthrough]];
     FUNCTION_TYPE_ATTRS_CASELIST:
       attr.setUsedAsTypeAttr();
 
       // Attributes with standard syntax have strict rules for what they
       // appertain to and hence should not use the "distribution" logic below.
-      if (attr.isStandardAttributeSyntax()) {
+      if (attr.isStandardAttributeSyntax() || attr.isAttributeLikeKeyword()) {
         if (!handleFunctionTypeAttr(state, attr, type)) {
           diagnoseBadTypeAttribute(state.getSema(), attr, type);
           attr.setInvalid();
         }
         break;
       }
 
       // Never process function type attributes as part of the

clang/test/AST/ast-dump-sme-attributes.cpp

 // Test without serialization:
 // RUN: %clang_cc1 -triple aarch64 -target-feature +sme -std=c++2a -ast-dump -ast-dump-filter Foo %s | FileCheck -strict-whitespace %s
 
 // Test with serialization:
 // RUN: %clang_cc1 -std=c++20 -triple aarch64 -target-feature +sme -emit-pch -o %t %s
 // RUN: %clang_cc1 -x c++ -std=c++20 -triple aarch64 -target-feature +sme -include-pch %t -ast-dump-all -ast-dump-filter Foo /dev/null \
 // RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
 // RUN: | FileCheck --strict-whitespace %s
 
 struct Foo {
 // CHECK:      |-CXXRecordDecl {{.*}} implicit struct Foo
-// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_streaming 'void () __attribute__((arm_streaming))'
-// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_streaming_compatible 'void () __attribute__((arm_streaming_compatible))'
+// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_streaming 'void () __arm_streaming'
+// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_streaming_compatible 'void () __arm_streaming_compatible'
 // CHECK-NEXT: |-CXXMethodDecl {{.*}} f_locally_streaming 'void ()'
 // CHECK-NEXT: | `-ArmLocallyStreamingAttr {{.*}}
-// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_shared_za 'void () __attribute__((arm_shared_za))'
-// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_new_za 'void () __attribute__((arm_new_za))'
-// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_preserves_za 'void () __attribute__((arm_preserves_za))'
-  void f_streaming() __attribute__((arm_streaming));
-  void f_streaming_compatible() __attribute__((arm_streaming_compatible));
-  void f_locally_streaming() __attribute__((arm_locally_streaming));
-  void f_shared_za() __attribute__((arm_shared_za));
-  void f_new_za() __attribute__((arm_new_za));
-  void f_preserves_za() __attribute__((arm_preserves_za));
+// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_shared_za 'void () __arm_shared_za'
+// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_new_za 'void () __arm_new_za'
+// CHECK-NEXT: |-CXXMethodDecl {{.*}} f_preserves_za 'void () __arm_preserves_za'
+  void f_streaming() __arm_streaming;
+  void f_streaming_compatible() __arm_streaming_compatible;
+  __arm_locally_streaming void f_locally_streaming();
+  void f_shared_za() __arm_shared_za;
+  void f_new_za() __arm_new_za;
+  void f_preserves_za() __arm_preserves_za;
 
 
 // CHECK:      |-CXXMethodDecl {{.*}} test_lambda 'int (int)' implicit-inline
 // CHECK:         `-CompoundStmt
 // CHECK-NEXT:     |-DeclStmt
 // CHECK-NEXT:     | `-VarDecl
 // CHECK-NEXT:     |   `-LambdaExpr
 // CHECK-NEXT:     |     |-CXXRecordDecl
-// CHECK:          |     | |-CXXMethodDecl {{.*}} used constexpr operator() 'int (int) __attribute__((arm_streaming)) const' inline
-// CHECK:          |     | |-CXXConversionDecl {{.*}} implicit constexpr operator int (*)(int) __attribute__((arm_streaming)) 'int (*() const noexcept)(int) __attribute__((arm_streaming))' inline
-// CHECK:          |     | |-CXXMethodDecl {{.*}} implicit __invoke 'int (int) __attribute__((arm_streaming))' static inline
+// CHECK:          |     | |-CXXMethodDecl {{.*}} used constexpr operator() 'int (int) __arm_streaming const' inline
+// CHECK:          |     | |-CXXConversionDecl {{.*}} implicit constexpr operator int (*)(int) __arm_streaming 'int (*() const noexcept)(int) __arm_streaming' inline
+// CHECK:          |     | |-CXXMethodDecl {{.*}} implicit __invoke 'int (int) __arm_streaming' static inline
 // CHECK:          `-ReturnStmt
 // CHECK:            `-CXXOperatorCallExpr
-// CHECK-NEXT:         |-ImplicitCastExpr {{.*}} 'int (*)(int) __attribute__((arm_streaming)) const' <FunctionToPointerDecay>
-// CHECK-NEXT:         | `-DeclRefExpr {{.*}} 'int (int) __attribute__((arm_streaming)) const' lvalue CXXMethod {{.*}} 'operator()' 'int (int) __attribute__((arm_streaming)) const'
+// CHECK-NEXT:         |-ImplicitCastExpr {{.*}} 'int (*)(int) __arm_streaming const' <FunctionToPointerDecay>
+// CHECK-NEXT:         | `-DeclRefExpr {{.*}} 'int (int) __arm_streaming const' lvalue CXXMethod {{.*}} 'operator()' 'int (int) __arm_streaming const'
   int test_lambda(int x) {
-    auto F = [](int x) __attribute__((arm_streaming)) { return x; };
+    auto F = [](int x) __arm_streaming { return x; };
     return F(x);
   }
 
-// CHECK: |-TypedefDecl {{.*}} referenced s_ptrty 'void (*)(int, int) __attribute__((arm_streaming))'
-// CHECK-NEXT: | `-PointerType {{.*}} 'void (*)(int, int) __attribute__((arm_streaming))'
-// CHECK-NEXT: |   `-ParenType {{.*}} 'void (int, int) __attribute__((arm_streaming))' sugar
-// CHECK-NEXT: |     `-FunctionProtoType {{.*}} 'void (int, int) __attribute__((arm_streaming))' cdecl
-  typedef void __attribute__((arm_streaming)) (*s_ptrty) (int, int);
+// CHECK: |-TypedefDecl {{.*}} referenced s_ptrty 'void (*)(int, int) __arm_streaming'
+// CHECK-NEXT: | `-PointerType {{.*}} 'void (*)(int, int) __arm_streaming'
+// CHECK-NEXT: |   `-ParenType {{.*}} 'void (int, int) __arm_streaming' sugar
+// CHECK-NEXT: |     `-FunctionProtoType {{.*}} 'void (int, int) __arm_streaming' cdecl
+  typedef void (*__arm_streaming s_ptrty) (int, int);
 
 // CHECK:      `-CXXMethodDecl {{.*}} test_streaming_ptrty 'void (s_ptrty, int, int)' implicit-inline
-// CHECK-NEXT:   |-ParmVarDecl {{.*}} used f 's_ptrty':'void (*)(int, int) __attribute__((arm_streaming))'
+// CHECK-NEXT:   |-ParmVarDecl {{.*}} used f 's_ptrty':'void (*)(int, int) __arm_streaming'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} used x 'int'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} used y 'int'
 // CHECK:        `-CompoundStmt
 // CHECK-NEXT:     `-ReturnStmt
 // CHECK-NEXT:       `-CallExpr
-// CHECK-NEXT:         |-ImplicitCastExpr {{.*}} 's_ptrty':'void (*)(int, int) __attribute__((arm_streaming))' <LValueToRValue>
-// CHECK-NEXT:         | `-DeclRefExpr {{.*}} 's_ptrty':'void (*)(int, int) __attribute__((arm_streaming))' lvalue ParmVar {{.*}} 'f' 's_ptrty':'void (*)(int, int) __attribute__((arm_streaming))'
+// CHECK-NEXT:         |-ImplicitCastExpr {{.*}} 's_ptrty':'void (*)(int, int) __arm_streaming' <LValueToRValue>
+// CHECK-NEXT:         | `-DeclRefExpr {{.*}} 's_ptrty':'void (*)(int, int) __arm_streaming' lvalue ParmVar {{.*}} 'f' 's_ptrty':'void (*)(int, int) __arm_streaming'
 // CHECK-NEXT:         |-ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
 // CHECK-NEXT:         | `-DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:         `-ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
 // CHECK-NEXT:           `-DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} 'y' 'int'
   void test_streaming_ptrty(s_ptrty f, int x, int y) { return f(x, y); };
 };

clang/test/CXX/modules-ts/basic/basic.link/module-declaration.cpp

 // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \
 // RUN:            -DTEST=7 -DEXPORT=export -DMODULE_NAME='z elderberry'
 // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \
 // RUN:            -DTEST=8 -DEXPORT=export -DMODULE_NAME='z [[]]'
 // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \
 // RUN:            -DTEST=9 -DEXPORT=export -DMODULE_NAME='z [[fancy]]'
 // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \
 // RUN:            -DTEST=10 -DEXPORT=export -DMODULE_NAME='z [[maybe_unused]]'
+// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \
+// RUN:            -DTEST=11 -DEXPORT=export -DMODULE_NAME='z __arm_streaming'
 
 EXPORT module MODULE_NAME;
 #if TEST == 4
 // expected-error@-2 {{redefinition of module 'x'}}
 // [e-mail]:* {{loaded from '{{.*[/\\]}}x.pcm'}}
 #elif TEST == 7
 // expected-error@-5 {{expected ';'}} expected-error@-5 {{a type specifier is required}}
 #elif TEST == 9
 // expected-warning@-7 {{unknown attribute 'fancy' ignored}}
 #elif TEST == 10
 // expected-error-re@-9 {{'maybe_unused' attribute cannot be applied to a module{{$}}}}
 #elif TEST == 1
 // expected-error@-11 {{definition of module 'z' is not available}}
+#elif TEST == 11
+// expected-error-re@-13 {{'__arm_streaming' cannot be applied to a module{{$}}}}
 #else
 // expected-no-diagnostics
 #endif

clang/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.import/p1.cpp

 // There is no relation between module x and module x.y.
 int use_3 = c; // expected-error {{declaration of 'c' must be imported from module 'x.y'}}
                // [e-mail]:1 {{not visible}}
 
 import x [[]];
 import x [[foo]]; // expected-warning {{unknown attribute 'foo' ignored}}
 import x [[noreturn]]; // expected-error {{'noreturn' attribute cannot be applied to a module import}}
 import x [[blarg::noreturn]]; // expected-warning {{unknown attribute 'noreturn' ignored}}
+import x __arm_streaming; // expected-error {{'__arm_streaming' cannot be applied to a module import}}
 
 import x.y;
 import a.b; // Does not imply existence of module a.
 import x.; // expected-error {{expected a module name after 'import'}}
 import .x; // expected-error {{expected a module name after 'import'}}
 
 int use_4 = c; // ok
 
 import blarg; // expected-error {{module 'blarg' not found}}

clang/test/CodeGen/aarch64-sme-intrinsics/aarch64-sme-attrs.cpp

 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme \
 // RUN:   -S -O0 -Werror -emit-llvm -o - %s | FileCheck %s
 
 extern "C" {
 
 extern int normal_callee();
 
 // == FUNCTION DECLARATIONS ==
 
-__attribute__((arm_streaming)) int streaming_decl();
-__attribute__((arm_streaming_compatible)) int streaming_compatible_decl();
-__attribute__((arm_shared_za)) int shared_za_decl();
-__attribute__((arm_preserves_za)) int preserves_za_decl();
-__attribute__((arm_new_za)) int new_za_decl();
+int streaming_decl() __arm_streaming;
+int streaming_compatible_decl() __arm_streaming_compatible;
+int shared_za_decl() __arm_shared_za;
+int preserves_za_decl() __arm_preserves_za;
+int new_za_decl() __arm_new_za;
 
 // == FUNCTION DEFINITIONS ==
 
 // CHECK-LABEL: @streaming_caller()
 // CHECK-SAME: #[[SM_ENABLED:[0-9]+]]
 // CHECK: call i32 @normal_callee()
 //
-__attribute__((arm_streaming)) int streaming_caller() {
+int streaming_caller() __arm_streaming {
   return normal_callee();
 }
 
 // CHECK: declare i32 @normal_callee() #[[NORMAL_DECL:[0-9]+]]
 
 
 // CHECK-LABEL: @streaming_callee()
 // CHECK-SAME: #[[SM_ENABLED]]
 // CHECK: call i32 @streaming_decl() #[[SM_ENABLED_CALL:[0-9]+]]
 //
-__attribute__((arm_streaming)) int streaming_callee() {
+int streaming_callee() __arm_streaming {
   return streaming_decl();
 }
 
 // CHECK: declare i32 @streaming_decl() #[[SM_ENABLED_DECL:[0-9]+]]
 
 // CHECK-LABEL: @streaming_compatible_caller()
 // CHECK-SAME: #[[SM_COMPATIBLE:[0-9]+]]
 // CHECK: call i32 @normal_callee()
 //
-__attribute__((arm_streaming_compatible)) int streaming_compatible_caller() {
+int streaming_compatible_caller() __arm_streaming_compatible {
   return normal_callee();
 }
 
 // CHECK-LABEL: @streaming_compatible_callee()
 // CHECK-SAME: #[[SM_COMPATIBLE]]
 // CHECK: call i32 @streaming_compatible_decl() #[[SM_COMPATIBLE_CALL:[0-9]+]]
 //
-__attribute__((arm_streaming_compatible)) int streaming_compatible_callee() {
+int streaming_compatible_callee() __arm_streaming_compatible {
   return streaming_compatible_decl();
 }
 
 // CHECK: declare i32 @streaming_compatible_decl() #[[SM_COMPATIBLE_DECL:[0-9]+]]
 
 // CHECK-LABEL: @locally_streaming_caller()
 // CHECK-SAME: #[[SM_BODY:[0-9]+]]
 // CHECK: call i32 @normal_callee()
 //
-__attribute__((arm_locally_streaming)) int locally_streaming_caller() {
+__arm_locally_streaming int locally_streaming_caller() {
   return normal_callee();
 }
 
 // CHECK-LABEL: @locally_streaming_callee()
 // CHECK-SAME: #[[SM_BODY]]
 // CHECK: call i32 @locally_streaming_caller() #[[SM_BODY_CALL:[0-9]+]]
 //
-__attribute__((arm_locally_streaming)) int locally_streaming_callee() {
+__arm_locally_streaming int locally_streaming_callee() {
   return locally_streaming_caller();
 }
 
 
 // CHECK-LABEL: @shared_za_caller()
 // CHECK-SAME: #[[ZA_SHARED:[0-9]+]]
 // CHECK: call i32 @normal_callee()
 //
-__attribute__((arm_shared_za)) int shared_za_caller() {
+int shared_za_caller() __arm_shared_za {
   return normal_callee();
 }
 
 // CHECK-LABEL: @shared_za_callee()
 // CHECK-SAME: #[[ZA_SHARED]]
 // CHECK: call i32 @shared_za_decl() #[[ZA_SHARED_CALL:[0-9]+]]
 //
-__attribute__((arm_shared_za)) int shared_za_callee() {
+int shared_za_callee() __arm_shared_za {
   return shared_za_decl();
 }
 
 // CHECK: declare i32 @shared_za_decl() #[[ZA_SHARED_DECL:[0-9]+]]
 
 
 // CHECK-LABEL: @preserves_za_caller()
 // CHECK-SAME: #[[ZA_PRESERVED:[0-9]+]]
 // CHECK: call i32 @normal_callee()
 //
-__attribute__((arm_preserves_za)) int preserves_za_caller() {
+int preserves_za_caller() __arm_preserves_za {
   return normal_callee();
 }
 
 // CHECK-LABEL: @preserves_za_callee()
 // CHECK-SAME: #[[ZA_PRESERVED]]
 // CHECK: call i32 @preserves_za_decl() #[[ZA_PRESERVED_CALL:[0-9]+]]
 //
-__attribute__((arm_preserves_za)) int preserves_za_callee() {
+int preserves_za_callee() __arm_preserves_za {
   return preserves_za_decl();
 }
 
 // CHECK: declare i32 @preserves_za_decl() #[[ZA_PRESERVED_DECL:[0-9]+]]
 
 
 // CHECK-LABEL: @new_za_caller()
 // CHECK-SAME: #[[ZA_NEW:[0-9]+]]
 // CHECK: call i32 @normal_callee()
 //
-__attribute__((arm_new_za)) int new_za_caller() {
+int new_za_caller() __arm_new_za {
   return normal_callee();
 }
 
 // CHECK-LABEL: @new_za_callee()
 // CHECK-SAME: #[[ZA_NEW]]
 // CHECK: call i32 @new_za_decl() #[[ZA_NEW_CALL:[0-9]+]]
 //
-__attribute__((arm_new_za)) int new_za_callee() {
+int new_za_callee() __arm_new_za {
   return new_za_decl();
 }
 
 // CHECK: declare i32 @new_za_decl() #[[ZA_NEW_DECL:[0-9]+]]
 
 
 // Ensure that the attributes are correctly propagated to function types
 // and also to callsites.
-typedef void __attribute__((arm_streaming)) (*s_ptrty) (int, int);
-typedef void __attribute__((arm_streaming_compatible)) (*sc_ptrty) (int, int);
-typedef void __attribute__((arm_new_za)) (*nz_ptrty) (int, int);
-typedef void __attribute__((arm_shared_za)) (*sz_ptrty) (int, int);
-typedef void __attribute__((arm_preserves_za)) (*pz_ptrty) (int, int);
+typedef void (*__arm_streaming s_ptrty) (int, int);
+typedef void (*__arm_streaming_compatible sc_ptrty) (int, int);
+typedef void (*__arm_new_za nz_ptrty) (int, int);
+typedef void (*__arm_shared_za sz_ptrty) (int, int);
+typedef void (*__arm_preserves_za pz_ptrty) (int, int);
 
 // CHECK-LABEL: @test_streaming_ptrty(
 // CHECK-SAME: #[[NORMAL_DEF:[0-9]+]]
 // CHECK: call void [[F:%.*]](i32 noundef [[X:%.*]], i32 noundef [[Y:%.*]]) #[[SM_ENABLED_CALL]]
 //
 void test_streaming_ptrty(s_ptrty f, int x, int y) { return f(x, y); }
 // CHECK-LABEL: @test_streaming_compatible_ptrty(
 // CHECK-SAME: #[[NORMAL_DEF]]
 // CHECK: call void [[F:%.*]](i32 noundef [[X:%.*]], i32 noundef [[Y:%.*]]) #[[SM_COMPATIBLE_CALL]]
 //
 void test_streaming_compatible_ptrty(sc_ptrty f, int x, int y) { return f(x, y); }
 // CHECK-LABEL: @test_new_za(
 // CHECK-SAME: #[[ZA_SHARED]]
 // CHECK: call void [[F:%.*]](i32 noundef [[X:%.*]], i32 noundef [[Y:%.*]]) #[[ZA_NEW_CALL]]
 //
-void __attribute__((arm_shared_za)) test_new_za(nz_ptrty f, int x, int y) { return f(x, y); }
+void test_new_za(nz_ptrty f, int x, int y) __arm_shared_za { return f(x, y); }
 // CHECK-LABEL: @test_shared_za(
 // CHECK-SAME: #[[ZA_SHARED]]
 // CHECK: call void [[F:%.*]](i32 noundef [[X:%.*]], i32 noundef [[Y:%.*]]) #[[ZA_SHARED_CALL]]
 //
-void __attribute__((arm_shared_za)) test_shared_za(sz_ptrty f, int x, int y) { return f(x, y); }
+void test_shared_za(sz_ptrty f, int x, int y) __arm_shared_za { return f(x, y); }
 // CHECK-LABEL: @test_preserved_za(
 // CHECK-SAME: #[[ZA_SHARED]]
 // CHECK: call void [[F:%.*]](i32 noundef [[X:%.*]], i32 noundef [[Y:%.*]]) #[[ZA_PRESERVED_CALL]]
 //
-void __attribute__((arm_shared_za)) test_preserved_za(pz_ptrty f, int x, int y) { return f(x, y); }
+void test_preserved_za(pz_ptrty f, int x, int y) __arm_shared_za { return f(x, y); }
 
 // CHECK-LABEL: @test_indirect_streaming_ptrty(
 // CHECK-SAME: #[[NORMAL_DEF:[0-9]+]]
 // CHECK: call void [[F:%.*]](i32 noundef [[X:%.*]], i32 noundef [[Y:%.*]]) #[[SM_ENABLED_CALL]]
 //
 typedef s_ptrty **indirect_s_ptrty;
 void test_indirect_streaming_ptrty(indirect_s_ptrty fptr, int x, int y) { return (**fptr)(x, y); }
 } // extern "C"

 // CHECK:   ret void
 // CHECK: }
 // CHECK: declare void @_Z10streaming1v() #[[SM_ENABLED_DECL]]
 // CHECK: declare void @_Z10streaming2v() #[[SM_ENABLED_DECL]]
 // CHECK: declare void @_Z10streaming3v() #[[SM_ENABLED_DECL]]
 // CHECK: declare void @_Z20same_type_streaming1v() #[[SM_ENABLED_DECL]]
 // CHECK: declare void @_Z20same_type_streaming2v() #[[SM_ENABLED_DECL]]
 // CHECK: declare void @_Z20same_type_streaming3v() #[[SM_ENABLED_DECL]]
-__attribute__((arm_streaming)) void streaming1();
-void __attribute__((arm_streaming)) streaming2();
-void streaming3() __attribute__((arm_streaming));
+void streaming1() __arm_streaming;
+void streaming2() __arm_streaming;
+void streaming3() __arm_streaming;
 decltype(streaming1) same_type_streaming1;
 decltype(streaming2) same_type_streaming2;
 decltype(streaming3) same_type_streaming3;
 void test_same_type_streaming() {
   streaming1();
   streaming2();
   streaming3();
   same_type_streaming1();
   same_type_streaming2();
   same_type_streaming3();
 }
 
 //
 // Test overloading; the attribute is not required for overloaded types and
 // does not apply if not specified.
 //
 
 // CHECK-LABEL: @_Z12overloadedfni(
 // CHECK-SAME: #[[SM_ENABLED]]
-int __attribute__((arm_streaming)) overloadedfn(int x) { return x; }
+int overloadedfn(int x) __arm_streaming { return x; }
 // CHECK-LABEL: @_Z12overloadedfnf(
 // CHECK-SAME: #[[NORMAL_DEF]]
 //
 float overloadedfn(float x) { return x; }
 // CHECK-LABEL: @_Z13test_overloadi(
 // CHECK-SAME: #[[NORMAL_DEF]]
 //
 int test_overload(int x) { return overloadedfn(x); }
 // CHECK-LABEL: @_Z13test_overloadf(
 // CHECK-SAME: #[[NORMAL_DEF]]
 //
 float test_overload(float x) { return overloadedfn(x); }
 
 // CHECK-LABEL: @_Z11test_lambdai(
 // CHECK-SAME: #[[NORMAL_DEF]]
 // CHECK: call noundef i32 @"_ZZ11test_lambdaiENK3$_0clEi"({{.*}}) #[[SM_ENABLED_CALL]]
 //
 // CHECK: @"_ZZ11test_lambdaiENK3$_0clEi"(
 // CHECK-SAME: #[[SM_ENABLED]]
 int test_lambda(int x) {
-  auto F = [](int x) __attribute__((arm_streaming)) { return x; };
+  auto F = [](int x) __arm_streaming { return x; };
   return F(x);
 }
 
 // CHECK-LABEL: @_Z27test_template_instantiationv(
 // CHECK-SAME: #[[NORMAL_DEF]]
 // CHECK: call noundef i32 @_Z15template_functyIiET_S0_(i32 noundef 12) #[[SM_ENABLED_CALL]]
 //
 // CHECK: @_Z15template_functyIiET_S0_(
 // CHECK-SAME: #[[SM_ENABLED]]
 template <typename Ty>
-Ty template_functy(Ty x) __attribute__((arm_streaming)) { return x; }
+Ty template_functy(Ty x) __arm_streaming { return x; }
 int test_template_instantiation() { return template_functy(12); }
 
 //
 // Test that arm_locally_streaming is inherited by future redeclarations,
 // even when they don't specify the attribute.
 //
 
 // CHECK: define {{.*}} @_Z25locally_streaming_inheritv(
 // CHECK-SAME: #[[SM_BODY]]
-__attribute__((arm_locally_streaming)) void locally_streaming_inherit();
+__arm_locally_streaming void locally_streaming_inherit();
 void locally_streaming_inherit() {
   streaming_decl();
 }
 
 // CHECK: attributes #[[SM_ENABLED]] = { mustprogress noinline nounwind optnone "aarch64_pstate_sm_enabled" "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+sme" }
 // CHECK: attributes #[[NORMAL_DECL]] = { "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+sme" }
 // CHECK: attributes #[[SM_ENABLED_DECL]] = { "aarch64_pstate_sm_enabled" "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+sme" }
 // CHECK: attributes #[[SM_COMPATIBLE]] = { mustprogress noinline nounwind optnone "aarch64_pstate_sm_compatible" "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+sme" }

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: Alias (SubjectMatchRule_function, SubjectMatchRule_variable_is_global)
 // CHECK-NEXT: AlignValue (SubjectMatchRule_variable, SubjectMatchRule_type_alias)
 // CHECK-NEXT: AlwaysDestroy (SubjectMatchRule_variable)
 // CHECK-NEXT: AlwaysInline (SubjectMatchRule_function)
 // CHECK-NEXT: Annotate ()
 // CHECK-NEXT: AnyX86NoCfCheck (SubjectMatchRule_hasType_functionType)
 // CHECK-NEXT: ArcWeakrefUnavailable (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ArmBuiltinAlias (SubjectMatchRule_function)
-// CHECK-NEXT: ArmLocallyStreaming (SubjectMatchRule_function)
 // CHECK-NEXT: AssumeAligned (SubjectMatchRule_objc_method, SubjectMatchRule_function)
 // CHECK-NEXT: Assumption (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: Availability ((SubjectMatchRule_record, SubjectMatchRule_enum, SubjectMatchRule_enum_constant, SubjectMatchRule_field, SubjectMatchRule_function, SubjectMatchRule_namespace, SubjectMatchRule_objc_category, SubjectMatchRule_objc_implementation, SubjectMatchRule_objc_interface, SubjectMatchRule_objc_method, SubjectMatchRule_objc_property, SubjectMatchRule_objc_protocol, SubjectMatchRule_record, SubjectMatchRule_type_alias, SubjectMatchRule_variable))
 // CHECK-NEXT: BPFPreserveAccessIndex (SubjectMatchRule_record)
 // CHECK-NEXT: BTFDeclTag (SubjectMatchRule_variable, SubjectMatchRule_function, SubjectMatchRule_record, SubjectMatchRule_field, SubjectMatchRule_type_alias)
 // CHECK-NEXT: BuiltinAlias (SubjectMatchRule_function)
 // CHECK-NEXT: CFAuditedTransfer (SubjectMatchRule_function)
 // CHECK-NEXT: CFConsumed (SubjectMatchRule_variable_is_parameter)

clang/test/Parser/c2x-attribute-keywords.c

+// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,notc2x -Wno-strict-prototypes %s
+// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,c2x %s
+
+enum __arm_streaming E { // expected-error {{'__arm_streaming' only applies to}}
+  One __arm_streaming, // expected-error {{'__arm_streaming' only applies to}}
+  Two,
+  Three __arm_streaming // expected-error {{'__arm_streaming' only applies to}}
+};
+
+enum __arm_streaming { Four }; // expected-error {{'__arm_streaming' only applies to}}
+__arm_streaming enum E2 { Five }; // expected-error {{misplaced '__arm_streaming'}}
+
+// FIXME: this diagnostic can be improved.
+enum { __arm_streaming Six }; // expected-error {{expected identifier}}
+
+// FIXME: this diagnostic can be improved.
+enum E3 __arm_streaming { Seven }; // expected-error {{expected identifier or '('}}
+
+struct __arm_streaming S1 { // expected-error {{'__arm_streaming' only applies to}}
+  int i __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
+  int __arm_streaming j; // expected-error {{'__arm_streaming' only applies to function types}}
+  int k[10] __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
+  int l __arm_streaming[10]; // expected-error {{'__arm_streaming' only applies to function types}}
+  __arm_streaming int m, n; // expected-error {{'__arm_streaming' only applies to function types}}
+  int o __arm_streaming : 12; // expected-error {{'__arm_streaming' only applies to function types}}
+  int __arm_streaming : 0; // expected-error {{'__arm_streaming' only applies to function types}}
+  int p, __arm_streaming : 0; // expected-error {{'__arm_streaming' cannot appear here}}
+  int q, __arm_streaming r; // expected-error {{'__arm_streaming' cannot appear here}}
+  __arm_streaming int; // expected-error {{'__arm_streaming' cannot appear here}} \
+            // expected-warning {{declaration does not declare anything}}
+};
+
+__arm_streaming struct S2 { int a; }; // expected-error {{misplaced '__arm_streaming'}}
+struct S3 __arm_streaming { int a; }; // expected-error {{'__arm_streaming' cannot appear here}} \
+                                         expected-error {{'__arm_streaming' only applies to}}
+
+union __arm_streaming U { // expected-error {{'__arm_streaming' only applies to}}
+  double d __arm_streaming; // expected-error {{'__arm_streaming' only applies to}}
+  __arm_streaming int i; // expected-error {{'__arm_streaming' only applies to}}
+};
+
+__arm_streaming union U2 { double d; }; // expected-error {{misplaced '__arm_streaming'}}
+union U3 __arm_streaming { double d; }; // expected-error {{'__arm_streaming' cannot appear here}} \
+                                           expected-error {{'__arm_streaming' only applies to}}
+
+struct __arm_streaming IncompleteStruct; // expected-error {{'__arm_streaming' only applies to}}
+union __arm_streaming IncompleteUnion; // expected-error {{'__arm_streaming' only applies to}}
+enum __arm_streaming IncompleteEnum; // expected-error {{'__arm_streaming' only applies to}}
+
+__arm_streaming void f1(void); // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+void __arm_streaming f2(void); // expected-error {{'__arm_streaming' only applies to function types}}
+void f3 __arm_streaming (void); // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+void f4(void) __arm_streaming;
+
+void f5(int i __arm_streaming, __arm_streaming int j, int __arm_streaming k); // expected-error 3 {{'__arm_streaming' only applies to function types}}
+
+void f6(a, b) __arm_streaming int a; int b; { // expected-error {{'__arm_streaming' cannot appear here}} \
+                                                 c2x-warning {{deprecated}}
+}
+
+// FIXME: technically, an attribute list cannot appear here, but we currently
+// parse it as part of the return type of the function, which is reasonable
+// behavior given that we *don't* want to parse it as part of the K&R parameter
+// declarations. It is disallowed to avoid a parsing ambiguity we already
+// handle well.
+int (*f7(a, b))(int, int) __arm_streaming int a; int b; { // c2x-warning {{deprecated}}
+  return 0;
+}
+
+__arm_streaming int a, b; // expected-error {{'__arm_streaming' only applies to function types}}
+int c __arm_streaming, d __arm_streaming; // expected-error 2 {{'__arm_streaming' only applies to function types}}
+
+void f8(void) __arm_streaming {
+  __arm_streaming int i, j; // expected-error {{'__arm_streaming' only applies to function types}}
+  int k, l __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
+}
+
+__arm_streaming void f9(void) { // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+  int i[10] __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
+  int (*fp1)(void)__arm_streaming;
+  int (*fp2 __arm_streaming)(void); // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+
+  int * __arm_streaming *ipp; // expected-error {{'__arm_streaming' only applies to function types}}
+}
+
+void f10(int j[static 10] __arm_streaming, int k[*] __arm_streaming); // expected-error 2 {{'__arm_streaming' only applies to function types}}
+
+void f11(void) {
+  __arm_streaming {} // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming if (1) {} // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+
+  __arm_streaming switch (1) { // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming case 1: __arm_streaming break; // expected-error 2 {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming default: break; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  }
+
+  goto foo;
+  __arm_streaming foo: (void)1; // expected-error {{'__arm_streaming' only applies to}}
+
+  __arm_streaming for (;;); // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming while (1); // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming do __arm_streaming { } while(1); // expected-error 2 {{'__arm_streaming' cannot be applied to a statement}}
+
+  __arm_streaming (void)1; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+
+  __arm_streaming; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+
+  (void)sizeof(int [4]__arm_streaming); // expected-error {{'__arm_streaming' only applies to function types}}
+  (void)sizeof(struct __arm_streaming S3 { int a __arm_streaming; }); // expected-error 2 {{'__arm_streaming' only applies to}}
+
+  __arm_streaming return; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+
+  __arm_streaming asm (""); // expected-error {{'__arm_streaming' cannot appear here}}
+}
+
+struct __arm_streaming S4 *s; // expected-error {{'__arm_streaming' cannot appear here}}
+struct S5 {};
+int c = sizeof(struct __arm_streaming S5); // expected-error {{'__arm_streaming' cannot appear here}}

clang/test/Parser/c2x-attribute-keywords.m

+// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify %s
+
+enum __arm_streaming E1 : int; // expected-error {{'__arm_streaming' only applies to}}
+
+@interface Base
+@end
+
+@interface S : Base
+- (void) bar;
+@end
+
+@interface T : Base
+- (S *) foo;
+@end
+
+
+void f(T *t) {
+  __arm_streaming[[t foo] bar]; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+}

clang/test/Parser/cxx0x-attribute-keywords.cpp

+// RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions -triple aarch64-none-linux-gnu -target-feature +sme %s
+
+// Need std::initializer_list
+namespace std {
+  typedef decltype(sizeof(int)) size_t;
+
+  // libc++'s implementation
+  template <class _E>
+  class initializer_list
+  {
+    const _E* __begin_;
+    size_t    __size_;
+
+    initializer_list(const _E* __b, size_t __s)
+      : __begin_(__b),
+        __size_(__s)
+    {}
+
+  public:
+    typedef _E        value_type;
+    typedef const _E& reference;
+    typedef const _E& const_reference;
+    typedef size_t    size_type;
+
+    typedef const _E* iterator;
+    typedef const _E* const_iterator;
+
+    initializer_list() : __begin_(nullptr), __size_(0) {}
+
+    size_t    size()  const {return __size_;}
+    const _E* begin() const {return __begin_;}
+    const _E* end()   const {return __begin_ + __size_;}
+  };
+}
+
+
+// Declaration syntax checks
+__arm_streaming int before_attr; // expected-error {{'__arm_streaming' only applies to function types}}
+int __arm_streaming between_attr; // expected-error {{'__arm_streaming' only applies to function types}}
+const __arm_streaming int between_attr_2 = 0; // expected-error {{'__arm_streaming' cannot appear here}}
+int after_attr __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
+int * __arm_streaming ptr_attr; // expected-error {{'__arm_streaming' only applies to function types}}
+int & __arm_streaming ref_attr = after_attr; // expected-error {{'__arm_streaming' only applies to function types}}
+int && __arm_streaming rref_attr = 0; // expected-error {{'__arm_streaming' only applies to function types}}
+int array_attr [1] __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
+void fn_attr () __arm_streaming;
+void noexcept_fn_attr () noexcept __arm_streaming;
+struct MemberFnOrder {
+  virtual void f() const volatile && noexcept __arm_streaming final = 0;
+};
+struct __arm_streaming struct_attr; // expected-error {{'__arm_streaming' only applies to}}
+class __arm_streaming class_attr {}; // expected-error {{'__arm_streaming' only applies to}}
+union __arm_streaming union_attr; // expected-error {{'__arm_streaming' only applies to}}
+enum __arm_streaming E { }; // expected-error {{'__arm_streaming' only applies to}}
+namespace test_misplacement {
+__arm_streaming struct struct_attr2;  // expected-error {{misplaced '__arm_streaming'}}
+__arm_streaming class class_attr2; // expected-error {{misplaced '__arm_streaming'}}
+__arm_streaming union union_attr2; // expected-error {{misplaced '__arm_streaming'}}
+__arm_streaming enum  E2 { }; // expected-error {{misplaced '__arm_streaming'}}
+}
+
+// Checks attributes placed at wrong syntactic locations of class specifiers.
+class __arm_streaming __arm_streaming // expected-error 2 {{'__arm_streaming' only applies to}}
+  attr_after_class_name_decl __arm_streaming __arm_streaming; // expected-error {{'__arm_streaming' cannot appear here}} \
+                                                                 expected-error 2 {{'__arm_streaming' only applies to}}
+
+class __arm_streaming __arm_streaming // expected-error 2 {{'__arm_streaming' only applies to}}
+ attr_after_class_name_definition __arm_streaming __arm_streaming __arm_streaming{}; // expected-error {{'__arm_streaming' cannot appear here}} \
+                                                                                        expected-error 3 {{'__arm_streaming' only applies to}}
+
+class __arm_streaming c {}; // expected-error {{'__arm_streaming' only applies to}}
+class c __arm_streaming __arm_streaming x; // expected-error 2 {{'__arm_streaming' only applies to function types}}
+class c __arm_streaming __arm_streaming y __arm_streaming __arm_streaming; // expected-error 4 {{'__arm_streaming' only applies to function types}}
+class c final [(int){0}];
+
+class base {};
+class __arm_streaming __arm_streaming final_class // expected-error 2 {{'__arm_streaming' only applies to}}
+  __arm_streaming alignas(float) final // expected-error {{'__arm_streaming' cannot appear here}} \
+                                          expected-error {{'__arm_streaming' only applies to}}
+  __arm_streaming alignas(float) __arm_streaming alignas(float): base{}; // expected-error {{'__arm_streaming' cannot appear here}}
+
+class __arm_streaming __arm_streaming final_class_another // expected-error 2 {{'__arm_streaming' only applies to}}
+  __arm_streaming __arm_streaming alignas(16) final // expected-error {{'__arm_streaming' cannot appear here}} \
+                                                       expected-error 2 {{'__arm_streaming' only applies to}}
+  __arm_streaming __arm_streaming alignas(16) __arm_streaming{}; // expected-error {{'__arm_streaming' cannot appear here}}
+
+class C {};
+
+__arm_streaming struct with_init_declarators {} init_declarator; // expected-error {{'__arm_streaming' only applies to function types}}
+__arm_streaming struct no_init_declarators; // expected-error {{misplaced '__arm_streaming'}}
+template<typename> __arm_streaming struct no_init_declarators_template; // expected-error {{'__arm_streaming' cannot appear here}}
+void fn_with_structs() {
+  __arm_streaming struct with_init_declarators {} init_declarator; // expected-error {{'__arm_streaming' only applies to function types}}
+  __arm_streaming struct no_init_declarators; // expected-error {{'__arm_streaming' cannot appear here}}
+}
+__arm_streaming; // expected-error {{'__arm_streaming' only applies to}}
+struct ctordtor {
+  __arm_streaming ctordtor __arm_streaming () __arm_streaming; // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+  ctordtor (C) __arm_streaming;
+  __arm_streaming ~ctordtor __arm_streaming () __arm_streaming; // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+};
+__arm_streaming ctordtor::ctordtor __arm_streaming () __arm_streaming {} // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+__arm_streaming ctordtor::ctordtor (C) __arm_streaming try {} catch (...) {} // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+__arm_streaming ctordtor::~ctordtor __arm_streaming () __arm_streaming {} // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+extern "C++" __arm_streaming int extern_attr; // expected-error {{'__arm_streaming' only applies to function types}}
+template <typename T> __arm_streaming void template_attr (); // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+__arm_streaming __arm_streaming int __arm_streaming __arm_streaming multi_attr __arm_streaming __arm_streaming; // expected-error 6 {{'__arm_streaming' only applies to function types}}
+
+int (paren_attr) __arm_streaming; // expected-error {{'__arm_streaming' cannot appear here}}
+unsigned __arm_streaming int attr_in_decl_spec; // expected-error {{'__arm_streaming' cannot appear here}}
+unsigned __arm_streaming int __arm_streaming const double_decl_spec = 0; // expected-error 2 {{'__arm_streaming' cannot appear here}}
+class foo {
+  void const_after_attr () __arm_streaming const; // expected-error {{expected ';'}}
+};
+extern "C++" __arm_streaming { } // expected-error {{'__arm_streaming' cannot appear here}}
+__arm_streaming extern "C++" { } // expected-error {{'__arm_streaming' cannot appear here}}
+__arm_streaming template <typename T> void before_template_attr (); // expected-error {{'__arm_streaming' cannot appear here}}
+__arm_streaming namespace ns { int i; } // expected-error {{'__arm_streaming' cannot appear here}}
+__arm_streaming static_assert(true, ""); //expected-error {{'__arm_streaming' cannot appear here}}
+__arm_streaming asm(""); // expected-error {{'__arm_streaming' cannot appear here}}
+
+__arm_streaming using ns::i; // expected-warning {{ISO C++}} \
+                                expected-error {{'__arm_streaming' only applies to}}
+__arm_streaming using namespace ns; // expected-error {{'__arm_streaming' only applies to}}
+namespace __arm_streaming ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}} \
+                                    expected-error {{'__arm_streaming' only applies to}}
+
+using __arm_streaming alignas(4)__arm_streaming ns::i;          // expected-warning 2 {{ISO C++}} \
+                                                                   expected-error {{'__arm_streaming' cannot appear here}} \
+                                                                   expected-error {{'alignas' attribute only applies to variables, data members and tag types}} \
+                                                                   expected-warning {{ISO C++}} \
+                                                                   expected-error 2 {{'__arm_streaming' only applies to}}
+using __arm_streaming alignas(4) __arm_streaming foobar = int; // expected-error {{'__arm_streaming' cannot appear here}} \
+                                                                  expected-error {{'alignas' attribute only applies to}} \
+                                                                  expected-error 2 {{'__arm_streaming' only applies to function types}}
+
+__arm_streaming using T = int; // expected-error {{'__arm_streaming' cannot appear here}}
+using T __arm_streaming = int; // expected-error {{'__arm_streaming' only applies to function types}}
+template<typename T> using U __arm_streaming = T; // expected-error {{'__arm_streaming' only applies to function types}}
+using ns::i __arm_streaming; // expected-warning {{ISO C++}} \
+                                expected-error {{'__arm_streaming' only applies to}}
+using ns::i __arm_streaming, ns::i __arm_streaming; // expected-warning 2 {{ISO C++}} \
+                                                       expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} \
+                                                       expected-error 2 {{'__arm_streaming' only applies to}}
+struct using_in_struct_base {
+  typedef int i, j, k, l;
+};
+struct using_in_struct : using_in_struct_base {
+  __arm_streaming using using_in_struct_base::i; // expected-warning {{ISO C++}} \
+                                                    expected-error {{'__arm_streaming' only applies to}}
+  using using_in_struct_base::j __arm_streaming; // expected-warning {{ISO C++}} \
+                                                    expected-error {{'__arm_streaming' only applies to}}
+  __arm_streaming using using_in_struct_base::k __arm_streaming, using_in_struct_base::l __arm_streaming; // expected-warning 3 {{ISO C++}} \
+                                                                                                             expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} \
+                                                                                                             expected-error 4 {{'__arm_streaming' only applies to}}
+};
+using __arm_streaming ns::i; // expected-warning {{ISO C++}} \
+                                expected-error {{'__arm_streaming' cannot appear here}} \
+                                expected-error {{'__arm_streaming' only applies to}}
+using T __arm_streaming = int; // expected-error {{'__arm_streaming' only applies to function types}}
+
+auto trailing() -> __arm_streaming const int; // expected-error {{'__arm_streaming' cannot appear here}}
+auto trailing() -> const __arm_streaming int; // expected-error {{'__arm_streaming' cannot appear here}}
+auto trailing() -> const int __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
+auto trailing_2() -> struct struct_attr __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
+
+namespace N {
+  struct S {};
+};
+template<typename> struct Template {};
+
+// FIXME: Improve this diagnostic
+struct __arm_streaming N::S s; // expected-error {{'__arm_streaming' cannot appear here}}
+struct __arm_streaming Template<int> t; // expected-error {{'__arm_streaming' cannot appear here}}
+struct __arm_streaming ::template Template<int> u; // expected-error {{'__arm_streaming' cannot appear here}}
+template struct __arm_streaming Template<char>; // expected-error {{'__arm_streaming' cannot appear here}}
+template struct __attribute__((pure)) Template<std::size_t>; // We still allow GNU-style attributes here
+template <> struct __arm_streaming Template<void>; // expected-error {{'__arm_streaming' only applies to}}
+
+enum __arm_streaming E1 {}; // expected-error {{'__arm_streaming' only applies to}}
+enum __arm_streaming E2; // expected-error {{forbids forward references}} \
+                            expected-error {{'__arm_streaming' only applies to}}
+enum __arm_streaming E1; // expected-error {{'__arm_streaming' only applies to}}
+enum __arm_streaming E3 : int; // expected-error {{'__arm_streaming' only applies to}}
+enum __arm_streaming { // expected-error {{'__arm_streaming' only applies to}}
+  k_123 __arm_streaming = 123 // expected-warning {{attributes on an enumerator declaration are a C++17 extension}} \
+                                 expected-error {{'__arm_streaming' only applies to}}
+};
+enum __arm_streaming E1 e; // expected-error {{'__arm_streaming' cannot appear here}}
+enum __arm_streaming class E4 { }; // expected-error {{'__arm_streaming' cannot appear here}}
+enum struct __arm_streaming E5; // expected-error {{'__arm_streaming' only applies to}}
+
+struct S {
+  friend int f __arm_streaming (); // expected-error {{'__arm_streaming' cannot appear here}} \
+                                      expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+  friend int f2 __arm_streaming () {} // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+  __arm_streaming friend int g(); // expected-error {{'__arm_streaming' cannot appear here}}
+  __arm_streaming friend int h() { // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+  }
+  __arm_streaming friend int f3(), f4(), f5(); // expected-error {{'__arm_streaming' cannot appear here}}
+  friend int f6 __arm_streaming (), f7 __arm_streaming (), f8 __arm_streaming (); // expected-error3 {{'__arm_streaming' cannot appear here}} \
+                                                                                     expected-error 3 {{'__arm_streaming' cannot be applied to a declaration}}
+  friend class __arm_streaming C; // expected-error {{'__arm_streaming' cannot appear here}}
+  __arm_streaming friend class D; // expected-error {{'__arm_streaming' cannot appear here}}
+  __arm_streaming friend int; // expected-error {{'__arm_streaming' cannot appear here}}
+};
+template<typename T> void tmpl (T) {}
+template __arm_streaming void tmpl(char); // expected-error {{'__arm_streaming' cannot appear here}}
+template void __arm_streaming tmpl(short); // expected-error {{'__arm_streaming' only applies to function types}}
+
+// Statement tests
+void foo () {
+  __arm_streaming ; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming { } // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming if (0) { } // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming for (;;); // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming do { // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+    __arm_streaming continue; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  } while (0);
+  __arm_streaming while (0); // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+
+  __arm_streaming switch (i) { // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+    __arm_streaming case 0: // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+    __arm_streaming default: // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+      __arm_streaming break; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  }
+
+  __arm_streaming goto there; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  __arm_streaming there: // expected-error {{'__arm_streaming' only applies to}}
+
+  __arm_streaming try { // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+  } __arm_streaming catch (...) { // expected-error {{'__arm_streaming' cannot appear here}}
+  }
+
+  void bar __arm_streaming (__arm_streaming int i, __arm_streaming int j); // expected-error 2 {{'__arm_streaming' only applies to function types}} \
+                                                                              expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+  using FuncType = void (__arm_streaming int); // expected-error {{'__arm_streaming' only applies to function types}}
+  void baz(__arm_streaming...); // expected-error {{expected parameter declarator}}
+
+  __arm_streaming return; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
+}
+
+// Expression tests
+void bar () {
+  new int[42]__arm_streaming[5]__arm_streaming{}; // expected-error {{'__arm_streaming' only applies to function types}}
+}
+
+// Condition tests
+void baz () {
+  if (__arm_streaming bool b = true) { // expected-error {{'__arm_streaming' only applies to function types}}
+    switch (__arm_streaming int n { 42 }) { // expected-error {{'__arm_streaming' only applies to function types}}
+    default:
+      for (__arm_streaming int n = 0; __arm_streaming char b = n < 5; ++b) { // expected-error 2 {{'__arm_streaming' only applies to function types}}
+      }
+    }
+  }
+  int x;
+  // An attribute can be applied to an expression-statement, such as the first
+  // statement in a for. But it can't be applied to a condition which is an
+  // expression.
+  for (__arm_streaming x = 0; ; ) {} // expected-error {{'__arm_streaming' cannot appear here}}
+  for (; __arm_streaming x < 5; ) {} // expected-error {{'__arm_streaming' cannot appear here}}
+  while (__arm_streaming bool k { false }) { // expected-error {{'__arm_streaming' only applies to function types}}
+  }
+  while (__arm_streaming true) { // expected-error {{'__arm_streaming' cannot appear here}}
+  }
+  do {
+  } while (__arm_streaming false); // expected-error {{'__arm_streaming' cannot appear here}}
+
+  for (__arm_streaming int n : { 1, 2, 3 }) { // expected-error {{'__arm_streaming' only applies to function types}}
+  }
+}
+
+enum class __attribute__((visibility("hidden"))) SecretKeepers {
+  one, /* rest are deprecated */ two, three
+};
+enum class __arm_streaming EvenMoreSecrets {}; // expected-error {{'__arm_streaming' only applies to}}
+
+// Forbid attributes on decl specifiers.
+unsigned __arm_streaming static int __arm_streaming v1; // expected-error {{'__arm_streaming' only applies to function types}} \
+           expected-error {{'__arm_streaming' cannot appear here}}
+typedef __arm_streaming unsigned long __arm_streaming v2; // expected-error {{'__arm_streaming' only applies to function types}} \
+          expected-error {{'__arm_streaming' cannot appear here}}
+int __arm_streaming foo(int __arm_streaming x); // expected-error 2 {{'__arm_streaming' only applies to function types}}
+
+__arm_streaming; // expected-error {{'__arm_streaming' only applies to}}
+
+class A {
+  A(__arm_streaming int a); // expected-error {{'__arm_streaming' only applies to function types}}
+};
+A::A(__arm_streaming int a) {} // expected-error {{'__arm_streaming' only applies to function types}}
+
+template<typename T> struct TemplateStruct {};
+class FriendClassesWithAttributes {
+  // We allow GNU-style attributes here
+  template <class _Tp, class _Alloc> friend class __attribute__((__type_visibility__("default"))) vector;
+  template <class _Tp, class _Alloc> friend class __declspec(code_seg("foo,whatever")) vector2;
+  // But not C++11 ones
+  template <class _Tp, class _Alloc> friend class __arm_streaming vector3;                                         // expected-error {{'__arm_streaming' cannot appear here}}
+
+  // Also allowed
+  friend struct __attribute__((__type_visibility__("default"))) TemplateStruct<FriendClassesWithAttributes>;
+  friend struct __declspec(code_seg("foo,whatever")) TemplateStruct<FriendClassesWithAttributes>;
+  friend struct __arm_streaming TemplateStruct<FriendClassesWithAttributes>;                                       // expected-error {{'__arm_streaming' cannot appear here}}
+};
+
+// Check ordering: C++11 attributes must appear before GNU attributes.
+class Ordering {
+  void f1(
+    int (__arm_streaming __attribute__(()) int n) // expected-error {{'__arm_streaming' only applies to function types}}
+  ) {
+  }
+
+  void f2(
+      int (*)(__arm_streaming __attribute__(()) int n) // expected-error {{'__arm_streaming' only applies to function types}}
+  ) {
+  }
+
+  void f3(
+    int (__attribute__(()) __arm_streaming int n) // expected-error {{'__arm_streaming' cannot appear here}}
+  ) {
+  }
+
+  void f4(
+      int (*)(__attribute__(()) __arm_streaming int n) // expected-error {{'__arm_streaming' cannot appear here}}
+  ) {
+  }
+};
+
+namespace base_specs {
+struct A {};
+struct B : __arm_streaming A {}; // expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
+struct C : __arm_streaming virtual A {}; // expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
+struct D : __arm_streaming public virtual A {}; // expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
+struct E : public __arm_streaming virtual A {}; // expected-error {{'__arm_streaming' cannot appear here}} \
+                                                   expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
+struct F : virtual __arm_streaming public A {}; // expected-error {{'__arm_streaming' cannot appear here}} \
+                                                   expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
+}

clang/test/Sema/aarch64-sme-attrs-no-sme.c

 // Test that the attribute is ignored if we don't compile for both AArch64 with +sme.
 //
 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu -fsyntax-only -verify %s
 // RUN: %clang_cc1 -triple x86_64-none-linux-gnu -target-feature +sme -fsyntax-only -verify %s
 
 extern int normal_callee(void);
 
-// expected-warning@+1 {{unknown attribute 'arm_streaming' ignored}}
-__attribute__((arm_streaming))
-int streaming_caller(void) {
+// expected-error@+1 {{'__arm_streaming' is not supported on this target}}
+int streaming_caller(void) __arm_streaming {
   return normal_callee();
 }
 
-// expected-warning@+1 {{unknown attribute 'arm_locally_streaming' ignored}}
-__attribute__((arm_locally_streaming))
-int locally_streaming_caller(void) {
+// expected-error@+1 {{'__arm_locally_streaming' is not supported on this target}}
+__arm_locally_streaming int locally_streaming_caller(void) {
   return normal_callee();
 }
 
-// expected-warning@+1 {{unknown attribute 'arm_shared_za' ignored}}
-__attribute__((arm_shared_za))
-int shared_za_caller(void) {
+// expected-error@+1 {{'__arm_shared_za' is not supported on this target}}
+int shared_za_caller(void) __arm_shared_za {
   return normal_callee();
 }
 
-// expected-warning@+1 {{unknown attribute 'arm_preserves_za' ignored}}
-__attribute__((arm_preserves_za))
-int preserves_za_caller(void) {
+// expected-error@+1 {{'__arm_preserves_za' is not supported on this target}}
+int preserves_za_caller(void) __arm_preserves_za {
   return normal_callee();
 }
 
-// expected-warning@+1 {{unknown attribute 'arm_new_za' ignored}}
-__attribute__((arm_new_za))
-int new_za_caller(void) {
+// expected-error@+1 {{'__arm_new_za' is not supported on this target}}
+__arm_new_za int new_za_caller(void) {
   return normal_callee();
 }

clang/test/Sema/aarch64-sme-func-attrs.c

 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -fsyntax-only -verify %s
 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -fsyntax-only -verify=expected-cpp -x c++ %s
 
 // Valid attributes
 
-__attribute__((arm_streaming)) void sme_arm_streaming(void);
-__attribute__((arm_streaming_compatible)) void sme_arm_streaming_compatible(void);
+void sme_arm_streaming(void) __arm_streaming;
+void sme_arm_streaming_compatible(void) __arm_streaming_compatible;
 
-__attribute__((arm_new_za)) void sme_arm_new_za(void);
-__attribute__((arm_shared_za)) void sme_arm_shared_za(void);
-__attribute__((arm_preserves_za)) void sme_arm_preserves_za(void);
-
-__attribute__((arm_streaming, arm_new_za)) void sme_arm_streaming_new_za(void);
-__attribute__((arm_streaming, arm_shared_za)) void sme_arm_streaming_shared_za(void);
-__attribute__((arm_streaming, arm_preserves_za)) void sme_arm_streaming_preserves_za(void);
-
-__attribute__((arm_streaming_compatible, arm_new_za)) void sme_arm_sc_new_za(void);
-__attribute__((arm_streaming_compatible, arm_shared_za)) void sme_arm_sc_shared_za(void);
-__attribute__((arm_streaming_compatible, arm_preserves_za)) void sme_arm_sc_preserves_za(void);
-
-__attribute__((arm_shared_za, arm_preserves_za)) void sme_arm_shared_preserves_za(void);
-
-__attribute__((arm_locally_streaming)) void sme_arm_locally_streaming(void) { }
-__attribute__((arm_locally_streaming, arm_streaming)) void sme_arm_streaming_and_locally_streaming(void) { }
-__attribute__((arm_locally_streaming, arm_streaming_compatible)) void sme_arm_streaming_and_streaming_compatible(void) { }
-
-__attribute__((arm_locally_streaming, arm_new_za)) void sme_arm_ls_new_za(void) { }
-__attribute__((arm_locally_streaming, arm_shared_za)) void sme_arm_ls_shared_za(void) { }
-__attribute__((arm_locally_streaming, arm_preserves_za)) void sme_arm_ls_preserves_za(void) { }
+void sme_arm_new_za(void) __arm_new_za;
+void sme_arm_shared_za(void) __arm_shared_za;
+void sme_arm_preserves_za(void) __arm_preserves_za;
+
+void sme_arm_streaming_new_za(void) __arm_streaming __arm_new_za;
+void sme_arm_streaming_shared_za(void) __arm_streaming __arm_shared_za;
+void sme_arm_streaming_preserves_za(void) __arm_streaming __arm_preserves_za;
+
+void sme_arm_sc_new_za(void) __arm_streaming_compatible __arm_new_za;
+void sme_arm_sc_shared_za(void) __arm_streaming_compatible __arm_shared_za;
+void sme_arm_sc_preserves_za(void) __arm_streaming_compatible __arm_preserves_za;
+
+void sme_arm_shared_preserves_za(void) __arm_shared_za __arm_preserves_za;
+
+__arm_locally_streaming void sme_arm_locally_streaming(void) { }
+__arm_locally_streaming void sme_arm_streaming_and_locally_streaming(void) __arm_streaming { }
+__arm_locally_streaming void sme_arm_streaming_and_streaming_compatible(void) __arm_streaming_compatible { }
+
+__arm_locally_streaming void sme_arm_ls_new_za(void) __arm_new_za { }
+__arm_locally_streaming void sme_arm_ls_shared_za(void) __arm_shared_za { }
+__arm_locally_streaming void sme_arm_ls_preserves_za(void) __arm_preserves_za { }
 
 // Valid attributes on function pointers
 
-void __attribute__((arm_streaming)) streaming_ptr(void);
-typedef __attribute__((arm_streaming)) void (*fptrty1) (void);
+void streaming_ptr(void) __arm_streaming;
+typedef void (*fptrty1) (void) __arm_streaming;
 fptrty1 call_streaming_func() { return streaming_ptr; }
 
-void __attribute__((arm_streaming_compatible)) streaming_compatible_ptr(void);
-typedef __attribute__((arm_streaming_compatible)) void (*fptrty2) (void);
+void streaming_compatible_ptr(void) __arm_streaming_compatible;
+typedef void (*fptrty2) (void) __arm_streaming_compatible;
 fptrty2 call_sc_func() { return streaming_compatible_ptr; }
 
-void __attribute__((arm_new_za)) new_za_ptr(void);
-typedef __attribute__((arm_new_za)) void (*fptrty3) (void);
+void new_za_ptr(void) __arm_new_za;
+typedef void (*fptrty3) (void) __arm_new_za;
 fptrty3 call_new_za_func() { return new_za_ptr; }
 
-void __attribute__((arm_shared_za)) shared_za_ptr(void);
-typedef __attribute__((arm_shared_za)) void (*fptrty4) (void);
+void shared_za_ptr(void) __arm_shared_za;
+typedef void (*fptrty4) (void) __arm_shared_za;
 fptrty4 call_shared_za_func() { return shared_za_ptr; }
 
-void __attribute__((arm_preserves_za)) preserves_za_ptr(void);
-typedef __attribute__((arm_preserves_za)) void (*fptrty5) (void);
+void preserves_za_ptr(void) __arm_preserves_za;
+typedef void (*fptrty5) (void) __arm_preserves_za;
 fptrty5 call_preserve_za_func() { return preserves_za_ptr; }
 
-void __attribute__((arm_shared_za, arm_preserves_za)) shared_preserves_za_ptr(void);
-typedef __attribute__((arm_shared_za, arm_preserves_za)) void (*fptrty6) (void);
+void shared_preserves_za_ptr(void) __arm_shared_za __arm_preserves_za;
+typedef void (*fptrty6) (void) __arm_shared_za __arm_preserves_za;
 fptrty6 call_shared_preserve_za_func() { return shared_preserves_za_ptr; }
 
 typedef void (*fptrty7) (void);
 fptrty7 cast_ls_func_to_normal() { return sme_arm_locally_streaming; }
 
 // FIXME: Add invalid function pointer assignments such as assigning:
 //   1. A streaming compatible function to a normal function pointer,
 //   2. A locally streaming function to a streaming function pointer,
 // etc.
 
 // Invalid attributes
 
-// expected-cpp-error@+4 {{'arm_streaming_compatible' and 'arm_streaming' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_streaming_compatible' and '__arm_streaming' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_streaming_compatible' and 'arm_streaming' attributes are not compatible}}
+// expected-error@+2 {{'__arm_streaming_compatible' and '__arm_streaming' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-__attribute__((arm_streaming, arm_streaming_compatible)) void streaming_mode(void);
+void streaming_mode(void) __arm_streaming __arm_streaming_compatible;
 
-// expected-cpp-error@+4 {{'arm_streaming' and 'arm_streaming_compatible' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_streaming' and '__arm_streaming_compatible' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_streaming' and 'arm_streaming_compatible' attributes are not compatible}}
+// expected-error@+2 {{'__arm_streaming' and '__arm_streaming_compatible' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-__attribute__((arm_streaming_compatible, arm_streaming)) void streaming_compatible(void);
+void streaming_compatible(void) __arm_streaming_compatible __arm_streaming;
 
-// expected-cpp-error@+4 {{'arm_shared_za' and 'arm_new_za' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_shared_za' and '__arm_new_za' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_shared_za' and 'arm_new_za' attributes are not compatible}}
+// expected-error@+2 {{'__arm_shared_za' and '__arm_new_za' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-__attribute__((arm_new_za, arm_shared_za)) void new_shared_za(void);
+void new_shared_za(void)__arm_new_za __arm_shared_za;
 
-// expected-cpp-error@+4 {{'arm_new_za' and 'arm_shared_za' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_new_za' and '__arm_shared_za' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_new_za' and 'arm_shared_za' attributes are not compatible}}
+// expected-error@+2 {{'__arm_new_za' and '__arm_shared_za' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-__attribute__((arm_shared_za, arm_new_za)) void shared_new_za(void);
+void shared_new_za(void) __arm_shared_za __arm_new_za;
 
-// expected-cpp-error@+4 {{'arm_preserves_za' and 'arm_new_za' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_preserves_za' and '__arm_new_za' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_preserves_za' and 'arm_new_za' attributes are not compatible}}
+// expected-error@+2 {{'__arm_preserves_za' and '__arm_new_za' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-__attribute__((arm_new_za, arm_preserves_za)) void new_preserves_za(void);
+void new_preserves_za(void) __arm_new_za __arm_preserves_za;
 
-// expected-cpp-error@+4 {{'arm_new_za' and 'arm_preserves_za' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_new_za' and '__arm_preserves_za' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_new_za' and 'arm_preserves_za' attributes are not compatible}}
+// expected-error@+2 {{'__arm_new_za' and '__arm_preserves_za' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-__attribute__((arm_preserves_za, arm_new_za)) void preserves_new_za(void);
+void preserves_new_za(void) __arm_preserves_za __arm_new_za;
 
-// Invalid attributes on function pointers
+// Invalid attributes on function types
 
-// expected-cpp-error@+4 {{'arm_streaming_compatible' and 'arm_streaming' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_streaming_compatible' and '__arm_streaming' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_streaming_compatible' and 'arm_streaming' attributes are not compatible}}
+// expected-error@+2 {{'__arm_streaming_compatible' and '__arm_streaming' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-void __attribute__((arm_streaming, arm_streaming_compatible)) streaming_ptr_invalid(void);
-// expected-cpp-error@+4 {{'arm_streaming_compatible' and 'arm_streaming' attributes are not compatible}}
+void streaming_ptr_invalid(void) __arm_streaming __arm_streaming_compatible;
+// expected-cpp-error@+4 {{'__arm_streaming_compatible' and '__arm_streaming' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_streaming_compatible' and 'arm_streaming' attributes are not compatible}}
+// expected-error@+2 {{'__arm_streaming_compatible' and '__arm_streaming' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-typedef __attribute__((arm_streaming, arm_streaming_compatible)) void (*fptrty8) (void);
+typedef void (*fptrty8) (void) __arm_streaming __arm_streaming_compatible;
 fptrty8 invalid_streaming_func() { return streaming_ptr_invalid; }
 
-// expected-cpp-error@+4 {{'arm_shared_za' and 'arm_new_za' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_shared_za' and '__arm_new_za' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_shared_za' and 'arm_new_za' attributes are not compatible}}
+// expected-error@+2 {{'__arm_shared_za' and '__arm_new_za' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-void __attribute__((arm_new_za, arm_shared_za)) shared_za_ptr_invalid(void);
-// expected-cpp-error@+4 {{'arm_shared_za' and 'arm_new_za' attributes are not compatible}}
+void shared_za_ptr_invalid(void) __arm_new_za __arm_shared_za;
+// expected-cpp-error@+4 {{'__arm_shared_za' and '__arm_new_za' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_shared_za' and 'arm_new_za' attributes are not compatible}}
+// expected-error@+2 {{'__arm_shared_za' and '__arm_new_za' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-typedef __attribute__((arm_new_za, arm_shared_za)) void (*fptrty9) (void);
+typedef void (*fptrty9) (void) __arm_new_za __arm_shared_za;
 fptrty9 invalid_shared_za_func() { return shared_za_ptr_invalid; }
 
-// expected-cpp-error@+4 {{'arm_preserves_za' and 'arm_new_za' attributes are not compatible}}
+// expected-cpp-error@+4 {{'__arm_preserves_za' and '__arm_new_za' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_preserves_za' and 'arm_new_za' attributes are not compatible}}
+// expected-error@+2 {{'__arm_preserves_za' and '__arm_new_za' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-void __attribute__((arm_new_za, arm_preserves_za)) preserves_za_ptr_invalid(void);
-// expected-cpp-error@+4 {{'arm_preserves_za' and 'arm_new_za' attributes are not compatible}}
+void preserves_za_ptr_invalid(void) __arm_new_za __arm_preserves_za;
+// expected-cpp-error@+4 {{'__arm_preserves_za' and '__arm_new_za' are not compatible}}
 // expected-cpp-note@+3 {{conflicting attribute is here}}
-// expected-error@+2 {{'arm_preserves_za' and 'arm_new_za' attributes are not compatible}}
+// expected-error@+2 {{'__arm_preserves_za' and '__arm_new_za' are not compatible}}
 // expected-note@+1 {{conflicting attribute is here}}
-typedef __attribute__((arm_new_za, arm_preserves_za)) void (*fptrty10) (void);
+typedef void (*fptrty10) (void) __arm_new_za __arm_preserves_za;
 fptrty10 invalid_preserve_za_func() { return preserves_za_ptr_invalid; }
 
-// expected-cpp-error@+2 {{'arm_locally_streaming' attribute only applies to functions}}
-// expected-error@+1 {{'arm_locally_streaming' attribute only applies to functions}}
-typedef __attribute__((arm_locally_streaming)) void (*fptrty11) (void);
-
-// expected-warning@+2 {{'arm_streaming' attribute ignored}}
-// expected-warning@+1 {{'arm_streaming' only applies to function types; type here is 'void ()'}}
-__attribute__((arm_streaming)) void function_no_prototype();
+// expected-cpp-error@+2 {{'__arm_locally_streaming' only applies to functions}}
+// expected-error@+1 {{'__arm_locally_streaming' only applies to functions}}
+typedef void (*fptrty11 __arm_locally_streaming) (void);
+
+// expected-warning@+2 {{'__arm_streaming' attribute ignored}}
+// expected-error@+1 {{'__arm_streaming' only applies to function types; type here is 'void ()'}}
+void function_no_prototype() __arm_streaming;
 
 //
 // Check for incorrect conversions of function pointers with the attributes
 //
 
 typedef void (*n_ptrty) (void);
-typedef __attribute__((arm_streaming)) void (*s_ptrty) (void);
+typedef void (*s_ptrty) (void) __arm_streaming;
 s_ptrty return_valid_streaming_fptr(s_ptrty f) { return f; }
 
-// expected-cpp-error@+2 {{cannot initialize return object of type 's_ptrty' (aka 'void (*)() __attribute__((arm_streaming))') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
-// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 's_ptrty' (aka 'void (*)(void) __attribute__((arm_streaming))')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 's_ptrty' (aka 'void (*)() __arm_streaming') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
+// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 's_ptrty' (aka 'void (*)(void) __arm_streaming')}}
 s_ptrty return_invalid_fptr_streaming_normal(n_ptrty f) { return f; }
-// expected-cpp-error@+2 {{cannot initialize return object of type 'n_ptrty' (aka 'void (*)()') with an lvalue of type 's_ptrty' (aka 'void (*)() __attribute__((arm_streaming))')}}
-// expected-error@+1 {{incompatible function pointer types returning 's_ptrty' (aka 'void (*)(void) __attribute__((arm_streaming))') from a function with result type 'n_ptrty' (aka 'void (*)(void)')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'n_ptrty' (aka 'void (*)()') with an lvalue of type 's_ptrty' (aka 'void (*)() __arm_streaming')}}
+// expected-error@+1 {{incompatible function pointer types returning 's_ptrty' (aka 'void (*)(void) __arm_streaming') from a function with result type 'n_ptrty' (aka 'void (*)(void)')}}
 n_ptrty return_invalid_fptr_normal_streaming(s_ptrty f) { return f; }
 
 // Test an instance where the result type is not a prototyped function, such that we still get a diagnostic.
 typedef void (*nonproto_n_ptrty) ();
-// expected-cpp-error@+2 {{cannot initialize return object of type 'nonproto_n_ptrty' (aka 'void (*)()') with an lvalue of type 's_ptrty' (aka 'void (*)() __attribute__((arm_streaming))')}}
-// expected-error@+1 {{incompatible function pointer types returning 's_ptrty' (aka 'void (*)(void) __attribute__((arm_streaming))') from a function with result type 'nonproto_n_ptrty' (aka 'void (*)()')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'nonproto_n_ptrty' (aka 'void (*)()') with an lvalue of type 's_ptrty' (aka 'void (*)() __arm_streaming')}}
+// expected-error@+1 {{incompatible function pointer types returning 's_ptrty' (aka 'void (*)(void) __arm_streaming') from a function with result type 'nonproto_n_ptrty' (aka 'void (*)()')}}
 nonproto_n_ptrty return_invalid_fptr_streaming_nonprotonormal(s_ptrty f) { return f; }
 
-typedef __attribute__((arm_streaming_compatible)) void (*sc_ptrty) (void);
+typedef void (*sc_ptrty) (void) __arm_streaming_compatible;
 sc_ptrty return_valid_streaming_compatible_fptr(sc_ptrty f) { return f; }
 
-// expected-cpp-error@+2 {{cannot initialize return object of type 'sc_ptrty' (aka 'void (*)() __attribute__((arm_streaming_compatible))') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
-// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 'sc_ptrty' (aka 'void (*)(void) __attribute__((arm_streaming_compatible))')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'sc_ptrty' (aka 'void (*)() __arm_streaming_compatible') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
+// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 'sc_ptrty' (aka 'void (*)(void) __arm_streaming_compatible')}}
 sc_ptrty return_invalid_fptr_streaming_compatible_normal(n_ptrty f) { return f; }
-// expected-cpp-error@+2 {{cannot initialize return object of type 'n_ptrty' (aka 'void (*)()') with an lvalue of type 'sc_ptrty' (aka 'void (*)() __attribute__((arm_streaming_compatible))')}}
-// expected-error@+1 {{incompatible function pointer types returning 'sc_ptrty' (aka 'void (*)(void) __attribute__((arm_streaming_compatible))') from a function with result type 'n_ptrty' (aka 'void (*)(void)')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'n_ptrty' (aka 'void (*)()') with an lvalue of type 'sc_ptrty' (aka 'void (*)() __arm_streaming_compatible')}}
+// expected-error@+1 {{incompatible function pointer types returning 'sc_ptrty' (aka 'void (*)(void) __arm_streaming_compatible') from a function with result type 'n_ptrty' (aka 'void (*)(void)')}}
 n_ptrty return_invalid_fptr_normal_streaming_compatible(sc_ptrty f) { return f; }
 
-typedef __attribute__((arm_new_za)) void (*nz_ptrty) (void);
+typedef void (*nz_ptrty) (void) __arm_new_za;
 nz_ptrty return_valid_new_za_fptr(nz_ptrty f) { return f; }
 
-// expected-cpp-error@+2 {{cannot initialize return object of type 'nz_ptrty' (aka 'void (*)() __attribute__((arm_new_za))') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
-// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 'nz_ptrty' (aka 'void (*)(void) __attribute__((arm_new_za))')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'nz_ptrty' (aka 'void (*)() __arm_new_za') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
+// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 'nz_ptrty' (aka 'void (*)(void) __arm_new_za')}}
 nz_ptrty return_invalid_fptr_new_za_normal(n_ptrty f) { return f; }
-// expected-cpp-error@+2 {{cannot initialize return object of type 'n_ptrty' (aka 'void (*)()') with an lvalue of type 'nz_ptrty' (aka 'void (*)() __attribute__((arm_new_za))')}}
-// expected-error@+1 {{incompatible function pointer types returning 'nz_ptrty' (aka 'void (*)(void) __attribute__((arm_new_za))') from a function with result type 'n_ptrty' (aka 'void (*)(void)')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'n_ptrty' (aka 'void (*)()') with an lvalue of type 'nz_ptrty' (aka 'void (*)() __arm_new_za')}}
+// expected-error@+1 {{incompatible function pointer types returning 'nz_ptrty' (aka 'void (*)(void) __arm_new_za') from a function with result type 'n_ptrty' (aka 'void (*)(void)')}}
 n_ptrty return_invalid_fptr_normal_new_za(nz_ptrty f) { return f; }
 
-typedef __attribute__((arm_shared_za)) void (*sz_ptrty) (void);
+typedef void (*sz_ptrty) (void) __arm_shared_za;
 sz_ptrty return_valid_shared_za_fptr(sz_ptrty f) { return f; }
 
 
-// expected-cpp-error@+2 {{cannot initialize return object of type 'sz_ptrty' (aka 'void (*)() __attribute__((arm_shared_za))') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
-// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 'sz_ptrty' (aka 'void (*)(void) __attribute__((arm_shared_za))')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'sz_ptrty' (aka 'void (*)() __arm_shared_za') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
+// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 'sz_ptrty' (aka 'void (*)(void) __arm_shared_za')}}
 sz_ptrty return_invalid_fptr_shared_za_normal(n_ptrty f) { return f; }
-// expected-cpp-error@+2 {{cannot initialize return object of type 'n_ptrty' (aka 'void (*)()') with an lvalue of type 'sz_ptrty' (aka 'void (*)() __attribute__((arm_shared_za))')}}
-// expected-error@+1 {{incompatible function pointer types returning 'sz_ptrty' (aka 'void (*)(void) __attribute__((arm_shared_za))') from a function with result type 'n_ptrty' (aka 'void (*)(void)')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'n_ptrty' (aka 'void (*)()') with an lvalue of type 'sz_ptrty' (aka 'void (*)() __arm_shared_za')}}
+// expected-error@+1 {{incompatible function pointer types returning 'sz_ptrty' (aka 'void (*)(void) __arm_shared_za') from a function with result type 'n_ptrty' (aka 'void (*)(void)')}}
 n_ptrty return_invalid_fptr_normal_shared_za(sz_ptrty f) { return f; }
 
-typedef __attribute__((arm_preserves_za)) void (*pz_ptrty) (void);
+typedef void (*pz_ptrty) (void) __arm_preserves_za;
 pz_ptrty return_valid_preserves_za_fptr(pz_ptrty f) { return f; }
 
-// expected-cpp-error@+2 {{cannot initialize return object of type 'pz_ptrty' (aka 'void (*)() __attribute__((arm_preserves_za))') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
-// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 'pz_ptrty' (aka 'void (*)(void) __attribute__((arm_preserves_za))')}}
+// expected-cpp-error@+2 {{cannot initialize return object of type 'pz_ptrty' (aka 'void (*)() __arm_preserves_za') with an lvalue of type 'n_ptrty' (aka 'void (*)()')}}
+// expected-error@+1 {{incompatible function pointer types returning 'n_ptrty' (aka 'void (*)(void)') from a function with result type 'pz_ptrty' (aka 'void (*)(void) __arm_preserves_za')}}
 pz_ptrty return_invalid_fptr_preserves_za_normal(n_ptrty f) { return f; }
 // No diagnostics, the preserves_za hint should be dropped silently.
 n_ptrty return_invalid_fptr_normal_preserves_za(pz_ptrty f) { return f; }
 
 // Test template instantiations
 #ifdef __cplusplus
-template <typename T> __attribute__((arm_streaming)) T templated(T x) { return x; }
-template <> __attribute__((arm_streaming)) int templated<int>(int x) { return x + 1; }
-template <> __attribute__((arm_streaming)) float templated<float>(float x) { return x + 2; }
+template <typename T> T templated(T x) __arm_streaming { return x; }
+template <> int templated<int>(int x) __arm_streaming { return x + 1; }
+template <> float templated<float>(float x) __arm_streaming { return x + 2; }
 // expected-cpp-error@+2 {{explicit instantiation of 'templated' does not refer to a function template, variable template, member function, member class, or static data member}}
-// expected-cpp-note@-4 {{candidate template ignored: could not match 'short (short) __attribute__((arm_streaming))' against 'short (short)'}}
+// expected-cpp-note@-4 {{candidate template ignored: could not match 'short (short) __arm_streaming' against 'short (short)'}}
 template short templated<short>(short);
 #endif
 
 // Conflicting attributes on redeclarations
 
-// expected-error@+5 {{function declared ''void (void) __attribute__((arm_streaming_compatible))'' was previously declared ''void (void) __attribute__((arm_streaming))'' with different SME function attributes}}
+// expected-error@+5 {{function declared ''void (void) __arm_streaming_compatible'' was previously declared ''void (void) __arm_streaming'' with different SME function attributes}}
 // expected-note@+3 {{previous declaration is here}}
-// expected-cpp-error@+3 {{function declared ''void () __attribute__((arm_streaming_compatible))'' was previously declared ''void () __attribute__((arm_streaming))'' with different SME function attributes}}
+// expected-cpp-error@+3 {{function declared ''void () __arm_streaming_compatible'' was previously declared ''void () __arm_streaming'' with different SME function attributes}}
 // expected-cpp-note@+1 {{previous declaration is here}}
-__attribute__((arm_streaming)) void redecl(void);
-__attribute__((arm_streaming_compatible)) void redecl(void) { }
+void redecl(void) __arm_streaming;
+void redecl(void) __arm_streaming_compatible { }
 
-// expected-error@+5 {{function declared ''void (void) __attribute__((arm_shared_za))'' was previously declared ''void (void) __attribute__((arm_shared_za)) __attribute__((arm_preserves_za))'' with different SME function attributes}}
+// expected-error@+5 {{function declared ''void (void) __arm_shared_za'' was previously declared ''void (void) __arm_shared_za __arm_preserves_za'' with different SME function attributes}}
 // expected-note@+3 {{previous declaration is here}}
-// expected-cpp-error@+3 {{function declared ''void () __attribute__((arm_shared_za))'' was previously declared ''void () __attribute__((arm_shared_za)) __attribute__((arm_preserves_za))'' with different SME function attributes}}
+// expected-cpp-error@+3 {{function declared ''void () __arm_shared_za'' was previously declared ''void () __arm_shared_za __arm_preserves_za'' with different SME function attributes}}
 // expected-cpp-note@+1 {{previous declaration is here}}
-__attribute__((arm_shared_za, arm_preserves_za)) void redecl_nopreserve_za(void);
-__attribute__((arm_shared_za)) void redecl_nopreserve_za(void) { }
+void redecl_nopreserve_za(void) __arm_shared_za __arm_preserves_za;
+void redecl_nopreserve_za(void) __arm_shared_za { }
 
 #ifdef __cplusplus
 struct S {
-  virtual __attribute__((arm_shared_za)) void shared_za_memberfn(void);
+  virtual void shared_za_memberfn(void) __arm_shared_za;
 };
 
 struct S2 : public S {
-// expected-cpp-error@+2 {{virtual function 'shared_za_memberfn' has different attributes ('void () __attribute__((arm_new_za))') than the function it overrides (which has 'void () __attribute__((arm_shared_za))')}}
+// expected-cpp-error@+2 {{virtual function 'shared_za_memberfn' has different attributes ('void () __arm_new_za') than the function it overrides (which has 'void () __arm_shared_za')}}
 // expected-cpp-note@-5 {{overridden virtual function is here}}
-  __attribute__((arm_new_za)) void shared_za_memberfn(void) override;
+  void shared_za_memberfn(void) __arm_new_za override;
 };
 
 // Check that the attribute propagates through template instantiations.
 template <typename Ty>
 struct S3 {
   static constexpr int value = 0;
 };
 
 template <>
 struct S3<void (*)()> {
   static constexpr int value = 1;
 };
 
 template <>
-struct S3<void (* __attribute__((arm_streaming)))()> {
+struct S3<void (* __arm_streaming)()> {
   static constexpr int value = 2;
 };
 
 void normal_func() {}
-void streaming_func() __attribute__((arm_streaming)) {}
+void streaming_func() __arm_streaming {}
 
 static_assert(S3<decltype(+normal_func)>::value == 1, "why are we picking the wrong specialization?");
 static_assert(S3<decltype(+streaming_func)>::value == 2, "why are we picking the wrong specialization?");
 #endif
 
-// expected-cpp-error@+2 {{'arm_streaming' attribute takes no arguments}}
-// expected-error@+1 {{'arm_streaming' attribute takes no arguments}}
-__attribute__((arm_streaming(0))) void invalid_streaming_args(void);
-
-// expected-cpp-error@+4 {{attribute only applies to non-K&R-style functions}}
-// expected-cpp-warning@+3 {{'arm_streaming' only applies to function types; type here is 'int'}}
-// expected-error@+2 {{attribute only applies to non-K&R-style functions}}
-// expected-warning@+1 {{'arm_streaming' only applies to function types; type here is 'int'}}
-__attribute__((arm_streaming)) int invalid_type_for_attribute;
+// expected-cpp-error@+2 {{'__arm_streaming' only applies to function types; type here is 'int'}}
+// expected-error@+1 {{'__arm_streaming' only applies to function types; type here is 'int'}}
+int invalid_type_for_attribute __arm_streaming;

clang/utils/TableGen/ClangAttrEmitter.cpp

for (auto I = List.cbegin(), E = List.cend(); I != E; ++I) {
       OS << "}";
     }
     OS << "\n} break;\n";
   };
   fn("CXX11", CXX);
   fn("C2x", C2x);
   OS << "case AttributeCommonInfo::Syntax::AS_Keyword:\n";
   OS << "case AttributeCommonInfo::Syntax::AS_ContextSensitiveKeyword:\n";
+  OS << "case AttributeCommonInfo::Syntax::AS_AttributeLikeKeyword:\n";
   OS << "  llvm_unreachable(\"hasAttribute not supported for keyword\");\n";
   OS << "  return 0;\n";
 
   OS << "}\n";
 }
 
 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Code to translate different attribute spellings "
static void GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
 
   if (DeclSubjects.empty()) {
     // If there are no decl subjects but there are stmt subjects, diagnose
     // trying to apply a statement attribute to a declaration.
     if (!StmtSubjects.empty()) {
       OS << "bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, ";
       OS << "const Decl *D) const override {\n";
       OS << "  S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)\n";
-      OS << "    << AL << D->getLocation();\n";
+      OS << "    << AL << AL.isAttributeLikeKeyword() << D->getLocation();\n";
       OS << "  return false;\n";
       OS << "}\n\n";
     }
   } else {
     // Otherwise, generate an appertainsTo check specific to this attribute
     // which checks all of the given subjects against the Decl passed in.
     OS << "bool diagAppertainsToDecl(Sema &S, ";
     OS << "const ParsedAttr &Attr, const Decl *D) const override {\n";
for (auto I = DeclSubjects.begin(), E = DeclSubjects.end(); I != E; ++I) {
       if (I + 1 != E)
         OS << " && ";
     }
     OS << ") {\n";
     OS << "    S.Diag(Attr.getLoc(), diag::";
     OS << (Warn ? "warn_attribute_wrong_decl_type_str"
                 : "err_attribute_wrong_decl_type_str");
     OS << ")\n";
-    OS << "      << Attr << ";
+    OS << "      << Attr << Attr.isAttributeLikeKeyword() << ";
     OS << CalculateDiagnostic(*SubjectObj) << ";\n";
     OS << "    return false;\n";
     OS << "  }\n";
     OS << "  return true;\n";
     OS << "}\n\n";
   }
 
   if (StmtSubjects.empty()) {
     // If there are no stmt subjects but there are decl subjects, diagnose
     // trying to apply a declaration attribute to a statement.
     if (!DeclSubjects.empty()) {
       OS << "bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, ";
       OS << "const Stmt *St) const override {\n";
       OS << "  S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)\n";
-      OS << "    << AL << St->getBeginLoc();\n";
+      OS << "    << AL << AL.isAttributeLikeKeyword() << St->getBeginLoc();\n";
       OS << "  return false;\n";
       OS << "}\n\n";
     }
   } else {
     // Now, do the same for statements.
     OS << "bool diagAppertainsToStmt(Sema &S, ";
     OS << "const ParsedAttr &Attr, const Stmt *St) const override {\n";
     OS << "  if (";
     for (auto I = StmtSubjects.begin(), E = StmtSubjects.end(); I != E; ++I) {
       OS << "!isa<" << (*I)->getName() << ">(St)";
       if (I + 1 != E)
         OS << " && ";
     }
     OS << ") {\n";
     OS << "    S.Diag(Attr.getLoc(), diag::";
     OS << (Warn ? "warn_attribute_wrong_decl_type_str"
                 : "err_attribute_wrong_decl_type_str");
     OS << ")\n";
-    OS << "      << Attr << ";
+    OS << "      << Attr << Attr.isAttributeLikeKeyword() << ";
     OS << CalculateDiagnostic(*SubjectObj) << ";\n";
     OS << "    return false;\n";
     OS << "  }\n";
     OS << "  return true;\n";
     OS << "}\n\n";
   }
 }
 
static void GenerateMutualExclusionsChecks(const Record &Attr,
   // predicates for them now.
   if (!DeclAttrs.empty()) {
     // Generate the ParsedAttrInfo subclass logic for declarations.
     OS << "  bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, "
        << "const Decl *D) const override {\n";
     for (const std::string &A : DeclAttrs) {
       OS << "    if (const auto *A = D->getAttr<" << A << ">()) {\n";
       OS << "      S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)"
-         << " << AL << A;\n";
+         << " << AL << A << (AL.isAttributeLikeKeyword() ||"
+         << " A->isAttributeLikeKeyword());\n";
       OS << "      S.Diag(A->getLocation(), diag::note_conflicting_attribute);";
       OS << "      \nreturn false;\n";
       OS << "    }\n";
     }
     OS << "    return true;\n";
     OS << "  }\n\n";
 
     // Also generate the declaration attribute merging logic if the current
     // attribute is one that can be inheritted on a declaration. It is assumed
     // this code will be executed in the context of a function with parameters:
     // Sema &S, Decl *D, Attr *A and that returns a bool (false on diagnostic,
     // true on success).
     if (Attr.isSubClassOf("InheritableAttr")) {
       MergeDeclOS << "  if (const auto *Second = dyn_cast<"
                   << (Attr.getName() + "Attr").str() << ">(A)) {\n";
       for (const std::string &A : DeclAttrs) {
         MergeDeclOS << "    if (const auto *First = D->getAttr<" << A
                     << ">()) {\n";
         MergeDeclOS << "      S.Diag(First->getLocation(), "
                     << "diag::err_attributes_are_not_compatible) << First << "
-                    << "Second;\n";
+                    << "Second << (First->isAttributeLikeKeyword() || "
+                    << "Second->isAttributeLikeKeyword());\n";
         MergeDeclOS << "      S.Diag(Second->getLocation(), "
                     << "diag::note_conflicting_attribute);\n";
         MergeDeclOS << "      return false;\n";
         MergeDeclOS << "    }\n";
       }
       MergeDeclOS << "    return true;\n";
       MergeDeclOS << "  }\n";
     }
MergeStmtOS << "      auto Iter = llvm::find_if(C, [](const Attr *Check) "
                 << "{ return isa<";
     interleave(
         StmtAttrs, [&](const std::string &Name) { MergeStmtOS << Name; },
         [&] { MergeStmtOS << ", "; });
     MergeStmtOS << ">(Check); });\n";
     MergeStmtOS << "      if (Iter != C.end()) {\n";
     MergeStmtOS << "        S.Diag((*Iter)->getLocation(), "
                 << "diag::err_attributes_are_not_compatible) << *Iter << "
-                << "Second;\n";
+                << "Second << ((*Iter)->isAttributeLikeKeyword() || "
+                << "Second->isAttributeLikeKeyword());\n";
     MergeStmtOS << "        S.Diag(Second->getLocation(), "
                 << "diag::note_conflicting_attribute);\n";
     MergeStmtOS << "        return false;\n";
     MergeStmtOS << "      }\n";
     MergeStmtOS << "    }\n";
   }
 }
 
void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
   StringMatcher("Name", Declspec, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_Microsoft == Syntax) {\n";
   StringMatcher("Name", Microsoft, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_CXX11 == Syntax) {\n";
   StringMatcher("Name", CXX11, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_C2x == Syntax) {\n";
   StringMatcher("Name", C2x, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_Keyword == Syntax || ";
-  OS << "AttributeCommonInfo::AS_ContextSensitiveKeyword == Syntax) {\n";
+  OS << "AttributeCommonInfo::AS_ContextSensitiveKeyword == Syntax || ";
+  OS << "AttributeCommonInfo::AS_AttributeLikeKeyword == Syntax) {\n";
   StringMatcher("Name", Keywords, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_Pragma == Syntax) {\n";
   StringMatcher("Name", Pragma, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_HLSLSemantic == Syntax) {\n";
   StringMatcher("Name", HLSLSemantic, OS).Emit();
   OS << "  }\n";
   OS << "  return AttributeCommonInfo::UnknownAttribute;\n"
      << "}\n";