[clang] [WIP] Reject non-declaration C++11 attributes on declarations.

[mboehme]

Summary

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

DRAFT -- do not review.

Clang has allowed this so far, transferring the attributes to the declaration's
type instead, as would be done for GNU syntax attributes. However, the C++
standard is clear that attributes in certain positions appertain to the
declaration, so we shouldn't allow type attributes in these positions.

For backwards compatibility, we only warn on non-declaration attributes that we
have historically allowed to be put on declarations. We only produce errors for
new non-declaration attributes.

Depends On D111548

[mboehme]

I'd like to mark this patch as a draft so that Herald doesn't keep adding reviewers -- but I'm not sure how?

[aaron.ballman]

In D124081#3461556, @mboehme wrote:

I'd like to mark this patch as a draft so that Herald doesn't keep adding reviewers -- but I'm not sure how?

In that case, I usually set the permissions on the review explicitly so that I'm the only one who can view the draft (but this means precommit CI won't run on it). Most often folks just add [WIP] to the title and reviewers know to ignore the review until the [WIP] is removed.

[mboehme]

In D124081#3461731, @aaron.ballman wrote:

In D124081#3461556, @mboehme wrote:

I'd like to mark this patch as a draft so that Herald doesn't keep adding reviewers -- but I'm not sure how?

In that case, I usually set the permissions on the review explicitly so that I'm the only one who can view the draft (but this means precommit CI won't run on it).

In this case, though, I want to be able to show the draft to others and discuss it with them. I guess this technique doesn't work for that?

Most often folks just add [WIP] to the title and reviewers know to ignore the review until the [WIP] is removed.

Ah -- thanks. I'll add [WIP[ then.

[aaron.ballman]

In D124081#3461742, @mboehme wrote:

In D124081#3461731, @aaron.ballman wrote:

In D124081#3461556, @mboehme wrote:

I'd like to mark this patch as a draft so that Herald doesn't keep adding reviewers -- but I'm not sure how?

In that case, I usually set the permissions on the review explicitly so that I'm the only one who can view the draft (but this means precommit CI won't run on it).

In this case, though, I want to be able to show the draft to others and discuss it with them. I guess this technique doesn't work for that?

FWIW, you can pick the specific list of folks you want to give permissions to if you know it's a limited group. (I've done this with Erich from time to time when I want a second set of eyes on an NFC change but don't want to bother the mailing lists with it.) However, it sounds to me like you want anyone to be able to come by and comment if they'd like while you're prepping the patch, so I'd stick with the [WIP] in the title like you've got.

[mboehme]

In D124081#3461761, @aaron.ballman wrote:

[snip]

However, it sounds to me like you want anyone to be able to come by and comment if they'd like while you're prepping the patch, so I'd stick with the [WIP] in the title like you've got.

Exactly. Thanks for the explanations!

[mboehme]

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

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/Parse/Parser.h

private:
   /// Diagnose and skip C++11 and C2x attributes that appear in syntactic
   /// locations where attributes are not allowed.
   void DiagnoseAndSkipCXX11Attributes();
 
   /// Emit warnings for C++11 and C2x attributes that are in a position that
   /// clang accepts as an extension.
   void DiagnoseCXX11AttributeExtension(ParsedAttributesWithRange &Attrs);
 
+  /// Emit diagnostics for C++11 and C2x attributes that aren't declaration
+  /// attributes.
+  /// Historically, we've allowed some pure type attributes to be applied to
+  /// declarations. For these, we emit only a warning. For all others, we emit
+  /// an error.
+  void DiagnoseCXX11NonDeclAttrs(ParsedAttributes &Attrs);
+
   /// Parses syntax-generic attribute arguments for attributes which are
   /// known to the implementation, and adds them to the given ParsedAttributes
   /// list with the given attribute syntax. Returns the number of arguments
   /// parsed for the attribute.
   unsigned
   ParseAttributeArgsCommon(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
                            ParsedAttributes &Attrs, SourceLocation *EndLoc,
                            IdentifierInfo *ScopeName, SourceLocation ScopeLoc,

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,

clang/lib/Parse/ParseDecl.cpp

 //===--- ParseDecl.cpp - 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 Declaration portions of the Parser interfaces.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Parse/Parser.h"
-#include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/PrettyDeclStackTrace.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Parse/ParseDiagnostic.h"
+#include "clang/Parse/Parser.h"
+#include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
+#include <unordered_set>
 
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // C99 6.7: Declarations.
 //===----------------------------------------------------------------------===//
 
 /// ParseTypeName

 
 void Parser::DiagnoseCXX11AttributeExtension(ParsedAttributesWithRange &Attrs) {
   for (const ParsedAttr &PA : Attrs) {
     if (PA.isCXX11Attribute() || PA.isC2xAttribute())
       Diag(PA.getLoc(), diag::ext_cxx11_attr_placement) << PA << PA.getRange();
   }
 }
 
+void Parser::DiagnoseCXX11NonDeclAttrs(ParsedAttributes &Attrs) {
+  for (ParsedAttr &PA : Attrs) {
+    if (!(PA.isCXX11Attribute() || PA.isC2xAttribute()))
+      continue;
+
+    if (PA.getInfo().IsDecl)
+      continue;
+
+    AttributeCommonInfo::Kind kind = PA.getKind();
+    if (kind == ParsedAttr::UnknownAttribute)
+      continue;
+
+    // Using unordered_set because we don't have DenseMapInfo for
+    // ParsedAttr::Kind.
+    static std::unordered_set<ParsedAttr::Kind> WarningOnlyAttrs = {
+        ParsedAttr::AT_AddressSpace,
+        ParsedAttr::AT_CmseNSCall,
+        ParsedAttr::AT_OpenCLPrivateAddressSpace,
+        ParsedAttr::AT_OpenCLGlobalAddressSpace,
+        ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace,
+        ParsedAttr::AT_OpenCLGlobalHostAddressSpace,
+        ParsedAttr::AT_OpenCLLocalAddressSpace,
+        ParsedAttr::AT_OpenCLConstantAddressSpace,
+        ParsedAttr::AT_OpenCLGenericAddressSpace,
+        ParsedAttr::AT_NeonPolyVectorType,
+        ParsedAttr::AT_NeonVectorType,
+        ParsedAttr::AT_ArmSveVectorBits,
+        ParsedAttr::AT_ArmMveStrictPolymorphism,
+        ParsedAttr::AT_BTFTypeTag,
+        ParsedAttr::AT_TypeNonNull,
+        ParsedAttr::AT_TypeNullable,
+        ParsedAttr::AT_TypeNullableResult,
+        ParsedAttr::AT_TypeNullUnspecified,
+        ParsedAttr::AT_ObjCInertUnsafeUnretained,
+        ParsedAttr::AT_Regparm,
+        ParsedAttr::AT_NoDeref,
+        ParsedAttr::AT_ObjCGC,
+        ParsedAttr::AT_VectorSize,
+        ParsedAttr::AT_MatrixType,
+        ParsedAttr::AT_Ptr32,
+        ParsedAttr::AT_Ptr64,
+        ParsedAttr::AT_SPtr,
+        ParsedAttr::AT_UPtr,
+    };
+
+    if (WarningOnlyAttrs.count(kind)) {
+      // FIXME: Emit a warning and change all affected tests to expect this
+      // warning.
+    } else {
+      Diag(PA.getLoc(), diag::err_type_attribute_invalid_on_decl) << PA;
+      PA.setInvalid();
+    }
+  }
+}
+
 // 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
 // variable.
 // This function moves attributes that should apply to the type off DS to Attrs.
 void Parser::stripTypeAttributesOffDeclSpec(ParsedAttributesWithRange &Attrs,
if (AnonRecord) {
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
   if (DeclSpecStart)
     DS.SetRangeStart(*DeclSpecStart);
 
+  DiagnoseCXX11NonDeclAttrs(Attrs);
   DS.takeAttributesFrom(Attrs);
   return ParseDeclGroup(DS, Context, &DeclEnd, FRI);
 }
 
 /// Returns true if this might be the start of a declarator, or a common typo
 /// for a declarator.
 bool Parser::MightBeDeclarator(DeclaratorContext Context) {
   switch (Tok.getKind()) {
if (Tok.is(tok::kw___extension__)) {
     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
     ConsumeToken();
     return ParseStructDeclaration(DS, FieldsCallback);
   }
 
   // Parse leading attributes.
   ParsedAttributesWithRange Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
+  DiagnoseCXX11NonDeclAttrs(Attrs);
   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)) {
do {
 
     // 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.
     // FIXME: If we can leave the attributes in the token stream somehow, we can
     // get rid of a parameter (FirstArgAttrs) and this statement. It might be
     // too much hassle.
     DS.takeAttributesFrom(FirstArgAttrs);
 
+    DiagnoseCXX11NonDeclAttrs(DS.getAttributes());
+
     ParseDeclarationSpecifiers(DS);
 
 
     // Parse the declarator.  This is "PrototypeContext" or
     // "LambdaExprParameterContext", because we must accept either
     // 'declarator' or 'abstract-declarator' here.
     Declarator ParmDeclarator(
         DS, DeclaratorCtx == DeclaratorContext::RequiresExpr

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.
if (!rBraceToken.is(tok::r_brace)) {
           << FixItHint::CreateInsertion(rBraceToken.getLocation(), RBraces);
     }
 
     // Warn about nested inline namespaces.
     if (FirstNestedInlineLoc.isValid())
       Diag(FirstNestedInlineLoc, diag::ext_inline_nested_namespace_definition);
   }
 
+  DiagnoseCXX11NonDeclAttrs(attrs);
+
   // If we're still good, complain about inline namespaces in non-C++0x now.
   if (InlineLoc.isValid())
     Diag(InlineLoc, getLangOpts().CPlusPlus11 ?
          diag::warn_cxx98_compat_inline_namespace : diag::ext_inline_namespace);
 
   // Enter a scope for the namespace.
   ParseScope NamespaceScope(this, Scope::DeclScope);
 
if (TemplateId) {
     // Don't pass down template parameter lists if this is just a tag
     // reference.  For example, we don't need the template parameters here:
     //   template <class T> class A *makeA(T t);
     MultiTemplateParamsArg TParams;
     if (TUK != Sema::TUK_Reference && TemplateParams)
       TParams =
         MultiTemplateParamsArg(&(*TemplateParams)[0], TemplateParams->size());
 
+    DiagnoseCXX11NonDeclAttrs(attrs);
+
     stripTypeAttributesOffDeclSpec(attrs, DS, TUK);
 
     // Declaration or definition of a class type
     TagOrTempResult = Actions.ActOnTag(
         getCurScope(), TagType, TUK, StartLoc, SS, Name, NameLoc, attrs, AS,
         DS.getModulePrivateSpecLoc(), TParams, Owned, IsDependent,
         SourceLocation(), false, clang::TypeResult(),
         DSC == DeclSpecContext::DSC_type_specifier,
Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
   }
 
   // Hold late-parsed attributes so we can attach a Decl to them later.
   LateParsedAttrList CommonLateParsedAttrs;
 
   // decl-specifier-seq:
   // Parse the common declaration-specifiers piece.
   ParsingDeclSpec DS(*this, TemplateDiags);
+  DiagnoseCXX11NonDeclAttrs(attrs);
   DS.takeAttributesFrom(attrs);
   if (MalformedTypeSpec)
     DS.SetTypeSpecError();
 
   // Turn off usual access checking for templates explicit specialization
   // and instantiation.
   // C++20 [temp.spec] 13.9/6.
   // This disables the access checking rules for member function template

clang/lib/Parse/ParseExprCXX.cpp

case ConditionOrInitStatement::Error:
     break;
   }
 
   // If this is a for loop, we're entering its condition.
   ForConditionScope.enter(/*IsConditionVariable=*/true);
 
   // type-specifier-seq
   DeclSpec DS(AttrFactory);
+  DiagnoseCXX11NonDeclAttrs(attrs);
   DS.takeAttributesFrom(attrs);
   ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_condition);
 
   // declarator
   Declarator DeclaratorInfo(DS, DeclaratorContext::Condition);
   ParseDeclarator(DeclaratorInfo);
 
   // simple-asm-expr[opt]

clang/lib/Parse/ParseStmt.cpp

StmtResult Parser::ParseCXXCatchBlock(bool FnCatch) {
   // 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);
 
     DeclSpec DS(AttrFactory);
+    DiagnoseCXX11NonDeclAttrs(Attributes);
     DS.takeAttributesFrom(Attributes);
 
     if (ParseCXXTypeSpecifierSeq(DS))
       return StmtError();
 
     Declarator ExDecl(DS, DeclaratorContext::CXXCatch);
     ParseDeclarator(ExDecl);
     ExceptionDecl = Actions.ActOnExceptionDeclarator(getCurScope(), ExDecl);

clang/lib/Parse/ParseTemplate.cpp

assert(!AnonRecord &&
            "Anonymous unions/structs should not be valid with template");
     DS.complete(Decl);
     return Decl;
   }
 
   // Move the attributes from the prefix into the DS.
   if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
     ProhibitAttributes(prefixAttrs);
-  else
+  else {
+    DiagnoseCXX11NonDeclAttrs(prefixAttrs);
     DS.takeAttributesFrom(prefixAttrs);
+  }
 
   // Parse the declarator.
   ParsingDeclarator DeclaratorInfo(*this, DS, (DeclaratorContext)Context);
   if (TemplateInfo.TemplateParams)
     DeclaratorInfo.setTemplateParameterLists(*TemplateInfo.TemplateParams);
 
   // Turn off usual access checking for template specializations and
   // instantiations.

clang/lib/Parse/Parser.cpp

if (Tok.is(tok::semi)) {
     DS.complete(TheDecl);
     if (AnonRecord) {
       Decl* decls[] = {AnonRecord, TheDecl};
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
+  DiagnoseCXX11NonDeclAttrs(attrs);
   DS.takeAttributesFrom(attrs);
 
   // ObjC2 allows prefix attributes on class interfaces and protocols.
   // FIXME: This still needs better diagnostics. We should only accept
   // attributes here, no types, etc.
   if (getLangOpts().ObjC && Tok.is(tok::at)) {
     SourceLocation AtLoc = ConsumeToken(); // the "@"
     if (!Tok.isObjCAtKeyword(tok::objc_interface) &&

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;

 // [[clang::annotate_type]] inside a template argument.
 template <typename Ty> void func_template();
 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

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";