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

[mboehme]

Summary

DRAFT -- do not review.

For backwards compatiblity, we emit only a warning instead of an error if the
attribute is one of the existing type attributes that we have historically
allowed to "slide" to the DeclSpec just as if it had been specified in GNU
syntax. (We will call these "legacy type attributes" below.)

The two high-level changes that achieve this are:

• We move any C++11 attributes (except legacy type attributes) that occur in the attribute-specifier-seq at the beginning of a simple-declaration (and other similar declarations) to Declarator::Attrs. This means that we treat them the same as if they had been placed after the declarator-id. (Justification below.)

• We make ProcessDeclAttribute emit an error if it sees any non-declaration attributes in C++11 syntax, except in the following cases:
  • If it is being called for attributes on a DeclSpec or DeclaratorChunk
  • If the attribute is a legacy type attribute (in which case we only emit a warning)

The standard justifies treating attributes at the beginning of a
simple-declaration and attributes after a declarator-id the same. Here are some
relevant parts of the standard:

• The attribute-specifier-seq at the beginning of a simple-declaration "appertains to each of the entities declared by the declarators of the init-declarator-list" (https://eel.is/c++draft/dcl.dcl#dcl.pre-3)

• "In the declaration for an entity, attributes appertaining to that entity can appear at the start of the declaration and after the declarator-id for that declaration." (https://eel.is/c++draft/dcl.dcl#dcl.pre-note-2)

• "The optional attribute-specifier-seq following a declarator-id appertains to the entity that is declared." (https://eel.is/c++draft/dcl.dcl#dcl.meaning.general-1)

The standard contains similar wording to that for a simple-declaration in other
similar types of declarations, for example:

• "The optional attribute-specifier-seq in a parameter-declaration appertains to the parameter." (https://eel.is/c++draft/dcl.fct#3)

• "The optional attribute-specifier-seq in an exception-declaration appertains to the parameter of the catch clause" (https://eel.is/c++draft/except.pre#1)

The new behavior is tested both on the newly added type attribute
annotate_type, for which we emit errors, and for the legacy type attribute
address_space (chosen somewhat randomly from the various legacy type
attributes), for which we emit warnings.

Depends On D111548

[mboehme]

Reuploaded because base revision changed.

[mboehme]

• Added warnings for "legacy" type attributes
• Added documentation
• Fixed TODOs in the code

[mboehme]

Simply code by replacing ExtractDefiniteDeclAttrs() function with SlideAttrsToDeclSpec(). This essentially inverts the logic: Instead of moving those attributes to a second list that should definitely remain on the declaration, we identify the attributes that should "slide" and move them directly to the DeclSpec. This obviates the need for an additional ParsedAttributes list and hence simplifies the callsites.

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

DeclGroupPtrTy ParseDeclaration(DeclaratorContext Context,
                                   SourceLocation *DeclSpecStart = nullptr);
   DeclGroupPtrTy
   ParseSimpleDeclaration(DeclaratorContext Context, SourceLocation &DeclEnd,
                          ParsedAttributes &Attrs, bool RequireSemi,
                          ForRangeInit *FRI = nullptr,
                          SourceLocation *DeclSpecStart = nullptr);
   bool MightBeDeclarator(DeclaratorContext Context);
   DeclGroupPtrTy ParseDeclGroup(ParsingDeclSpec &DS, DeclaratorContext Context,
+                                ParsedAttributes &Attrs,
                                 SourceLocation *DeclEnd = nullptr,
                                 ForRangeInit *FRI = nullptr);
   Decl *ParseDeclarationAfterDeclarator(Declarator &D,
                const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo());
   bool ParseAsmAttributesAfterDeclarator(Declarator &D);
   Decl *ParseDeclarationAfterDeclaratorAndAttributes(
       Declarator &D,
       const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
void CheckMisplacedCXX11Attribute(ParsedAttributes &Attrs,
     DiagnoseMisplacedCXX11Attribute(Attrs, CorrectLocation);
   }
   void DiagnoseMisplacedCXX11Attribute(ParsedAttributes &Attrs,
                                        SourceLocation CorrectLocation);
 
   void stripTypeAttributesOffDeclSpec(ParsedAttributes &Attrs, DeclSpec &DS,
                                       Sema::TagUseKind TUK);
 
+  /// TODO: Add documentation.
+  void ExtractDefiniteDeclAttrs(ParsedAttributes &Attrs,
+                                ParsedAttributes &DeclAttrs);
+
   // FixItLoc = possible correct location for the attributes
   void ProhibitAttributes(ParsedAttributes &Attrs,
                           SourceLocation FixItLoc = SourceLocation()) {
     if (Attrs.Range.isInvalid())
       return;
     DiagnoseProhibitedAttributes(Attrs.Range, FixItLoc);
     Attrs.clear();
   }

clang/include/clang/Parse/RAIIObjectsForParser.h

bool consumeClose() {
         LClose = (P.*Consumer)();
         return false;
       }
 
       return diagnoseMissingClose();
     }
     void skipToEnd();
   };
+
+  // TODO: Document and explain how this isn't actually a RAII object.
+  class AttributeLender {
+  public:
+    void Lend(ParsedAttributes &Attrs, Declarator &D) {
+      for (ParsedAttr &AL : Attrs) {
+        LentAttrs.push_back(&AL);
+      }
+      D.takeAttributes(Attrs);
+    }
+
+    void Return(ParsedAttributes &Attrs, Declarator &D) {
+      for (ParsedAttr *AL : LentAttrs) {
+        Attrs.takeOneFrom(D.getAttributes(), AL);
+      }
+      LentAttrs.clear();
+    }
+
+  private:
+    llvm::SmallVector<ParsedAttr *, 1> LentAttrs;
+  };
 } // end namespace clang
 
 #endif

clang/include/clang/Sema/ParsedAttr.h

public:
   bool appliesToDecl(const Decl *D, attr::SubjectMatchRule MatchRule) const;
   void getMatchRules(const LangOptions &LangOpts,
                      SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>>
                          &MatchRules) const;
   bool diagnoseLangOpts(class Sema &S) const;
   bool existsInTarget(const TargetInfo &Target) const;
   bool isKnownToGCC() const;
   bool isSupportedByPragmaAttribute() const;
+  // TODO: Document
+  bool slidesFromDeclToDeclSpec() const;
 
   /// If the parsed attribute has a semantic equivalent, and it would
   /// have a semantic Spelling enumeration (due to having semantically-distinct
   /// spelling variations), return the value of that semantic spelling. If the
   /// parsed attribute does not have a semantic equivalent, or would not have
   /// a Spelling enumeration, the value UINT_MAX is returned.
   unsigned getSemanticSpelling() const;
 

 
 public:
   SourceRange Range;
   bool empty() const { return AttrList.empty(); }
   SizeType size() const { return AttrList.size(); }
   ParsedAttr &operator[](SizeType pos) { return *AttrList[pos]; }
   const ParsedAttr &operator[](SizeType pos) const { return *AttrList[pos]; }
 
+  void updateRange() {
+    Range = SourceRange();
+    for (const ParsedAttr &PA : *this) {
+      if (Range.isInvalid()) {
+        Range = PA.getRange();
+        continue;
+      }
+      if (PA.getRange().getBegin() < Range.getBegin()) {
+        Range.setBegin(PA.getRange().getBegin());
+      }
+      if (PA.getRange().getEnd() > Range.getEnd()) {
+        Range.setEnd(PA.getRange().getEnd());
+      }
+    }
+  }
+
   void addAtEnd(ParsedAttr *newAttr) {
     assert(newAttr);
     AttrList.push_back(newAttr);
   }
 
   void remove(ParsedAttr *ToBeRemoved) {
     assert(is_contained(AttrList, ToBeRemoved) &&
            "Cannot remove attribute that isn't in the list");

clang/include/clang/Sema/Sema.h

public:
   // More parsing and symbol table subroutines.
 
   void ProcessPragmaWeak(Scope *S, Decl *D);
   // Decl attributes - this routine is the top level dispatcher.
   void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
   // Helper for delayed processing of attributes.
   void ProcessDeclAttributeDelayed(Decl *D,
                                    const ParsedAttributesView &AttrList);
-  void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,
-                             bool IncludeCXX11Attributes = true);
+  struct ProcessDeclAttributeOptions {
+    ProcessDeclAttributeOptions()
+        : IncludeCXX11Attributes(true), IgnoreTypeAttributes(false) {}
+    ProcessDeclAttributeOptions WithIncludeCXX11Attributes(bool Val) {
+      ProcessDeclAttributeOptions Result = *this;
+      Result.IncludeCXX11Attributes = Val;
+      return Result;
+    }
+    ProcessDeclAttributeOptions WithIgnoreTypeAttributes(bool Val) {
+      ProcessDeclAttributeOptions Result = *this;
+      Result.IgnoreTypeAttributes = Val;
+      return Result;
+    }
+    bool IncludeCXX11Attributes;
+    bool IgnoreTypeAttributes;
+  };
+  void ProcessDeclAttributeList(Scope *S, Decl *D,
+                                const ParsedAttributesView &AL,
+                                const ProcessDeclAttributeOptions &Options =
+                                    ProcessDeclAttributeOptions());
   bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
                                    const ParsedAttributesView &AttrList);
 
   void checkUnusedDeclAttributes(Declarator &D);
 
   /// Handles semantic checking for features that are common to all attributes,
   /// such as checking whether a parameter was properly specified, or the
   /// correct number of arguments were passed, etc. Returns true if the

clang/lib/Parse/ParseDecl.cpp

void Parser::stripTypeAttributesOffDeclSpec(ParsedAttributes &Attrs,
   }
 
   for (ParsedAttr *AL : ToBeMoved) {
     DS.getAttributes().remove(AL);
     Attrs.addAtEnd(AL);
   }
 }
 
+// TODO: Documentation
+void Parser::ExtractDefiniteDeclAttrs(ParsedAttributes &Attrs,
+                                      ParsedAttributes &DeclAttrs) {
+  llvm::SmallVector<ParsedAttr *, 1> ToBeMoved;
+  for (ParsedAttr &AL : Attrs) {
+    if (!AL.slidesFromDeclToDeclSpec()) {
+      ToBeMoved.push_back(&AL);
+    }
+  }
+  for (ParsedAttr *AL : ToBeMoved) {
+    DeclAttrs.takeOneFrom(Attrs, AL);
+  }
+}
+
 /// ParseDeclaration - Parse a full 'declaration', which consists of
 /// declaration-specifiers, some number of declarators, and a semicolon.
 /// 'Context' should be a DeclaratorContext value.  This returns the
 /// location of the semicolon in DeclEnd.
 ///
 ///       declaration: [C99 6.7]
 ///         block-declaration ->
 ///           simple-declaration
if (AnonRecord) {
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
   if (DeclSpecStart)
     DS.SetRangeStart(*DeclSpecStart);
 
+  ParsedAttributes DeclAttrs(AttrFactory);
+  ExtractDefiniteDeclAttrs(Attrs, DeclAttrs);
   DS.takeAttributesFrom(Attrs);
-  return ParseDeclGroup(DS, Context, &DeclEnd, FRI);
+  return ParseDeclGroup(DS, Context, DeclAttrs, &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()) {
   case tok::annot_cxxscope:
   case tok::annot_template_id:
void Parser::SkipMalformedDecl() {
   }
 }
 
 /// ParseDeclGroup - Having concluded that this is either a function
 /// definition or a group of object declarations, actually parse the
 /// result.
 Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
                                               DeclaratorContext Context,
+                                              ParsedAttributes &Attrs,
                                               SourceLocation *DeclEnd,
                                               ForRangeInit *FRI) {
   // Parse the first declarator.
   ParsingDeclarator D(*this, DS, Context);
+  AttributeLender AttrLender;
+  AttrLender.Lend(Attrs, D);
   ParseDeclarator(D);
 
   // Bail out if the first declarator didn't seem well-formed.
   if (!D.hasName() && !D.mayOmitIdentifier()) {
     SkipMalformedDecl();
     return nullptr;
   }
 
if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) {
       // semicolon.
       Diag(CommaLoc, diag::err_expected_semi_declaration)
         << FixItHint::CreateReplacement(CommaLoc, ";");
       ExpectSemi = false;
       break;
     }
 
     // Parse the next declarator.
+    AttrLender.Return(Attrs, D);
     D.clear();
+    AttrLender.Lend(Attrs, D);
     D.setCommaLoc(CommaLoc);
 
     // Accept attributes in an init-declarator.  In the first declarator in a
     // declaration, these would be part of the declspec.  In subsequent
     // declarators, they become part of the declarator itself, so that they
     // don't apply to declarators after *this* one.  Examples:
     //    short __attribute__((common)) var;    -> declspec
     //    short var __attribute__((common));    -> declarator
if (Tok.is(tok::kw___extension__)) {
     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
     ConsumeToken();
     return ParseStructDeclaration(DS, FieldsCallback);
   }
 
   // Parse leading attributes.
   ParsedAttributes Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
+  ParsedAttributes DeclAttrs(AttrFactory);
+  ExtractDefiniteDeclAttrs(Attrs, DeclAttrs);
   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)) {
     RecordDecl *AnonRecord = nullptr;
+    // TODO: Pass on DeclAttrs
     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
                                                        DS, AnonRecord);
     assert(!AnonRecord && "Did not expect anonymous struct or union here");
     DS.complete(TheDecl);
     return;
   }
 
   // Read struct-declarators until we find the semicolon.
   bool FirstDeclarator = true;
   SourceLocation CommaLoc;
   while (true) {
     ParsingFieldDeclarator DeclaratorInfo(*this, DS);
+    AttributeLender AttrLender;
+    AttrLender.Lend(DeclAttrs, DeclaratorInfo.D);
     DeclaratorInfo.D.setCommaLoc(CommaLoc);
 
     // Attributes are only allowed here on successive declarators.
     if (!FirstDeclarator) {
       // However, this does not apply for [[]] attributes (which could show up
       // before or after the __attribute__ attributes).
       DiagnoseAndSkipCXX11Attributes();
       MaybeParseGNUAttributes(DeclaratorInfo.D);
while (true) {
     FieldsCallback(DeclaratorInfo);
 
     // If we don't have a comma, it is either the end of the list (a ';')
     // or an error, bail out.
     if (!TryConsumeToken(tok::comma, CommaLoc))
       return;
 
     FirstDeclarator = false;
+
+    AttrLender.Return(DeclAttrs, DeclaratorInfo.D);
   }
 }
 
 /// ParseStructUnionBody
 ///       struct-contents:
 ///         struct-declaration-list
 /// [EXT]   empty
 /// [GNU]   "struct-declaration-list" without terminating ';'
do {
     // before deciding this was a parameter-declaration-clause.
     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());
-
-    // Skip any Microsoft attributes before a param.
-    MaybeParseMicrosoftAttributes(DS.getAttributes());
-
-    SourceLocation DSStart = Tok.getLocation();
+    ParsedAttributes ArgAttrs(AttrFactory);
 
     // 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);
+    ArgAttrs.takeAllFrom(FirstArgAttrs);
+
+    // Parse any C++11 attributes.
+    MaybeParseCXX11Attributes(ArgAttrs);
+
+    // Skip any Microsoft attributes before a param.
+    MaybeParseMicrosoftAttributes(ArgAttrs);
+
+    ParsedAttributes DeclAttrs(AttrFactory);
+    ExtractDefiniteDeclAttrs(ArgAttrs, DeclAttrs);
+    DS.takeAttributesFrom(ArgAttrs);
+
+    SourceLocation DSStart = Tok.getLocation();
 
     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
                 ? DeclaratorContext::RequiresExpr
                 : DeclaratorCtx == DeclaratorContext::LambdaExpr
                       ? DeclaratorContext::LambdaExprParameter
                       : DeclaratorContext::Prototype);
+    ParmDeclarator.takeAttributes(DeclAttrs);
     ParseDeclarator(ParmDeclarator);
 
     // Parse GNU attributes, if present.
     MaybeParseGNUAttributes(ParmDeclarator);
     MaybeParseHLSLSemantics(DS.getAttributes());
 
     if (Tok.is(tok::kw_requires)) {
       // User tried to define a requires clause in a parameter declaration,

clang/lib/Parse/ParseDeclCXX.cpp

Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
   MaybeParseCXX11Attributes(attrs);
 
   // 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
-  // before they are taken over by declaration specifier.
-  FnAttrs.addAll(attrs.begin(), attrs.end());
-  FnAttrs.Range = attrs.Range;
-
   MaybeParseMicrosoftAttributes(attrs);
 
   if (Tok.is(tok::kw_using)) {
     // Eat 'using'.
     SourceLocation UsingLoc = ConsumeToken();
 
     // Consume unexpected 'template' keywords.
     while (Tok.is(tok::kw_template)) {
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);
+  ParsedAttributes DeclAttrs(AttrFactory);
+  ExtractDefiniteDeclAttrs(attrs, DeclAttrs);
+
+  // We need to keep these attributes for future diagnostic
+  // before they are taken over by declaration specifier.
+  FnAttrs.addAll(attrs.begin(), attrs.end());
+  // TODO: Explain the reason for this.
+  if (DeclAttrs.empty()) {
+    FnAttrs.Range = attrs.Range;
+  } else {
+    FnAttrs.updateRange();
+  }
+
   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
if (TryConsumeToken(tok::semi)) {
     if (AnonRecord) {
       Decl* decls[] = {AnonRecord, TheDecl};
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
   ParsingDeclarator DeclaratorInfo(*this, DS, DeclaratorContext::Member);
+  AttributeLender AttrLender;
+  AttrLender.Lend(DeclAttrs, DeclaratorInfo);
   if (TemplateInfo.TemplateParams)
     DeclaratorInfo.setTemplateParameterLists(TemplateParams);
   VirtSpecifiers VS;
 
   // Hold late-parsed attributes so we can attach a Decl to them later.
   LateParsedAttrList LateParsedAttrs;
 
   SourceLocation EqualLoc;
if (Tok.isAtStartOfLine() &&
       // semicolon.
       Diag(CommaLoc, diag::err_expected_semi_declaration)
         << FixItHint::CreateReplacement(CommaLoc, ";");
       ExpectSemi = false;
       break;
     }
 
     // Parse the next declarator.
+    AttrLender.Return(DeclAttrs, DeclaratorInfo);
     DeclaratorInfo.clear();
+    AttrLender.Lend(DeclAttrs, DeclaratorInfo);
     VS.clear();
     BitfieldSize = ExprResult(/*Invalid=*/false);
     EqualLoc = PureSpecLoc = SourceLocation();
     DeclaratorInfo.setCommaLoc(CommaLoc);
 
     // GNU attributes are allowed before the second and subsequent declarator.
     // However, this does not apply for [[]] attributes (which could show up
     // before or after the __attribute__ attributes).

clang/lib/Parse/ParseExprCXX.cpp

Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc,
   case ConditionOrInitStatement::ConditionDecl:
   case ConditionOrInitStatement::Error:
     break;
   }
 
   // If this is a for loop, we're entering its condition.
   ForConditionScope.enter(/*IsConditionVariable=*/true);
 
+  ParsedAttributes DeclAttrs(AttrFactory);
+  ExtractDefiniteDeclAttrs(attrs, DeclAttrs);
+
   // type-specifier-seq
   DeclSpec DS(AttrFactory);
   DS.takeAttributesFrom(attrs);
   ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_condition);
 
   // declarator
   Declarator DeclaratorInfo(DS, DeclaratorContext::Condition);
+  DeclaratorInfo.takeAttributes(DeclAttrs);
   ParseDeclarator(DeclaratorInfo);
 
   // simple-asm-expr[opt]
   if (Tok.is(tok::kw_asm)) {
     SourceLocation Loc;
     ExprResult AsmLabel(ParseSimpleAsm(/*ForAsmLabel*/ true, &Loc));
     if (AsmLabel.isInvalid()) {
       SkipUntil(tok::semi, StopAtSemi);

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)) {
     ParsedAttributes Attributes(AttrFactory);
     MaybeParseCXX11Attributes(Attributes);
 
+    ParsedAttributes DeclAttrs(AttrFactory);
+    ExtractDefiniteDeclAttrs(Attributes, DeclAttrs);
+
     DeclSpec DS(AttrFactory);
     DS.takeAttributesFrom(Attributes);
 
     if (ParseCXXTypeSpecifierSeq(DS))
       return StmtError();
 
     Declarator ExDecl(DS, DeclaratorContext::CXXCatch);
+    ExDecl.takeAttributes(DeclAttrs);
     ParseDeclarator(ExDecl);
     ExceptionDecl = Actions.ActOnExceptionDeclarator(getCurScope(), ExDecl);
   } else
     ConsumeToken();
 
   T.consumeClose();
   if (T.getCloseLocation().isInvalid())
     return StmtError();

clang/lib/Parse/ParseTemplate.cpp

Decl *Decl = Actions.ParsedFreeStandingDeclSpec(
         TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation,
         AnonRecord);
     assert(!AnonRecord &&
            "Anonymous unions/structs should not be valid with template");
     DS.complete(Decl);
     return Decl;
   }
 
+  ParsedAttributes DeclAttrs(AttrFactory);
+  ExtractDefiniteDeclAttrs(prefixAttrs, DeclAttrs);
+
   // Move the attributes from the prefix into the DS.
   if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
     ProhibitAttributes(prefixAttrs);
   else
     DS.takeAttributesFrom(prefixAttrs);
 
   // Parse the declarator.
   ParsingDeclarator DeclaratorInfo(*this, DS, (DeclaratorContext)Context);
+  DeclaratorInfo.takeAttributes(DeclAttrs);
   if (TemplateInfo.TemplateParams)
     DeclaratorInfo.setTemplateParameterLists(*TemplateInfo.TemplateParams);
 
   // Turn off usual access checking for template specializations and
   // instantiations.
   // C++20 [temp.spec] 13.9/6.
   // This disables the access checking rules for function template explicit
   // instantiation and explicit specialization:

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);
   }
 
+  ParsedAttributes DeclAttrs(AttrFactory);
+  ExtractDefiniteDeclAttrs(Attrs, DeclAttrs);
   DS.takeAttributesFrom(Attrs);
 
+  // TODO: Plumb attributes through to here?
   // 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) &&
         !Tok.isObjCAtKeyword(tok::objc_protocol) &&
         !Tok.isObjCAtKeyword(tok::objc_implementation)) {
if (getLangOpts().ObjC && Tok.is(tok::at)) {
 
     if (Tok.isObjCAtKeyword(tok::objc_implementation))
       return ParseObjCAtImplementationDeclaration(AtLoc, DS.getAttributes());
 
     return Actions.ConvertDeclToDeclGroup(
             ParseObjCAtInterfaceDeclaration(AtLoc, DS.getAttributes()));
   }
 
+  // TODO: Plumb attributes through to here?
   // If the declspec consisted only of 'extern' and we have a string
   // literal following it, this must be a C++ linkage specifier like
   // 'extern "C"'.
   if (getLangOpts().CPlusPlus && isTokenStringLiteral() &&
       DS.getStorageClassSpec() == DeclSpec::SCS_extern &&
       DS.getParsedSpecifiers() == DeclSpec::PQ_StorageClassSpecifier) {
     Decl *TheDecl = ParseLinkage(DS, DeclaratorContext::File);
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
-  return ParseDeclGroup(DS, DeclaratorContext::File);
+  return ParseDeclGroup(DS, DeclaratorContext::File, DeclAttrs);
 }
 
 Parser::DeclGroupPtrTy Parser::ParseDeclarationOrFunctionDefinition(
     ParsedAttributes &Attrs, ParsingDeclSpec *DS, AccessSpecifier AS) {
   if (DS) {
     return ParseDeclOrFunctionDefInternal(Attrs, *DS, AS);
   } else {
     ParsingDeclSpec PDS(*this);

clang/lib/Sema/ParsedAttr.cpp

 }
 
 bool ParsedAttr::isKnownToGCC() const { return getInfo().IsKnownToGCC; }
 
 bool ParsedAttr::isSupportedByPragmaAttribute() const {
   return getInfo().IsSupportedByPragmaAttribute;
 }
 
+bool ParsedAttr::slidesFromDeclToDeclSpec() const {
+  if (!isStandardAttributeSyntax())
+    return true;
+
+  // TODO: Document that these are due to legacy behavior.
+  switch (getParsedKind()) {
+  case AT_AddressSpace:
+  case AT_CmseNSCall:
+  case AT_OpenCLPrivateAddressSpace:
+  case AT_OpenCLGlobalAddressSpace:
+  case AT_OpenCLGlobalDeviceAddressSpace:
+  case AT_OpenCLGlobalHostAddressSpace:
+  case AT_OpenCLLocalAddressSpace:
+  case AT_OpenCLConstantAddressSpace:
+  case AT_OpenCLGenericAddressSpace:
+  case AT_NeonPolyVectorType:
+  case AT_NeonVectorType:
+  case AT_ArmSveVectorBits:
+  case AT_ArmMveStrictPolymorphism:
+  case AT_BTFTypeTag:
+  case AT_TypeNonNull:
+  case AT_TypeNullable:
+  case AT_TypeNullableResult:
+  case AT_TypeNullUnspecified:
+  case AT_ObjCInertUnsafeUnretained:
+  case AT_Regparm:
+  case AT_NoDeref:
+  case AT_ObjCGC:
+  case AT_VectorSize:
+  case AT_MatrixType:
+  case AT_Ptr32:
+  case AT_Ptr64:
+  case AT_SPtr:
+  case AT_UPtr:
+    return true;
+  default:
+    return false;
+  }
+}
+
 bool ParsedAttr::acceptsExprPack() const { return getInfo().AcceptsExprPack; }
 
 unsigned ParsedAttr::getSemanticSpelling() const {
   return getInfo().spellingIndexToSemanticSpelling(*this);
 }
 
 bool ParsedAttr::hasVariadicArg() const {
   // If the attribute has the maximum number of optional arguments, we will

clang/lib/Sema/SemaDeclAttr.cpp

if (E->isValueDependent() && !ArgMemberCanHoldExpr)
       return true;
   }
   return false;
 }
 
 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
 /// the attribute applies to decls.  If the attribute is a type attribute, just
 /// silently ignore it if a GNU attribute.
-static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
-                                 const ParsedAttr &AL,
-                                 bool IncludeCXX11Attributes) {
+static void
+ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
+                     const Sema::ProcessDeclAttributeOptions &Options) {
   if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
     return;
 
   // Ignore C++11 attributes on declarator chunks: they appertain to the type
   // instead.
-  if (AL.isCXX11Attribute() && !IncludeCXX11Attributes)
+  if (AL.isCXX11Attribute() && !Options.IncludeCXX11Attributes)
     return;
 
   // Unknown attributes are automatically warned on. Target-specific attributes
   // which do not apply to the current target architecture are treated as
   // though they were unknown attributes.
   if (AL.getKind() == ParsedAttr::UnknownAttribute ||
       !AL.existsInTarget(S.Context.getTargetInfo())) {
     S.Diag(AL.getLoc(),
if (MustDelayArgs) {
     return;
   }
 
   switch (AL.getKind()) {
   default:
     if (AL.getInfo().handleDeclAttribute(S, D, AL) != ParsedAttrInfo::NotHandled)
       break;
     if (!AL.isStmtAttr()) {
-      // Type attributes are handled elsewhere; silently move on.
       assert(AL.isTypeAttr() && "Non-type attribute not handled");
+    }
+    if (AL.isTypeAttr()) {
+      if (Options.IgnoreTypeAttributes)
+        break;
+      if (AL.slidesFromDeclToDeclSpec()) {
+        if (AL.isStandardAttributeSyntax()) {
+          // TODO: We're looking at one of a number of type attributes that we
+          // have historically allowed to be applied to a declaration in C++11
+          // syntax, "sliding" them to the DeclSpec. Emit a warning that type
+          // attributes aren't allowed in this position.
+        }
+        // GNU type attributes are handled elsewhere; silently move on.
         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)
         << AL << D->getLocation();
     break;
   case ParsedAttr::AT_Interrupt:
     handleInterruptAttr(S, D, AL);
ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
   case ParsedAttr::AT_UsingIfExists:
     handleSimpleAttribute<UsingIfExistsAttr>(S, D, AL);
     break;
   }
 }
 
 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
 /// attribute list to the specified decl, ignoring any type attributes.
-void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
-                                    const ParsedAttributesView &AttrList,
-                                    bool IncludeCXX11Attributes) {
+void Sema::ProcessDeclAttributeList(
+    Scope *S, Decl *D, const ParsedAttributesView &AttrList,
+    const ProcessDeclAttributeOptions &Options) {
   if (AttrList.empty())
     return;
 
   for (const ParsedAttr &AL : AttrList)
-    ProcessDeclAttribute(*this, S, D, AL, IncludeCXX11Attributes);
+    ProcessDeclAttribute(*this, S, D, AL, Options);
 
   // FIXME: We should be able to handle these cases in TableGen.
   // GCC accepts
   // static int a9 __attribute__((weakref));
   // but that looks really pointless. We reject it.
   if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
     Diag(AttrList.begin()->getLoc(), diag::err_attribute_weakref_without_alias)
         << cast<NamedDecl>(D);

 }
 
 // Annotation attributes are the only attributes allowed after an access
 // specifier.
 bool Sema::ProcessAccessDeclAttributeList(
     AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList) {
   for (const ParsedAttr &AL : AttrList) {
     if (AL.getKind() == ParsedAttr::AT_Annotate) {
-      ProcessDeclAttribute(*this, nullptr, ASDecl, AL, AL.isCXX11Attribute());
+      ProcessDeclAttributeOptions Options;
+      Options.IncludeCXX11Attributes = AL.isCXX11Attribute();
+      ProcessDeclAttribute(*this, nullptr, ASDecl, AL, Options);
     } else {
       Diag(AL.getLoc(), diag::err_only_annotate_after_access_spec);
       return true;
     }
   }
   return false;
 }
 
void Sema::ProcessPragmaWeak(Scope *S, Decl *D) {
   }
 }
 
 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
 /// it, apply them to D.  This is a bit tricky because PD can have attributes
 /// specified in many different places, and we need to find and apply them all.
 void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
   // Apply decl attributes from the DeclSpec if present.
-  if (!PD.getDeclSpec().getAttributes().empty())
-    ProcessDeclAttributeList(S, D, PD.getDeclSpec().getAttributes());
+  if (!PD.getDeclSpec().getAttributes().empty()) {
+    ProcessDeclAttributeList(
+        S, D, PD.getDeclSpec().getAttributes(),
+        ProcessDeclAttributeOptions().WithIgnoreTypeAttributes(true));
+  }
 
   // Walk the declarator structure, applying decl attributes that were in a type
   // position to the decl itself.  This handles cases like:
   //   int *__attr__(x)** D;
   // when X is a decl attribute.
-  for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
+  for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i) {
     ProcessDeclAttributeList(S, D, PD.getTypeObject(i).getAttrs(),
-                             /*IncludeCXX11Attributes=*/false);
+                             ProcessDeclAttributeOptions()
+                                 .WithIncludeCXX11Attributes(false)
+                                 .WithIgnoreTypeAttributes(true));
+  }
 
   // Finally, apply any attributes on the decl itself.
   ProcessDeclAttributeList(S, D, PD.getAttributes());
 
   // Apply additional attributes specified by '#pragma clang attribute'.
   AddPragmaAttributes(S, D);
 }
 

clang/lib/Sema/SemaType.cpp

case ParsedAttr::AT_AcquireHandle: {
         return;
       type = state.getAttributedType(
           AcquireHandleAttr::Create(state.getSema().Context, HandleType, attr),
           type, type);
       attr.setUsedAsTypeAttr();
       break;
     }
     case ParsedAttr::AT_AnnotateType: {
-      if (TAL == TAL_DeclName) {
-        state.getSema().Diag(attr.getLoc(),
-                             diag::err_type_attribute_invalid_on_decl)
-            << attr;
-        return;
-      }
-
       HandleAnnotateTypeAttr(state, type, attr);
       attr.setUsedAsTypeAttr();
       break;
     }
     }
 
     // Handle attributes that are defined in a macro. We do not want this to be
     // applied to ObjC builtin attributes.

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}}
+[[clang::annotate_type("bar")]] void annotated_function(); // 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
+// RUN: %clang_cc1 %s -std=c++17 -fsyntax-only -fcxx-exceptions -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 {
+} // namespace my_namespace
+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) {
+  } // expected-error {{'annotate_type' attribute cannot be applied to a
+    // declaration}}
+  for (; [[clang::annotate_type("foo")]] bool b = false;) {
+  } // expected-error {{'annotate_type' attribute cannot be applied to a
+    // declaration}}
+  while ([[clang::annotate_type("foo")]] bool b = false) {
+  } // expected-error {{'annotate_type' attribute cannot be applied to a
+    // declaration}}
+  if ([[clang::annotate_type("foo")]] bool b = false) {
+  } // expected-error {{'annotate_type' attribute cannot be applied to a
+    // declaration}}
+  try {
+  } catch ([[clang::annotate_type(
+      "foo")]] int i) { // expected-error {{'annotate_type' attribute cannot be
+                        // applied to a declaration}}
   }
 }
+template <class T>
+[[clang::annotate_type(
+    "foo")]] T var_template; // expected-error {{'annotate_type' attribute
+                             // cannot be applied to a declaration}}