[clang] [WIP] Reject C++ 11 attributes appertaining to the wrong entity type.

[mboehme]

Summary

Note: This is an "alternative considered" to my preferred solution at https://reviews.llvm.org/D124919

DRAFT -- do not review.

Depends On D111548

[mboehme]

It appears that we're converging on the approach in https://reviews.llvm.org/D126061, so I'm abandoning this change.

clang/include/clang/Basic/Attr.td

def SwiftAsyncError : InheritableAttr {
   let Subjects = SubjectList<[Function, ObjCMethod]>;
   let Args = [EnumArgument<"Convention", "ConventionKind",
               ["none", "nonnull_error", "zero_argument", "nonzero_argument"],
               ["None", "NonNullError", "ZeroArgument", "NonZeroArgument"]>,
               UnsignedArgument<"HandlerParamIdx", /*opt=*/1>];
   let Documentation = [SwiftAsyncErrorDocs];
 }
 
-def Suppress : StmtAttr {
+def Suppress : DeclOrStmtAttr {
   let Spellings = [CXX11<"gsl", "suppress">];
   let Args = [VariadicStringArgument<"DiagnosticIdentifiers">];
   let Documentation = [SuppressDocs];
 }
 
 def SysVABI : DeclOrTypeAttr {
   let Spellings = [GCC<"sysv_abi">];
 //  let Subjects = [Function, ObjCMethod];

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_attribute_has_no_effect_on_infinite_loop : Warning<
    InGroup<IgnoredAttributes>;
 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<
+def err_attribute_invalid_on_stmt : Error<
   "%0 attribute cannot be applied to a statement">;
-def err_stmt_attribute_invalid_on_decl : Error<
+def err_attribute_invalid_on_decl : Error<
   "%0 attribute cannot be applied to a declaration">;
 def err_type_attribute_invalid_on_decl : Error<
   "%0 attribute cannot be applied to a declaration">;
 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<

clang/include/clang/Parse/Parser.h

private:
   /// arbitrary order. e.g.,
   ///
   ///   [[]] __attribute__(()) int i; // OK
   ///   __attribute__(()) [[]] int i; // Not OK
   ///
   /// Such situations should use the specific attribute parsing functionality.
   void ParseAttributes(unsigned WhichAttrKinds,
                        ParsedAttributesWithRange &Attrs,
+                       AttributeAppertainsTo appertainsTo,
                        LateParsedAttrList *LateAttrs = nullptr);
   void ParseAttributes(unsigned WhichAttrKinds, ParsedAttributes &Attrs,
+                       AttributeAppertainsTo appertainsTo,
                        LateParsedAttrList *LateAttrs = nullptr) {
     ParsedAttributesWithRange AttrsWithRange(AttrFactory);
-    ParseAttributes(WhichAttrKinds, AttrsWithRange, LateAttrs);
+    ParseAttributes(WhichAttrKinds, AttrsWithRange, appertainsTo, LateAttrs);
     Attrs.takeAllFrom(AttrsWithRange);
   }
   /// \brief Possibly parse attributes based on what syntaxes are desired,
   /// allowing for the order to vary.
   bool MaybeParseAttributes(unsigned WhichAttrKinds,
                             ParsedAttributesWithRange &Attrs,
+                            AttributeAppertainsTo appertainsTo,
                             LateParsedAttrList *LateAttrs = nullptr) {
     if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec) ||
         (standardAttributesAllowed() && isCXX11AttributeSpecifier())) {
-      ParseAttributes(WhichAttrKinds, Attrs, LateAttrs);
+      ParseAttributes(WhichAttrKinds, Attrs, appertainsTo, LateAttrs);
       return true;
     }
     return false;
   }
   bool MaybeParseAttributes(unsigned WhichAttrKinds, ParsedAttributes &Attrs,
+                            AttributeAppertainsTo appertainsTo,
                             LateParsedAttrList *LateAttrs = nullptr) {
     if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec) ||
         (standardAttributesAllowed() && isCXX11AttributeSpecifier())) {
-      ParseAttributes(WhichAttrKinds, Attrs, LateAttrs);
+      ParseAttributes(WhichAttrKinds, Attrs, appertainsTo, LateAttrs);
       return true;
     }
     return false;
   }
 
   void MaybeParseGNUAttributes(Declarator &D,
                                LateParsedAttrList *LateAttrs = nullptr) {
     if (Tok.is(tok::kw___attribute)) {
if (!OpenMPTokens.empty()) {
       PP.EnterTokenStream(OpenMPTokens, /*DisableMacroExpansion*/ true,
                           /*IsReinject*/ true);
       ConsumeAnyToken(/*ConsumeCodeCompletionTok*/ true);
     }
   }
   void MaybeParseCXX11Attributes(Declarator &D) {
     if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
       ParsedAttributesWithRange attrs(AttrFactory);
-      ParseCXX11Attributes(attrs);
+      // TODO: Is this correct?
+      ParseCXX11Attributes(attrs, AppertainsToDecl);
       D.takeAttributes(attrs, attrs.Range.getEnd());
     }
   }
-  bool MaybeParseCXX11Attributes(ParsedAttributes &attrs) {
+  bool MaybeParseCXX11Attributes(ParsedAttributes &attrs,
+                                 AttributeAppertainsTo appertainsTo) {
     if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
       ParsedAttributesWithRange attrsWithRange(AttrFactory);
-      ParseCXX11Attributes(attrsWithRange);
+      ParseCXX11Attributes(attrsWithRange, appertainsTo);
       attrs.takeAllFrom(attrsWithRange);
       return true;
     }
     return false;
   }
   bool MaybeParseCXX11Attributes(ParsedAttributesWithRange &attrs,
+                                 AttributeAppertainsTo appertainsTo,
                                  bool OuterMightBeMessageSend = false) {
     if (standardAttributesAllowed() &&
         isCXX11AttributeSpecifier(false, OuterMightBeMessageSend)) {
-      ParseCXX11Attributes(attrs);
+      // TODO: How to pass?
+      ParseCXX11Attributes(attrs, appertainsTo);
       return true;
     }
     return false;
   }
 
   void ParseOpenMPAttributeArgs(IdentifierInfo *AttrName,
                                 CachedTokens &OpenMPTokens);
 
+  void DiagnoseAppertainsTo(ParsedAttr &PA, AttributeAppertainsTo appertainsTo);
+  void DiagnoseAppertainsTo(ParsedAttributesView &Attrs,
+                            AttributeAppertainsTo appertainsTo);
+
   void ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs,
                                             CachedTokens &OpenMPTokens,
+                                            AttributeAppertainsTo appertainsTo,
                                             SourceLocation *EndLoc = nullptr);
   void ParseCXX11AttributeSpecifier(ParsedAttributes &Attrs,
+                                    AttributeAppertainsTo appertainsTo,
                                     SourceLocation *EndLoc = nullptr) {
     CachedTokens OpenMPTokens;
-    ParseCXX11AttributeSpecifierInternal(Attrs, OpenMPTokens, EndLoc);
+    ParseCXX11AttributeSpecifierInternal(Attrs, OpenMPTokens, appertainsTo,
+                                         EndLoc);
     ReplayOpenMPAttributeTokens(OpenMPTokens);
   }
-  void ParseCXX11Attributes(ParsedAttributesWithRange &attrs);
+  void ParseCXX11Attributes(ParsedAttributesWithRange &attrs,
+                            AttributeAppertainsTo appertainsTo);
   /// Parses a C++11 (or C2x)-style attribute argument list. Returns true
   /// if this results in adding an attribute to the ParsedAttributes list.
   bool ParseCXX11AttributeArgs(IdentifierInfo *AttrName,
                                SourceLocation AttrNameLoc,
                                ParsedAttributes &Attrs, SourceLocation *EndLoc,
                                IdentifierInfo *ScopeName,
                                SourceLocation ScopeLoc,
                                CachedTokens &OpenMPTokens);

clang/include/clang/Sema/ParsedAttr.h

struct ParsedAttrInfo {
   // True if this attribute accepts expression parameter pack expansions.
   unsigned AcceptsExprPack : 1;
   /// True if this attribute is only available for certain targets.
   unsigned IsTargetSpecific : 1;
   /// True if this attribute applies to types.
   unsigned IsType : 1;
   /// True if this attribute applies to statements.
   unsigned IsStmt : 1;
+  /// True if this attribute applies to declarations.
+  unsigned IsDecl : 1;
   /// True if this attribute has any spellings that are known to gcc.
   unsigned IsKnownToGCC : 1;
   /// True if this attribute is supported by #pragma clang attribute.
   unsigned IsSupportedByPragmaAttribute : 1;
   /// The syntaxes supported by this attribute and how they're spelled.
   struct Spelling {
     AttributeCommonInfo::Syntax Syntax;
     const char *NormalizedFullName;
   };
   ArrayRef<Spelling> Spellings;
   // The names of the known arguments of this attribute.
   ArrayRef<const char *> ArgNames;
 
 protected:
   constexpr ParsedAttrInfo(AttributeCommonInfo::Kind AttrKind =
                                AttributeCommonInfo::NoSemaHandlerAttribute)
       : AttrKind(AttrKind), NumArgs(0), OptArgs(0), NumArgMembers(0),
         HasCustomParsing(0), AcceptsExprPack(0), IsTargetSpecific(0), IsType(0),
-        IsStmt(0), IsKnownToGCC(0), IsSupportedByPragmaAttribute(0) {}
+        IsStmt(0), IsDecl(0), IsKnownToGCC(0), IsSupportedByPragmaAttribute(0) {
+  }
 
   constexpr ParsedAttrInfo(AttributeCommonInfo::Kind AttrKind, unsigned NumArgs,
                            unsigned OptArgs, unsigned NumArgMembers,
                            unsigned HasCustomParsing, unsigned AcceptsExprPack,
                            unsigned IsTargetSpecific, unsigned IsType,
-                           unsigned IsStmt, unsigned IsKnownToGCC,
+                           unsigned IsStmt, unsigned IsDecl,
+                           unsigned IsKnownToGCC,
                            unsigned IsSupportedByPragmaAttribute,
                            ArrayRef<Spelling> Spellings,
                            ArrayRef<const char *> ArgNames)
       : AttrKind(AttrKind), NumArgs(NumArgs), OptArgs(OptArgs),
         NumArgMembers(NumArgMembers), HasCustomParsing(HasCustomParsing),
         AcceptsExprPack(AcceptsExprPack), IsTargetSpecific(IsTargetSpecific),
-        IsType(IsType), IsStmt(IsStmt), IsKnownToGCC(IsKnownToGCC),
+        IsType(IsType), IsStmt(IsStmt), IsDecl(IsDecl),
+        IsKnownToGCC(IsKnownToGCC),
         IsSupportedByPragmaAttribute(IsSupportedByPragmaAttribute),
         Spellings(Spellings), ArgNames(ArgNames) {}
 
 public:
   virtual ~ParsedAttrInfo() = default;
 
   /// Check if this attribute appertains to D, and issue a diagnostic if not.
   virtual bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr,
enum AttributeDeclKind {
   ExpectedVariableOrField,
   ExpectedVariableFieldOrTag,
   ExpectedTypeOrNamespace,
   ExpectedFunctionVariableOrClass,
   ExpectedKernelFunction,
   ExpectedFunctionWithProtoType,
 };
 
+// TODO: Document
+enum AttributeAppertainsTo {
+  AppertainsToDecl,
+  AppertainsToStmt,
+  AppertainsToType,
+  AppertainsToUnknown,
+};
+
 inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                              const ParsedAttr &At) {
   DB.AddTaggedVal(reinterpret_cast<uint64_t>(At.getAttrName()),
                   DiagnosticsEngine::ak_identifierinfo);
   return DB;
 }
 
 inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,

clang/lib/Parse/ParseDecl.cpp

bool AttrStartIsInMacro =
       Lexer::isAtStartOfMacroExpansion(StartLoc, SM, PP.getLangOpts());
   bool AttrEndIsInMacro =
       Lexer::isAtEndOfMacroExpansion(EndLoc, SM, PP.getLangOpts());
   return AttrStartIsInMacro && AttrEndIsInMacro;
 }
 
 void Parser::ParseAttributes(unsigned WhichAttrKinds,
                              ParsedAttributesWithRange &Attrs,
+                             AttributeAppertainsTo appertainsTo,
                              LateParsedAttrList *LateAttrs) {
   bool MoreToParse;
   do {
     // Assume there's nothing left to parse, but if any attributes are in fact
     // parsed, loop to ensure all specified attribute combinations are parsed.
     MoreToParse = false;
     if (WhichAttrKinds & PAKM_CXX11)
-      MoreToParse |= MaybeParseCXX11Attributes(Attrs);
+      // TODO: Need to plumb the right value in here
+      MoreToParse |= MaybeParseCXX11Attributes(Attrs, appertainsTo);
     if (WhichAttrKinds & PAKM_GNU)
       MoreToParse |= MaybeParseGNUAttributes(Attrs, LateAttrs);
     if (WhichAttrKinds & PAKM_Declspec)
       MoreToParse |= MaybeParseMicrosoftDeclSpecs(Attrs);
   } while (MoreToParse);
 }
 
 /// ParseGNUAttributes - Parse a non-empty attributes list.

 /// provide a fixit moving them to the right place.
 void Parser::DiagnoseMisplacedCXX11Attribute(ParsedAttributesWithRange &Attrs,
                                              SourceLocation CorrectLocation) {
   assert((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) ||
          Tok.is(tok::kw_alignas));
 
   // Consume the attributes.
   SourceLocation Loc = Tok.getLocation();
-  ParseCXX11Attributes(Attrs);
+  ParseCXX11Attributes(Attrs, AppertainsToUnknown);
   CharSourceRange AttrRange(SourceRange(Loc, Attrs.Range.getEnd()), true);
   // FIXME: use err_attributes_misplaced
   Diag(Loc, diag::err_attributes_not_allowed)
     << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
     << FixItHint::CreateRemoval(AttrRange);
 }
 
 void Parser::DiagnoseProhibitedAttributes(
case tok::kw_alignas:
 
       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);
+      ParseCXX11Attributes(attrs, AppertainsToType);
       AttrsLastTime = true;
       continue;
 
     case tok::code_completion: {
       Sema::ParserCompletionContext CCC = Sema::PCC_Namespace;
       if (DS.hasTypeSpecifier()) {
         bool AllowNonIdentifiers
           = (getCurScope()->getFlags() & (Scope::ControlScope |
case tok::annot_template_id: {
       CXXScopeSpec SS;
       AnnotateTemplateIdTokenAsType(SS);
       continue;
     }
 
     // Attributes support.
     case tok::kw___attribute:
     case tok::kw___declspec:
-      ParseAttributes(PAKM_GNU | PAKM_Declspec, DS.getAttributes(), LateAttrs);
+      ParseAttributes(PAKM_GNU | PAKM_Declspec, DS.getAttributes(),
+                      AppertainsToType, LateAttrs);
       continue;
 
     // Microsoft single token adornments.
     case tok::kw___forceinline: {
       isInvalid = DS.setFunctionSpecForceInline(Loc, PrevSpec, DiagID);
       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
       SourceLocation AttrNameLoc = Tok.getLocation();
       DS.getAttributes().addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc,
if (Tok.is(tok::kw___extension__)) {
     // __extension__ silences extension warnings in the subexpression.
     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
     ConsumeToken();
     return ParseStructDeclaration(DS, FieldsCallback);
   }
 
   // Parse leading attributes.
   ParsedAttributesWithRange Attrs(AttrFactory);
-  MaybeParseCXX11Attributes(Attrs);
+  MaybeParseCXX11Attributes(Attrs, AppertainsToDecl);
   DS.takeAttributesFrom(Attrs);
 
   // Parse the common specifier-qualifiers-list piece.
   ParseSpecifierQualifierList(DS);
 
   // If there are no declarators, this is a free-standing declaration
   // specifier. Let the actions module cope with it.
   if (Tok.is(tok::semi)) {
if (Tok.is(tok::code_completion)) {
     // Code completion for an enum name.
     cutOffParsing();
     Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
     return;
   }
 
   // If attributes exist after tag, parse them.
   ParsedAttributesWithRange attrs(AttrFactory);
-  MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs);
+  MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs,
+                       AppertainsToDecl);
 
   SourceLocation ScopedEnumKWLoc;
   bool IsScopedUsingClassTag = false;
 
   // In C++11, recognize 'enum class' and 'enum struct'.
   if (Tok.isOneOf(tok::kw_class, tok::kw_struct)) {
     Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_scoped_enum
                                         : diag::ext_scoped_enum);
     IsScopedUsingClassTag = Tok.is(tok::kw_class);
     ScopedEnumKWLoc = ConsumeToken();
 
     // Attributes are not allowed between these keywords.  Diagnose,
     // but then just treat them like they appeared in the right place.
     ProhibitAttributes(attrs);
 
     // They are allowed afterwards, though.
-    MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs);
+    MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs,
+                         AppertainsToDecl);
   }
 
   // C++11 [temp.explicit]p12:
   //   The usual access controls do not apply to names used to specify
   //   explicit instantiations.
   // We extend this to also cover explicit specializations.  Note that
   // we don't suppress if this turns out to be an elaborated type
   // specifier.
while (Tok.isNot(tok::r_brace)) {
     ParsedAttributesWithRange attrs(AttrFactory);
     MaybeParseGNUAttributes(attrs);
     if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
       if (getLangOpts().CPlusPlus)
         Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
                                     ? diag::warn_cxx14_compat_ns_enum_attribute
                                     : diag::ext_ns_enum_attribute)
             << 1 /*enumerator*/;
-      ParseCXX11Attributes(attrs);
+      ParseCXX11Attributes(attrs, AppertainsToDecl);
     }
 
     SourceLocation EqualLoc;
     ExprResult AssignedVal;
     EnumAvailabilityDiags.emplace_back(*this);
 
     EnterExpressionEvaluationContext ConstantEvaluated(
         Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);

 /// 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()) {
     ParsedAttributesWithRange attrs(AttrFactory);
-    ParseCXX11Attributes(attrs);
+    ParseCXX11Attributes(attrs, AppertainsToType);
     DS.takeAttributesFrom(attrs);
   }
 
   SourceLocation EndLoc;
 
   while (true) {
     bool isInvalid = false;
     const char *PrevSpec = nullptr;
if (isFunctionDeclaratorIdentifierList()) {
 
     Tracker.consumeClose();
     RParenLoc = Tracker.getCloseLocation();
     LocalEndLoc = RParenLoc;
     EndLoc = RParenLoc;
 
     // If there are attributes following the identifier list, parse them and
     // prohibit them.
-    MaybeParseCXX11Attributes(FnAttrs);
+    MaybeParseCXX11Attributes(FnAttrs, AppertainsToDecl);
     ProhibitAttributes(FnAttrs);
   } else {
     if (Tok.isNot(tok::r_paren))
       ParseParameterDeclarationClause(D.getContext(), FirstArgAttrs, ParamInfo,
                                       EllipsisLoc);
     else if (RequiresArg)
       Diag(Tok, diag::err_argument_required_after_attribute);
 
if (getLangOpts().CPlusPlus) {
                                                  DynamicExceptionRanges,
                                                  NoexceptExpr,
                                                  ExceptionSpecTokens);
       if (ESpecType != EST_None)
         EndLoc = ESpecRange.getEnd();
 
       // Parse attribute-specifier-seq[opt]. Per DR 979 and DR 1297, this goes
       // after the exception-specification.
-      MaybeParseCXX11Attributes(FnAttrs);
+      MaybeParseCXX11Attributes(FnAttrs, AppertainsToType);
 
       // Parse trailing-return-type[opt].
       LocalEndLoc = EndLoc;
       if (getLangOpts().CPlusPlus11 && Tok.is(tok::arrow)) {
         Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);
         if (D.getDeclSpec().getTypeSpecType() == TST_auto)
           StartLoc = D.getDeclSpec().getTypeSpecTypeLoc();
         LocalEndLoc = Tok.getLocation();
         SourceRange Range;
         TrailingReturnType =
             ParseTrailingReturnType(Range, D.mayBeFollowedByCXXDirectInit());
         TrailingReturnTypeLoc = Range.getBegin();
         EndLoc = Range.getEnd();
       }
     } else if (standardAttributesAllowed()) {
-      MaybeParseCXX11Attributes(FnAttrs);
+      MaybeParseCXX11Attributes(FnAttrs, AppertainsToType);
     }
   }
 
   // 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.
   SmallVector<NamedDecl *, 0> DeclsInPrototype;
do {
     if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
       break;
 
     // Parse the declaration-specifiers.
     // Just use the ParsingDeclaration "scope" of the declarator.
     DeclSpec DS(AttrFactory);
 
     // Parse any C++11 attributes.
-    MaybeParseCXX11Attributes(DS.getAttributes());
+    MaybeParseCXX11Attributes(DS.getAttributes(), AppertainsToDecl);
 
     // Skip any Microsoft attributes before a param.
     MaybeParseMicrosoftAttributes(DS.getAttributes());
 
     SourceLocation DSStart = Tok.getLocation();
 
     // If the caller parsed attributes for the first argument, add them now.
     // Take them so that we only apply the attributes to the first parameter.
void Parser::ParseBracketDeclarator(Declarator &D) {
   BalancedDelimiterTracker T(*this, tok::l_square);
   T.consumeOpen();
 
   // C array syntax has many features, but by-far the most common is [] and [4].
   // This code does a fast path to handle some of the most obvious cases.
   if (Tok.getKind() == tok::r_square) {
     T.consumeClose();
     ParsedAttributes attrs(AttrFactory);
-    MaybeParseCXX11Attributes(attrs);
+    MaybeParseCXX11Attributes(attrs, AppertainsToType);
 
     // Remember that we parsed the empty array type.
     D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, nullptr,
                                             T.getOpenLocation(),
                                             T.getCloseLocation()),
                   std::move(attrs), T.getCloseLocation());
     return;
   } else if (Tok.getKind() == tok::numeric_constant &&
              GetLookAheadToken(1).is(tok::r_square)) {
     // [4] is very common.  Parse the numeric constant expression.
     ExprResult ExprRes(Actions.ActOnNumericConstant(Tok, getCurScope()));
     ConsumeToken();
 
     T.consumeClose();
     ParsedAttributes attrs(AttrFactory);
-    MaybeParseCXX11Attributes(attrs);
+    MaybeParseCXX11Attributes(attrs, AppertainsToType);
 
     // Remember that we parsed a array type, and remember its features.
     D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, ExprRes.get(),
                                             T.getOpenLocation(),
                                             T.getCloseLocation()),
                   std::move(attrs), T.getCloseLocation());
     return;
   } else if (Tok.getKind() == tok::code_completion) {
if (NumElements.isInvalid()) {
     D.setInvalidType(true);
     // If the expression was invalid, skip it.
     SkipUntil(tok::r_square, StopAtSemi);
     return;
   }
 
   T.consumeClose();
 
-  MaybeParseCXX11Attributes(DS.getAttributes());
+  MaybeParseCXX11Attributes(DS.getAttributes(), AppertainsToType);
 
   // Remember that we parsed a array type, and remember its features.
   D.AddTypeInfo(
       DeclaratorChunk::getArray(DS.getTypeQualifiers(), StaticLoc.isValid(),
                                 isStar, NumElements.get(), T.getOpenLocation(),
                                 T.getCloseLocation()),
       std::move(DS.getAttributes()), T.getCloseLocation());
 }

clang/lib/Parse/ParseDeclCXX.cpp

 //===--- ParseDeclCXX.cpp - C++ Declaration Parsing -------------*- C++ -*-===//
 //
 // 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 the C++ Declaration portions of the Parser interfaces.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Parse/Parser.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/PrettyDeclStackTrace.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Parse/ParseDiagnostic.h"
+#include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/TimeProfiler.h"
 
 using namespace clang;
 
 /// ParseNamespace - We know that the current token is a namespace keyword. This
 /// may either be a top level namespace or a block-level namespace alias. If
 /// there was an inline keyword, it has already been parsed.
do {
         ParseGNUAttributes(attrs);
         MoreToParse = true;
       }
       if (getLangOpts().CPlusPlus11 && isCXX11AttributeSpecifier()) {
         Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
                                     ? diag::warn_cxx14_compat_ns_enum_attribute
                                     : diag::ext_ns_enum_attribute)
             << 0 /*namespace*/;
-        ParseCXX11Attributes(attrs);
+        ParseCXX11Attributes(attrs, AppertainsToDecl);
         MoreToParse = true;
       }
     } while (MoreToParse);
   };
 
   ReadAttributes();
 
   if (Tok.is(tok::identifier)) {

 void Parser::ParseInnerNamespace(const InnerNamespaceInfoList &InnerNSs,
                                  unsigned int index, SourceLocation &InlineLoc,
                                  ParsedAttributes &attrs,
                                  BalancedDelimiterTracker &Tracker) {
   if (index == InnerNSs.size()) {
     while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
            Tok.isNot(tok::eof)) {
       ParsedAttributesWithRange attrs(AttrFactory);
-      MaybeParseCXX11Attributes(attrs);
+      MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
       ParseExternalDeclaration(attrs);
     }
 
     // The caller is what called check -- we are simply calling
     // the close for it.
     Tracker.consumeClose();
 
     return;
Decl *Parser::ParseLinkage(ParsingDeclSpec &DS, DeclaratorContext Context) {
   Decl *LinkageSpec =
       Lang.isInvalid()
           ? nullptr
           : Actions.ActOnStartLinkageSpecification(
                 getCurScope(), DS.getSourceRange().getBegin(), Lang.get(),
                 Tok.is(tok::l_brace) ? Tok.getLocation() : SourceLocation());
 
   ParsedAttributesWithRange attrs(AttrFactory);
-  MaybeParseCXX11Attributes(attrs);
+  MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
 
   if (Tok.isNot(tok::l_brace)) {
     // Reset the source range in DS, as the leading "extern"
     // does not really belong to the inner declaration ...
     DS.SetRangeStart(SourceLocation());
     DS.SetRangeEnd(SourceLocation());
     // ... but anyway remember that such an "extern" was seen.
     DS.setExternInLinkageSpec(true);
case tok::eof:
       break;
 
     case tok::r_brace:
       if (!NestedModules)
         break;
       LLVM_FALLTHROUGH;
     default:
       ParsedAttributesWithRange attrs(AttrFactory);
-      MaybeParseCXX11Attributes(attrs);
+      MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
       ParseExternalDeclaration(attrs);
       continue;
     }
 
     break;
   }
 
   T.consumeClose();
Decl *Parser::ParseExportDeclaration() {
   ParseScope ExportScope(this, Scope::DeclScope);
   Decl *ExportDecl = Actions.ActOnStartExportDecl(
       getCurScope(), ExportLoc,
       Tok.is(tok::l_brace) ? Tok.getLocation() : SourceLocation());
 
   if (Tok.isNot(tok::l_brace)) {
     // FIXME: Factor out a ParseExternalDeclarationWithAttrs.
     ParsedAttributesWithRange Attrs(AttrFactory);
-    MaybeParseCXX11Attributes(Attrs);
+    MaybeParseCXX11Attributes(Attrs, AppertainsToDecl);
     MaybeParseMicrosoftAttributes(Attrs);
     ParseExternalDeclaration(Attrs);
     return Actions.ActOnFinishExportDecl(getCurScope(), ExportDecl,
                                          SourceLocation());
   }
 
   BalancedDelimiterTracker T(*this, tok::l_brace);
   T.consumeOpen();
 
   // The Modules TS draft says "An export-declaration shall declare at least one
   // entity", but the intent is that it shall contain at least one declaration.
   if (Tok.is(tok::r_brace) && getLangOpts().ModulesTS) {
     Diag(ExportLoc, diag::err_export_empty)
         << SourceRange(ExportLoc, Tok.getLocation());
   }
 
   while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
          Tok.isNot(tok::eof)) {
     ParsedAttributesWithRange Attrs(AttrFactory);
-    MaybeParseCXX11Attributes(Attrs);
+    MaybeParseCXX11Attributes(Attrs, AppertainsToDecl);
     MaybeParseMicrosoftAttributes(Attrs);
     ParseExternalDeclaration(Attrs);
   }
 
   T.consumeClose();
   return Actions.ActOnFinishExportDecl(getCurScope(), ExportDecl,
                                        T.getCloseLocation());
 }
if (ExpectAndConsume(tok::semi, diag::err_expected_after,
       SkipUntil(tok::semi);
 
     return Actions.ConvertDeclToDeclGroup(UED);
   }
 
   // Check for misplaced attributes before the identifier in an
   // alias-declaration.
   ParsedAttributesWithRange MisplacedAttrs(AttrFactory);
-  MaybeParseCXX11Attributes(MisplacedAttrs);
+  MaybeParseCXX11Attributes(MisplacedAttrs, AppertainsToDecl);
 
   if (InInitStatement && Tok.isNot(tok::identifier))
     return nullptr;
 
   UsingDeclarator D;
   bool InvalidDeclarator = ParseUsingDeclarator(Context, D);
 
   ParsedAttributesWithRange Attrs(AttrFactory);
-  MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs);
+  MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs, AppertainsToDecl);
 
   // 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)
         << FixItHint::CreateInsertionFromRange(
                Tok.getLocation(),
                CharSourceRange::getTokenRange(MisplacedAttrs.Range))
if (TemplateInfo.Kind) {
     // ignoring the parameters, just in case the nested name specifier
     // depends on the parameters.
     return nullptr;
   }
 
   SmallVector<Decl *, 8> DeclsInGroup;
   while (true) {
     // Parse (optional) attributes.
-    MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs);
+    MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs, AppertainsToDecl);
     DiagnoseCXX11AttributeExtension(Attrs);
     Attrs.addAll(PrefixAttrs.begin(), PrefixAttrs.end());
 
     if (InvalidDeclarator)
       SkipUntil(tok::comma, tok::semi, StopBeforeMatch);
     else {
       // "typename" keyword is allowed for identifiers only,
       // because it may be a type definition.
void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
   //   The usual access checking rules do not apply to names in a declaration
   //   of an explicit instantiation or explicit specialization...
   const bool shouldDelayDiagsInTag =
       (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate);
   SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
 
   ParsedAttributesWithRange attrs(AttrFactory);
   // If attributes exist after tag, parse them.
-  MaybeParseAttributes(PAKM_CXX11 | PAKM_Declspec | PAKM_GNU, attrs);
+  // TODO: I think this doesn't really work -- could be a type too.
+  MaybeParseAttributes(PAKM_CXX11 | PAKM_Declspec | PAKM_GNU, attrs,
+                       AppertainsToDecl);
 
   // Parse inheritance specifiers.
   if (Tok.isOneOf(tok::kw___single_inheritance,
                   tok::kw___multiple_inheritance,
                   tok::kw___virtual_inheritance))
     ParseMicrosoftInheritanceClassAttributes(attrs);
 
   // Allow attributes to precede or succeed the inheritance specifiers.
-  MaybeParseAttributes(PAKM_CXX11 | PAKM_Declspec | PAKM_GNU, attrs);
+  // TODO: I think this doesn't really work -- could be a type too.
+  MaybeParseAttributes(PAKM_CXX11 | PAKM_Declspec | PAKM_GNU, attrs,
+                       AppertainsToDecl);
 
   // Source location used by FIXIT to insert misplaced
   // C++11 attributes
   SourceLocation AttrFixitLoc = Tok.getLocation();
 
   if (TagType == DeclSpec::TST_struct &&
       Tok.isNot(tok::identifier) &&
       !Tok.isAnnotation() &&
void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
   // just references, e.g.
   //   new struct s;
   // or
   //   &T::operator struct s;
   // For these, DSC is DeclSpecContext::DSC_type_specifier or
   // DeclSpecContext::DSC_alias_declaration.
 
   // If there are attributes after class name, parse them.
-  MaybeParseCXX11Attributes(Attributes);
+  MaybeParseCXX11Attributes(Attributes, AppertainsToDecl);
 
   const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
   Sema::TagUseKind TUK;
   if (isDefiningTypeSpecifierContext(DSC) == AllowDefiningTypeSpec::No ||
       (getLangOpts().OpenMP && OpenMPDirectiveParsing))
     TUK = Sema::TUK_Reference;
   else if (Tok.is(tok::l_brace) ||
            (getLangOpts().CPlusPlus && Tok.is(tok::colon)) ||

 ///                 base-type-specifier
 ///         attribute-specifier-seq[opt] access-specifier 'virtual'[opt]
 ///                 base-type-specifier
 BaseResult Parser::ParseBaseSpecifier(Decl *ClassDecl) {
   bool IsVirtual = false;
   SourceLocation StartLoc = Tok.getLocation();
 
   ParsedAttributesWithRange Attributes(AttrFactory);
-  MaybeParseCXX11Attributes(Attributes);
+  MaybeParseCXX11Attributes(Attributes, AppertainsToDecl);
 
   // Parse the 'virtual' keyword.
   if (TryConsumeToken(tok::kw_virtual))
     IsVirtual = true;
 
   CheckMisplacedCXX11Attribute(Attributes, StartLoc);
 
   // Parse an (optional) access specifier.
if (Tok.is(tok::kw___extension__)) {
     ConsumeToken();
     return ParseCXXClassMemberDeclaration(AS, AccessAttrs,
                                           TemplateInfo, TemplateDiags);
   }
 
   ParsedAttributesWithRange attrs(AttrFactory);
   ParsedAttributesViewWithRange FnAttrs;
   // Optional C++11 attribute-specifier
-  MaybeParseCXX11Attributes(attrs);
+  MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
 
   // The next token may be an OpenMP pragma annotation token. That would
   // normally be handled from ParseCXXClassMemberDeclarationWithPragmas, but in
   // this case, it came from an *attribute* rather than a pragma. Handle it now.
   if (Tok.is(tok::annot_attr_openmp))
     return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, attrs);
 
   // We need to keep these attributes for future diagnostic
if (Attr.getMaxArgs() && !NumArgs) {
           << AttrName
           << FixItHint::CreateRemoval(SourceRange(LParenLoc, *EndLoc));
       Attr.setInvalid(true);
     }
   }
   return true;
 }
 
+void Parser::DiagnoseAppertainsTo(ParsedAttr &PA,
+                                  AttributeAppertainsTo appertainsTo) {
+  AttributeCommonInfo::Kind kind = PA.getKind();
+
+  if (kind == ParsedAttr::UnknownAttribute)
+    return;
+
+  switch (appertainsTo) {
+  case AppertainsToDecl:
+    if (!PA.getInfo().IsDecl && kind != ParsedAttr::AT_AddressSpace &&
+        kind != ParsedAttr::AT_CmseNSCall &&
+        kind != ParsedAttr::AT_OpenCLPrivateAddressSpace &&
+        kind != ParsedAttr::AT_OpenCLGlobalAddressSpace &&
+        kind != ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace &&
+        kind != ParsedAttr::AT_OpenCLGlobalHostAddressSpace &&
+        kind != ParsedAttr::AT_OpenCLLocalAddressSpace &&
+        kind != ParsedAttr::AT_OpenCLConstantAddressSpace &&
+        kind != ParsedAttr::AT_OpenCLGenericAddressSpace &&
+        kind != ParsedAttr::AT_NeonPolyVectorType &&
+        kind != ParsedAttr::AT_NeonVectorType &&
+        kind != ParsedAttr::AT_ArmSveVectorBits &&
+        kind != ParsedAttr::AT_ArmMveStrictPolymorphism &&
+        kind != ParsedAttr::AT_BTFTypeTag &&
+        kind != ParsedAttr::AT_TypeNonNull &&
+        kind != ParsedAttr::AT_TypeNullable &&
+        kind != ParsedAttr::AT_TypeNullableResult &&
+        kind != ParsedAttr::AT_TypeNullUnspecified &&
+        kind != ParsedAttr::AT_ObjCInertUnsafeUnretained &&
+        kind != ParsedAttr::AT_Regparm && kind != ParsedAttr::AT_NoDeref &&
+        kind != ParsedAttr::AT_ObjCGC && kind != ParsedAttr::AT_VectorSize &&
+        kind != ParsedAttr::AT_MatrixType && kind != ParsedAttr::AT_Ptr32 &&
+        kind != ParsedAttr::AT_Ptr64 && kind != ParsedAttr::AT_SPtr &&
+        kind != ParsedAttr::AT_UPtr) {
+      Diag(PA.getLoc(), diag::err_attribute_invalid_on_decl) << PA;
+      PA.setInvalid();
+    }
+    break;
+  case AppertainsToType:
+    if (!PA.getInfo().IsType) {
+      Diag(PA.getLoc(), diag::err_attribute_not_type_attr) << PA;
+      PA.setInvalid();
+    }
+    break;
+  case AppertainsToStmt:
+    if (!PA.getInfo().IsStmt) {
+      Diag(PA.getLoc(), diag::err_attribute_invalid_on_stmt) << PA;
+      PA.setInvalid();
+    }
+    break;
+  case AppertainsToUnknown:
+    // No checking
+    break;
+  }
+}
+
+void Parser::DiagnoseAppertainsTo(ParsedAttributesView &Attrs,
+                                  AttributeAppertainsTo appertainsTo) {
+  for (ParsedAttr &PA : Attrs) {
+    DiagnoseAppertainsTo(PA, appertainsTo);
+  }
+}
+
 /// ParseCXX11AttributeSpecifier - Parse a C++11 or C2x attribute-specifier.
 ///
 /// [C++11] attribute-specifier:
 ///         '[' '[' attribute-list ']' ']'
 ///         alignment-specifier
 ///
 /// [C++11] attribute-list:
 ///         attribute[opt]
 ///         attribute-list ',' attribute[opt]
 ///         attribute '...'
 ///         attribute-list ',' attribute '...'
 ///
 /// [C++11] attribute:
 ///         attribute-token attribute-argument-clause[opt]
 ///
 /// [C++11] attribute-token:
 ///         identifier
 ///         attribute-scoped-token
 ///
 /// [C++11] attribute-scoped-token:
 ///         attribute-namespace '::' identifier
 ///
 /// [C++11] attribute-namespace:
 ///         identifier
-void Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs,
-                                                  CachedTokens &OpenMPTokens,
-                                                  SourceLocation *EndLoc) {
+void Parser::ParseCXX11AttributeSpecifierInternal(
+    ParsedAttributes &Attrs, CachedTokens &OpenMPTokens,
+    AttributeAppertainsTo appertainsTo, SourceLocation *EndLoc) {
   if (Tok.is(tok::kw_alignas)) {
     Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas);
     ParseAlignmentSpecifier(Attrs, EndLoc);
     return;
   }
 
   assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square) &&
          "Not a double square bracket attribute list");
if (!CommonScopeName) {
       SkipUntil(tok::r_square, tok::colon, StopBeforeMatch);
     }
     if (!TryConsumeToken(tok::colon) && CommonScopeName)
       Diag(Tok.getLocation(), diag::err_expected) << tok::colon;
   }
 
   llvm::SmallDenseMap<IdentifierInfo*, SourceLocation, 4> SeenAttrs;
 
+  size_t NumAttributesExisting = Attrs.size();
+
   bool AttrParsed = false;
   while (!Tok.isOneOf(tok::r_square, tok::semi, tok::eof)) {
     if (AttrParsed) {
       // If we parsed an attribute, a comma is required before parsing any
       // additional attributes.
       if (ExpectAndConsume(tok::comma)) {
         SkipUntil(tok::r_square, StopAtSemi | StopBeforeMatch);
         continue;
if (!AttrParsed) {
       AttrParsed = true;
     }
 
     if (TryConsumeToken(tok::ellipsis))
       Diag(Tok, diag::err_cxx11_attribute_forbids_ellipsis)
         << AttrName;
   }
 
+  for (size_t i = NumAttributesExisting; i < Attrs.size(); ++i) {
+    DiagnoseAppertainsTo(Attrs[i], appertainsTo);
+  }
+
   // If we hit an error and recovered by parsing up to a semicolon, eat the
   // semicolon and don't issue further diagnostics about missing brackets.
   if (Tok.is(tok::semi)) {
     ConsumeToken();
     return;
   }
 
   SourceLocation CloseLoc = Tok.getLocation();
   if (ExpectAndConsume(tok::r_square))
     SkipUntil(tok::r_square);
   else if (Tok.is(tok::r_square))
     checkCompoundToken(CloseLoc, tok::r_square, CompoundToken::AttrEnd);
   if (EndLoc)
     *EndLoc = Tok.getLocation();
   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(ParsedAttributesWithRange &attrs) {
+void Parser::ParseCXX11Attributes(ParsedAttributesWithRange &attrs,
+                                  AttributeAppertainsTo appertainsTo) {
   assert(standardAttributesAllowed());
 
   SourceLocation StartLoc = Tok.getLocation();
   SourceLocation EndLoc = StartLoc;
 
   do {
-    ParseCXX11AttributeSpecifier(attrs, &EndLoc);
+    ParseCXX11AttributeSpecifier(attrs, appertainsTo, &EndLoc);
   } while (isCXX11AttributeSpecifier());
 
   attrs.Range = SourceRange(StartLoc, EndLoc);
 }
 
 void Parser::DiagnoseAndSkipCXX11Attributes() {
   // Start and end location of an attribute or an attribute list.
   SourceLocation StartLoc = Tok.getLocation();

clang/lib/Parse/ParseExprCXX.cpp

auto ParseLambdaSpecifiers =
       [&](SourceLocation LParenLoc, SourceLocation RParenLoc,
           MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo,
           SourceLocation EllipsisLoc) {
         SourceLocation DeclEndLoc = RParenLoc;
 
         // GNU-style attributes must be parsed before the mutable specifier to
         // be compatible with GCC. MSVC-style attributes must be parsed before
         // the mutable specifier to be compatible with MSVC.
-        MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr);
+        MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr, AppertainsToDecl);
 
         // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update
         // the DeclEndLoc.
         SourceLocation MutableLoc;
         SourceLocation ConstexprLoc;
         SourceLocation ConstevalLoc;
         tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc,
                                        ConstevalLoc, DeclEndLoc);
auto ParseLambdaSpecifiers =
         ESpecType = tryParseExceptionSpecification(
             /*Delayed=*/false, ESpecRange, DynamicExceptions,
             DynamicExceptionRanges, NoexceptExpr, ExceptionSpecTokens);
 
         if (ESpecType != EST_None)
           DeclEndLoc = ESpecRange.getEnd();
 
         // Parse attribute-specifier[opt].
-        if (MaybeParseCXX11Attributes(Attr))
+        // TODO: Correct?
+        if (MaybeParseCXX11Attributes(Attr, AppertainsToType))
           DeclEndLoc = Attr.Range.getEnd();
 
         // Parse OpenCL addr space attribute.
         if (Tok.isOneOf(tok::kw___private, tok::kw___global, tok::kw___local,
                         tok::kw___constant, tok::kw___generic)) {
           ParseOpenCLQualifiers(DS.getAttributes());
           ConsumeToken();
         }
Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc,
 
   if (Tok.is(tok::code_completion)) {
     cutOffParsing();
     Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
     return Sema::ConditionError();
   }
 
   ParsedAttributesWithRange attrs(AttrFactory);
-  MaybeParseCXX11Attributes(attrs);
+  MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
 
   const auto WarnOnInit = [this, &CK] {
     Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
                                 ? diag::warn_cxx14_compat_init_statement
                                 : diag::ext_init_statement)
         << (CK == Sema::ConditionKind::Switch);
   };
 
if (Size.isInvalid()) {
       return;
     }
     First = false;
 
     T.consumeClose();
 
     // Attributes here appertain to the array type. C++11 [expr.new]p5.
     ParsedAttributes Attrs(AttrFactory);
-    MaybeParseCXX11Attributes(Attrs);
+    MaybeParseCXX11Attributes(Attrs, AppertainsToType);
 
     D.AddTypeInfo(DeclaratorChunk::getArray(0,
                                             /*isStatic=*/false, /*isStar=*/false,
                                             Size.get(), T.getOpenLocation(),
                                             T.getCloseLocation()),
                   std::move(Attrs), T.getCloseLocation());
 
     if (T.getCloseLocation().isInvalid())

clang/lib/Parse/ParseObjc.cpp

Decl *Parser::ParseObjCMethodDecl(SourceLocation mLoc,
   ObjCDeclSpec DSRet;
   if (Tok.is(tok::l_paren))
     ReturnType =
         ParseObjCTypeName(DSRet, DeclaratorContext::ObjCResult, nullptr);
 
   // If attributes exist before the method, parse them.
   ParsedAttributes methodAttrs(AttrFactory);
   MaybeParseAttributes(PAKM_CXX11 | (getLangOpts().ObjC ? PAKM_GNU : 0),
-                       methodAttrs);
+                       methodAttrs, AppertainsToDecl);
 
   if (Tok.is(tok::code_completion)) {
     cutOffParsing();
     Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
                                        ReturnType);
     return nullptr;
   }
 
if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name.
     SkipUntil(tok::at, StopAtSemi | StopBeforeMatch);
     return nullptr;
   }
 
   SmallVector<DeclaratorChunk::ParamInfo, 8> CParamInfo;
   if (Tok.isNot(tok::colon)) {
     // If attributes exist after the method, parse them.
     MaybeParseAttributes(PAKM_CXX11 | (getLangOpts().ObjC ? PAKM_GNU : 0),
-                         methodAttrs);
+                         methodAttrs, AppertainsToDecl);
 
     Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent);
     Decl *Result = Actions.ActOnMethodDeclaration(
         getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType,
         selLoc, Sel, nullptr, CParamInfo.data(), CParamInfo.size(), methodAttrs,
         MethodImplKind, false, MethodDefinition);
     PD.complete(Result);
     return Result;
while (true) {
     ArgInfo.Type = nullptr;
     if (Tok.is(tok::l_paren)) // Parse the argument type if present.
       ArgInfo.Type = ParseObjCTypeName(
           ArgInfo.DeclSpec, DeclaratorContext::ObjCParameter, &paramAttrs);
 
     // If attributes exist before the argument name, parse them.
     // Regardless, collect all the attributes we've parsed so far.
     MaybeParseAttributes(PAKM_CXX11 | (getLangOpts().ObjC ? PAKM_GNU : 0),
-                         paramAttrs);
+                         paramAttrs, AppertainsToDecl);
     ArgInfo.ArgAttrs = paramAttrs;
 
     // Code completion for the next piece of the selector.
     if (Tok.is(tok::code_completion)) {
       cutOffParsing();
       KeyIdents.push_back(SelIdent);
       Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
                                                  mType == tok::minus,
CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
                                                     ParmDecl.getIdentifierLoc(),
                                                     Param,
                                                     nullptr));
   }
 
   // FIXME: Add support for optional parameter list...
   // If attributes exist after the method, parse them.
   MaybeParseAttributes(PAKM_CXX11 | (getLangOpts().ObjC ? PAKM_GNU : 0),
-                       methodAttrs);
+                       methodAttrs, AppertainsToDecl);
 
   if (KeyIdents.size() == 0)
     return nullptr;
 
   Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(),
                                                    &KeyIdents[0]);
   Decl *Result = Actions.ActOnMethodDeclaration(
       getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType, KeyLocs,
Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc,
   assert(ObjCImpDecl);
 
   SmallVector<Decl *, 8> DeclsInGroup;
 
   {
     ObjCImplParsingDataRAII ObjCImplParsing(*this, ObjCImpDecl);
     while (!ObjCImplParsing.isFinished() && !isEofOrEom()) {
       ParsedAttributesWithRange attrs(AttrFactory);
-      MaybeParseCXX11Attributes(attrs);
+      MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
       if (DeclGroupPtrTy DGP = ParseExternalDeclaration(attrs)) {
         DeclGroupRef DG = DGP.get();
         DeclsInGroup.append(DG.begin(), DG.end());
       }
     }
   }
 
   return Actions.ActOnFinishObjCImplementation(ObjCImpDecl, DeclsInGroup);

clang/lib/Parse/ParseOpenMP.cpp

case OMPD_declare_simd: {
     DeclGroupPtrTy Ptr;
     if (Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp)) {
       Ptr = ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs, Delayed,
                                                        TagType, Tag);
     } else if (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
       // Here we expect to see some function declaration.
       if (AS == AS_none) {
         assert(TagType == DeclSpec::TST_unspecified);
-        MaybeParseCXX11Attributes(Attrs);
+        MaybeParseCXX11Attributes(Attrs, AppertainsToDecl);
         ParsingDeclSpec PDS(*this);
         Ptr = ParseExternalDeclaration(Attrs, &PDS);
       } else {
         Ptr =
             ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag);
       }
     }
     if (!Ptr) {

clang/lib/Parse/ParsePragma.cpp

void Parser::HandlePragmaAttribute() {
 
   auto SkipToEnd = [this]() {
     SkipUntil(tok::eof, StopBeforeMatch);
     ConsumeToken();
   };
 
   if (Tok.is(tok::l_square) && NextToken().is(tok::l_square)) {
     // Parse the CXX11 style attribute.
-    ParseCXX11AttributeSpecifier(Attrs);
+    ParseCXX11AttributeSpecifier(Attrs, AppertainsToUnknown);
   } 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, "("))
       return SkipToEnd();
 

clang/lib/Parse/ParseStmt.cpp

Parser::ParseStatementOrDeclaration(StmtVector &Stmts,
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
 
   // Because we're parsing either a statement or a declaration, the order of
   // attribute parsing is important. [[]] attributes at the start of a
   // statement are different from [[]] attributes that follow an __attribute__
   // at the start of the statement. Thus, we're not using MaybeParseAttributes
   // here because we don't want to allow arbitrary orderings.
   ParsedAttributesWithRange Attrs(AttrFactory);
-  MaybeParseCXX11Attributes(Attrs, /*MightBeObjCMessageSend*/ true);
+  // TODO: Oops -- don't know what to pass here! So we need to be able to do
+  // either-or and then process this further in
+  // ParseStatementOrDeclarationAfterAttributes(). Phew, this is complicated.
+  MaybeParseCXX11Attributes(Attrs, AppertainsToUnknown,
+                            /*MightBeObjCMessageSend*/ true);
   if (getLangOpts().OpenCL)
     MaybeParseGNUAttributes(Attrs);
 
   StmtResult Res = ParseStatementOrDeclarationAfterAttributes(
       Stmts, StmtCtx, TrailingElseLoc, Attrs);
   MaybeDestroyTemplateIds();
 
   assert((Attrs.empty() || Res.isInvalid() || Res.isUsable()) &&
if ((getLangOpts().CPlusPlus || getLangOpts().MicrosoftExt ||
              ParsedStmtContext()) &&
         ((GNUAttributeLoc.isValid() &&
           !(!Attrs.empty() &&
             llvm::all_of(
                 Attrs, [](ParsedAttr &Attr) { return Attr.isStmtAttr(); }))) ||
          isDeclarationStatement())) {
       SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
       DeclGroupPtrTy Decl;
+      DiagnoseAppertainsTo(Attrs, AppertainsToDecl);
       if (GNUAttributeLoc.isValid()) {
         DeclStart = GNUAttributeLoc;
         Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, Attrs,
                                 &GNUAttributeLoc);
       } else {
         Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, Attrs);
       }
       if (Attrs.Range.getBegin().isValid())
if (Tok.isNot(tok::kw___extension__)) {
       // operator for expressions.  Consume multiple __extension__ markers here
       // until we can determine which is which.
       // FIXME: This loses extension expressions in the AST!
       SourceLocation ExtLoc = ConsumeToken();
       while (Tok.is(tok::kw___extension__))
         ConsumeToken();
 
       ParsedAttributesWithRange attrs(AttrFactory);
-      MaybeParseCXX11Attributes(attrs, /*MightBeObjCMessageSend*/ true);
+      MaybeParseCXX11Attributes(attrs, AppertainsToUnknown,
+                                /*MightBeObjCMessageSend*/ true);
 
       // If this is the start of a declaration, parse it as such.
       if (isDeclarationStatement()) {
         // __extension__ silences extension warnings in the subdeclaration.
         // FIXME: Save the __extension__ on the decl as a node somehow?
         ExtensionRAIIObject O(Diags);
 
         SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
if (Tok.is(tok::code_completion)) {
     cutOffParsing();
     Actions.CodeCompleteOrdinaryName(getCurScope(),
                                      C99orCXXorObjC? Sema::PCC_ForInit
                                                    : Sema::PCC_Expression);
     return StmtError();
   }
 
   ParsedAttributesWithRange attrs(AttrFactory);
-  MaybeParseCXX11Attributes(attrs);
+  MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
 
   SourceLocation EmptyInitStmtSemiLoc;
 
   // Parse the first part of the for specifier.
   if (Tok.is(tok::semi)) {  // for (;
     ProhibitAttributes(attrs);
     // no first part, eat the ';'.
     SourceLocation SemiLoc = Tok.getLocation();
     if (!Tok.hasLeadingEmptyMacro() && !SemiLoc.isMacroID())
       EmptyInitStmtSemiLoc = SemiLoc;
     ConsumeToken();
   } else if (getLangOpts().CPlusPlus && Tok.is(tok::identifier) &&
              isForRangeIdentifier()) {
     ProhibitAttributes(attrs);
     IdentifierInfo *Name = Tok.getIdentifierInfo();
     SourceLocation Loc = ConsumeToken();
-    MaybeParseCXX11Attributes(attrs);
+    MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
 
     ForRangeInfo.ColonLoc = ConsumeToken();
     if (Tok.is(tok::l_brace))
       ForRangeInfo.RangeExpr = ParseBraceInitializer();
     else
       ForRangeInfo.RangeExpr = ParseExpression();
 
     Diag(Loc, diag::err_for_range_identifier)
while (Tok.is(tok::annot_pragma_loop_hint)) {
     ArgsUnion ArgHints[] = {Hint.PragmaNameLoc, Hint.OptionLoc, Hint.StateLoc,
                             ArgsUnion(Hint.ValueExpr)};
     TempAttrs.addNew(Hint.PragmaNameLoc->Ident, Hint.Range, nullptr,
                      Hint.PragmaNameLoc->Loc, ArgHints, 4,
                      ParsedAttr::AS_Pragma);
   }
 
   // Get the next statement.
-  MaybeParseCXX11Attributes(Attrs);
+  MaybeParseCXX11Attributes(Attrs, AppertainsToUnknown);
 
   StmtResult S = ParseStatementOrDeclarationAfterAttributes(
       Stmts, StmtCtx, TrailingElseLoc, Attrs);
 
   Attrs.takeAllFrom(TempAttrs);
 
   // Start of attribute range may already be set for some invalid input.
   // See PR46336.
ParseScope CatchScope(this, Scope::DeclScope | Scope::ControlScope |
                                   Scope::CatchScope |
                                   (FnCatch ? Scope::FnTryCatchScope : 0));
 
   // exception-declaration is equivalent to '...' or a parameter-declaration
   // without default arguments.
   Decl *ExceptionDecl = nullptr;
   if (Tok.isNot(tok::ellipsis)) {
     ParsedAttributesWithRange Attributes(AttrFactory);
-    MaybeParseCXX11Attributes(Attributes);
+    MaybeParseCXX11Attributes(Attributes, AppertainsToDecl);
 
     DeclSpec DS(AttrFactory);
     DS.takeAttributesFrom(Attributes);
 
     if (ParseCXXTypeSpecifierSeq(DS))
       return StmtError();
 
     Declarator ExDecl(DS, DeclaratorContext::CXXCatch);

clang/lib/Parse/ParseTemplate.cpp

Decl *Parser::ParseSingleDeclarationAfterTemplate(
   if (Context == DeclaratorContext::Member) {
     // We are parsing a member template.
     ParseCXXClassMemberDeclaration(AS, AccessAttrs, TemplateInfo,
                                    &DiagsFromTParams);
     return nullptr;
   }
 
   ParsedAttributesWithRange prefixAttrs(AttrFactory);
-  MaybeParseCXX11Attributes(prefixAttrs);
+  MaybeParseCXX11Attributes(prefixAttrs, AppertainsToDecl);
 
   if (Tok.is(tok::kw_using)) {
     auto usingDeclPtr = ParseUsingDirectiveOrDeclaration(Context, TemplateInfo, DeclEnd,
                                                          prefixAttrs);
     if (!usingDeclPtr || !usingDeclPtr.get().isSingleDecl())
       return nullptr;
     return usingDeclPtr.get().getSingleDecl();
   }

clang/lib/Parse/Parser.cpp

case tok::identifier:
     }
     break;
 
   default:
     break;
   }
 
   ParsedAttributesWithRange attrs(AttrFactory);
-  MaybeParseCXX11Attributes(attrs);
+  MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
 
   Result = ParseExternalDeclaration(attrs);
   // An empty Result might mean a line with ';' or some parsing error, ignore
   // it.
   if (Result) {
     if (ImportState == Sema::ModuleImportState::FirstDecl)
       // First decl was not modular.
       ImportState = Sema::ModuleImportState::NotACXX20Module;
case IEB_Skip:
     Braces.skipToEnd();
     return;
   }
 
   // Parse the declarations.
   // FIXME: Support module import within __if_exists?
   while (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
     ParsedAttributesWithRange attrs(AttrFactory);
-    MaybeParseCXX11Attributes(attrs);
+    MaybeParseCXX11Attributes(attrs, AppertainsToDecl);
     DeclGroupPtrTy Result = ParseExternalDeclaration(attrs);
     if (Result && !getCurScope()->getParent())
       Actions.getASTConsumer().HandleTopLevelDecl(Result.get());
   }
   Braces.consumeClose();
 }
 
 /// Parse a declaration beginning with the 'module' keyword or C++20
if (!getLangOpts().CPlusPlusModules)
           << SourceRange(ColonLoc, Partition.back().second);
     // Recover by ignoring the partition name.
     else if (ParseModuleName(ModuleLoc, Partition, /*IsImport*/ false))
       return nullptr;
   }
 
   // We don't support any module attributes yet; just parse them and diagnose.
   ParsedAttributesWithRange Attrs(AttrFactory);
-  MaybeParseCXX11Attributes(Attrs);
+  MaybeParseCXX11Attributes(Attrs, AppertainsToDecl);
   ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr);
 
   ExpectAndConsumeSemi(diag::err_module_expected_semi);
 
   return Actions.ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path, Partition,
                                  ImportState);
 }
 
if (Tok.is(tok::header_name)) {
     else
       IsPartition = true;
   } else {
     if (ParseModuleName(ImportLoc, Path, /*IsImport*/ true))
       return nullptr;
   }
 
   ParsedAttributesWithRange Attrs(AttrFactory);
-  MaybeParseCXX11Attributes(Attrs);
+  MaybeParseCXX11Attributes(Attrs, AppertainsToDecl);
   // We don't support any module import attributes yet.
   ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr);
 
   if (PP.hadModuleLoaderFatalFailure()) {
     // With a fatal failure in the module loader, we abort parsing.
     cutOffParsing();
     return nullptr;
   }

clang/lib/Sema/SemaDeclAttr.cpp

default:
     if (!AL.isStmtAttr()) {
       // Type attributes are handled elsewhere; silently move on.
       assert(AL.isTypeAttr() && "Non-type attribute not handled");
       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 attributes in Attr.td that do not list any subjects.
-    S.Diag(AL.getLoc(), diag::err_stmt_attribute_invalid_on_decl)
+    S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
         << AL << D->getLocation();
     break;
   case ParsedAttr::AT_Interrupt:
     handleInterruptAttr(S, D, AL);
     break;
   case ParsedAttr::AT_X86ForceAlignArgPointer:
     handleX86ForceAlignArgPointerAttr(S, D, AL);
     break;

clang/lib/Sema/SemaStmtAttr.cpp

static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A,
   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)
+    S.Diag(A.getRange().getBegin(), diag::err_attribute_invalid_on_stmt)
         << A << St->getBeginLoc();
     return nullptr;
   }
 }
 
 void Sema::ProcessStmtAttributes(Stmt *S,
                                  const ParsedAttributesWithRange &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/test/Sema/annotate-type.c

void foo(float *[[clang::annotate_type("foo")]] a) {
 
   typedef int [[clang::annotate_type("bar")]] my_typedef;
 
   // GNU spelling is not supported
   int __attribute__((annotate_type("bar"))) y1;  // expected-warning {{unknown attribute 'annotate_type' ignored}}
   int *__attribute__((annotate_type("bar"))) y2; // expected-warning {{unknown attribute 'annotate_type' ignored}}
 
   // Various error cases
-  // FIXME: We would want to prohibit the attribute in the following location.
-  // However, Clang currently generally doesn't prohibit type-only C++11
-  // attributes on declarations. This should be fixed more generally.
-  [[clang::annotate_type("bar")]] int *z1;
+  [[clang::annotate_type("bar")]] int *z1; // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
   int *z2 [[clang::annotate_type("bar")]]; // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
   [[clang::annotate_type("bar")]]; // expected-error {{'annotate_type' attribute cannot be applied to a statement}}
   int *[[clang::annotate_type(1)]] z3; // expected-error {{'annotate_type' attribute requires a string}}
   int *[[clang::annotate_type()]] z4; // expected-error {{'annotate_type' attribute takes at least 1 argument}}
   int *[[clang::annotate_type]] z5; // expected-error {{'annotate_type' attribute takes at least 1 argument}}
   int *[[clang::annotate_type(some_function())]] z6; // expected-error {{'annotate_type' attribute requires a string}}
   int *[[clang::annotate_type("bar", some_function())]] z7; // expected-error {{'annotate_type' attribute requires parameter 1 to be a constant expression}} expected-note{{subexpression not valid in a constant expression}}
   int *[[clang::annotate_type("bar", z7)]] z8; // expected-error {{'annotate_type' attribute requires parameter 1 to be a constant expression}} expected-note{{subexpression not valid in a constant expression}}
   int *[[clang::annotate_type("bar", int)]] z9; // expected-error {{expected expression}}
 }
 // More error cases: Prohibit adding the attribute to declarations.
 // Different declarations hit different code paths, so they need separate tests.
-// FIXME: Clang currently generally doesn't prohibit type-only C++11
-// attributes on declarations.
-[[clang::annotate_type("bar")]] int *global;
-void g([[clang::annotate_type("bar")]] int);
+[[clang::annotate_type("bar")]] int *global; // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
+void g([[clang::annotate_type("bar")]] int); // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}

clang/test/SemaCXX/annotate-type.cpp

 // RUN: %clang_cc1 %s -std=c++17 -fsyntax-only -verify
 
 struct S1 {
   void f() [[clang::annotate_type("foo")]];
-  // FIXME: We would want to prohibit the attribute in the following location.
-  // However, Clang currently generally doesn't prohibit type-only C++11
-  // attributes on declarations. This should be fixed more generally.
-  [[clang::annotate_type("foo")]] void g();
+  [[clang::annotate_type("foo")]] void g(); // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
 };
 
 template <typename T1, typename T2> struct is_same {
   static constexpr bool value = false;
 };
 
 template <typename T1> struct is_same<T1, T1> {
   static constexpr bool value = true;

 void f3() {
   func_template<int [[clang::annotate_type()]]>(); // expected-error {{'annotate_type' attribute takes at least 1 argument}}
 }
 
 // More error cases: Prohibit adding the attribute to declarations.
 // Different declarations hit different code paths, so they need separate tests.
 // FIXME: Clang currently generally doesn't prohibit type-only C++11
 // attributes on declarations.
-namespace [[clang::annotate_type("foo")]] my_namespace {}
-struct [[clang::annotate_type("foo")]] S3{};
+namespace [[clang::annotate_type("foo")]] my_namespace {} // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
+struct [[clang::annotate_type("foo")]] S3{}; // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
 void f4() {
-  for ([[clang::annotate_type("foo")]] int i = 0; i < 42; ++i) {}
+  for ([[clang::annotate_type("foo")]] int i = 0; i < 42; ++i) {} // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
 }

clang/utils/TableGen/ClangAttrEmitter.cpp

static void GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
   assert(DeclSubjects.size() + StmtSubjects.size() == Subjects.size());
 
   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_stmt_attribute_invalid_on_decl)\n";
+      OS << "  S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)\n";
       OS << "    << AL << 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, ";
static void GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
   }
 
   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 << "  S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_stmt)\n";
       OS << "    << AL << 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";
for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
     OS << "    /*IsTargetSpecific=*/";
     OS << Attr.isSubClassOf("TargetSpecificAttr") << ",\n";
     OS << "    /*IsType=*/";
     OS << (Attr.isSubClassOf("TypeAttr") || Attr.isSubClassOf("DeclOrTypeAttr"))
        << ",\n";
     OS << "    /*IsStmt=*/";
     OS << (Attr.isSubClassOf("StmtAttr") || Attr.isSubClassOf("DeclOrStmtAttr"))
        << ",\n";
+    OS << "    /*IsDecl=*/";
+    OS << (!Attr.isSubClassOf("TypeAttr") && !Attr.isSubClassOf("StmtAttr"))
+       << ",\n";
     OS << "    /*IsKnownToGCC=*/";
     OS << IsKnownToGCC(Attr) << ",\n";
     OS << "    /*IsSupportedByPragmaAttribute=*/";
     OS << PragmaAttributeSupport.isAttributedSupported(*I->second) << ",\n";
     if (!Spellings.empty())
       OS << "    /*Spellings=*/" << I->first << "Spellings,\n";
     else
       OS << "    /*Spellings=*/{},\n";