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

[mboehme]

Summary

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 high-level changes that achieve this are:

• We introduce a new field Declarator::DeclarationAttrs (with appropriate accessors) to store C++11 attributes occurring in the attribute-specifier-seq at the beginning of a simple-declaration (and other similar declarations). Previously, these attributes were placed on the DeclSpec, which made it impossible to reconstruct later on whether the attributes had in fact been placed on the decl-specifier-seq or ahead of the declaration.

• In the parser, we propgate declaration attributes and decl-specifier-seq attributes separately until we can place them in Declarator::DeclarationAttrs or DeclSpec::Attrs, respectively.

• In ProcessDeclAttributes(), in addition to processing declarator attributes, we now also process the attributes from Declarator::DeclarationAttrs (except if they are legacy type attributes).

• In ConvertDeclSpecToType(), in addition to processing DeclSpec attributes, we also process any legacy type attributes that occur in Declarator::DeclarationAttrs (and emit a warning).

• 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]

clang/include/clang/Sema/DeclSpec.h

1853–1860

I've added some comments to clarify the difference. I'm not sure what a good alternative name for Attrs would be though. The only obvious candidate that comes to mind is DeclaratorAttrs, but that seems pretty redundant given that this is a field of Declarator.

I think there is actually a good case for calling the first list simply Attrs because, unlike DeclarationAttrs, it applies directly to the Declarator. This distinction is amplified by the fact that, since your review, I've changed DeclarationAttrs to be a reference, not a by-value field.

1998–2000

This is a great idea that also helps with other things. It's similar in spirit to the idea that I'd floated in our discussion on https://reviews.llvm.org/D111548 of introducing a Declaration and having Declarator hold a reference to that, but it seemed a bit excessive to introduce a new Declaration class solely for the purpose of holding the declaration attributes. Holding a reference directly to the declaration attributes achieves the same thing, but without having to introduce yet another class. I like it.

One implication of this is that we should only have a const version of getDeclarationAttributes(); a non-const version would be dangerous because we're potentially sharing the attribute list with other declarators. (In fact, this wasn't really sound before either because we were effectively already sharing the attribute list too by moving it around between declarators.) Fortunately, it turns out that all of the places that were using the non-const getDeclarationAttributes() didn't actually need to be manipulating the declaration attribute list. I've added source code comments to call this out where appropriate.

clang/include/clang/Sema/ParsedAttr.h

657–658

Yes, this was inteded to refer to the fact that non-[[]] attributes also notionally slide to the DeclSpec. In the initial version of my patch, it was possible for slidesFromDeclToDeclSpec() to be called on non-[[]] attributes within the default case in ProcessDeclAttribute().

However, I've realized that this is confusing; it's better to restrict this function only to [[]] attributes and to do an explicit check in ProcessDeclAttribute() to see whether we're looking at a [[]] attribute. I've added documentation to this function making it clear that it should only be called on [[]] attributes, and I've also added an assertion to enforce this.

All other places that call slidesFromDeclToDeclSpec() are already guaranteed to only call it on [[]] attributes because those attributes come from Declarator::getDeclarationAttributes(), and that is only ever populated with [[]] attributes. (I've added an assertion to make sure this is and continues to be true.)

clang/lib/Parse/ParseDecl.cpp

1833

Done. Unfortunately this did require adding the OriginalDeclSpecAttrs for the purpose of the ProhibitAttributes() call below. That call can't simply use DS.getAttributes() because ParseDeclarationSpecifiers() might have added attributes to that that are legitimately allowed to be there. For example, here's a case from test/SemaCXX/MicrosoftExtensions.cpp that would otherwise break:

// expected-warning@+1 {{attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration}}
struct D {} __declspec(deprecated);

Interestingly, I believe the attribute ordering was already correct before this change because DeclSpec::takeAttributesFrom() adds attributes at the beginning of the list. (It may even be that it does this to support this very use case.) However, as we discuss elsewhere, this behavior is potentially surprising, and we may want to change it at some point, so it's better not to rely on it in the first place.

2193

Now that Declarator only holds a reference to the declaration attributes, the additional clearExceptDeclarationAttrs() has become unnecessary. With that, I think the original clear() name is acceptable?

4328–4331

Good point. Test added in test/Parser/c2x-attributes.c.

4389

Agree -- this has made this function much more straightforward.

6979–7001

Thank you -- done!

clang/lib/Parse/ParseDeclCXX.cpp

2715

Good point.

Instead of doing a ProhibitAttributes(), I've decided to simply move the MaybeParseMicrosoftAttributes() down below this point -- that seemed more straightforward.

I've added a test in test/Parser/MicrosoftExtensions.cpp.

Some considerations:

• With this patch, we've "upgraded" the warning to a hard error. I think this is defensible though because b) the Microsoft compiler also flags this as a hard error (https://godbolt.org/z/jrx6Y1Y83), b) most people will be using Clang to compile code that they compiled with MSVC originally or in parallel, and c) it's an error that I think people are unlikely to make in the first place,

• The error message we get isn't great, but it's not really worse than the Microsoft compiler's error message, and as noted above, this is an error that I think people are unlikely to make.

clang/lib/Parse/ParseObjc.cpp

660–662

Good points -- I've used two separate variables.

1239–1240

As it turns out, we can never pass declaration attributes in here anyway -- see the newly added assertion at the top of the function. This is a good thing, because I've eliminated the non-const version of Declarator::getDeclarationAttributes().

clang/lib/Parse/ParseStmt.cpp

199

Thanks for pointing this out. I agree we shouldn't do this sorting unless it turns out to be necessary.

243–248

I investigated this, but I'm not sure it's a net win.

• If the next token is kw_static_assert, kw_using, or kw_namespace, then prohibit attributes and call ParseDeclaration.

Or if the next token is kw_inline and the token after that is kw_namespace...

I think going down this path would mean duplicating all of the case distinctions in ParseDeclaration() -- and if we add more cases in the future, we'd have to make sure to replicate them here. I think overall it keeps the code simpler to accept the additional DeclSpecAttrs parameter.

Do we also have to handle opaque-enum-declaration here? http://eel.is/c++draft/dcl.dcl#nt:block-declaration

A moot point, probably, but I believe this is handled by ParseEnumSpecifier(), which is called from ParseDeclarationSpecifiers(), so there would be no need to handle it separately.

318–327

Yes, we do!

Fixed, and tests added in test/Parser/asm.c and test/Parser/asm.cpp.

337–339

I would lean towards keeping it simple. Duplicating the ProhibitAttributes() is more verbose, but it's also less surprising.

clang/lib/Parse/Parser.cpp

935–938

Good point, done!

1165

Fixed and added a test in test/Parser/cxx0x-attributes.cpp.

clang/lib/Sema/ParsedAttr.cpp

219

As explained elsewhere, in the first iteration of the change, we used to actually call this with non-[[]] attributes.

I've changed this now, and there's an assertion that this will only ever be called with [[]] attributes.

224

Thoughts on the additional comment?

Yes, good point, we should point this out explicitly.

I've worded the comment slightly differently: we can definitely deprecate the "sliding" behavior for attributes in the clang:: namespace, as we own them, but there may be compatibility concerns for other attributes. This may mean that we can never reduce this list to nothing, but we should try.

And should we start to issue that deprecation warning now (perhaps as a separate follow-up commit)?

We're already doing this (see the tests in test/SemaCXX/adress-space-placement.cpp), though again only for attributes in the clang:: namespace, as we don't really have the authority to deprecate this usage for other attributes.

I think the other question here is whether, by default, this should be an error, not a warning, but this would then presumably require a command-line flag to downgrade the error to a warning if needed (I believe @rsmith raised this point on https://reviews.llvm.org/D111548). If we do decide to make this an error by default, I'd like to do this in a followup change if possible, as a) this change is already a strict improvement over the status quo; b) adding a command-line flag with associated tests would further increase the scope of this change, and c) this change is a blocker for https://reviews.llvm.org/D111548, which others on my team are waiting to be able to use.

308–309

Are you sure about this? I looked at the implementation of takeAllFrom and takePool, and it looks like it adds the new attributes to the end:

void AttributePool::takePool(AttributePool &pool) {
  Attrs.insert(Attrs.end(), pool.Attrs.begin(), pool.Attrs.end());
  pool.Attrs.clear();
}

This is the AttributePool, however, and IIUC that only deals with memory management for attributes; the ordering of attributes there should not have any semantic implications I believe.

What's actually relevant for the semantic ordering of attributes is the call to addAll() in takeAllFrom():

void takeAllFrom(ParsedAttributes &Other) {
  assert(&Other != this &&
         "ParsedAttributes can't take attributes from itself");
  addAll(Other.begin(), Other.end());
  Other.clearListOnly();
  pool.takeAllFrom(Other.pool);
}

And addAll() inserts at the beginning of the list:

void addAll(iterator B, iterator E) {
  AttrList.insert(AttrList.begin(), B.I, E.I);
}

The behavior is definitely surprising though. I speculate that it _may_ have been introduced to make ParseSimpleDeclaration() do the right thing (see my comments there).

As mentioned earlier, we've got some preexisting ordering confusion somewhere in our attribute processing code, so I wouldn't be surprised if we're getting close to finding the root cause of that.

It's possible that other callers of takeAllFrom() or addAll() are expecting the attributes to get added at the end and are doing the wrong thing because of that. This seems worth investigating further, but I'd prefer to defer that to a followup change.

clang/lib/Sema/SemaDeclAttr.cpp

8365

Good point. I've added a check that we're looking at either a DeclaratorDecl or a TypeAliasDecl. The latter is necessary because we have existing use cases where attributes can be placed on an alias declaration and is interpreted as appertaining to the type; see this example from test/Parser/cxx0x-attributes.cpp:

using V = int; // expected-note {{previous}}
using V [[gnu::vector_size(16)]] = int; // expected-error {{redefinition with different types}}

The various tests in test/SemaCXX/address-space-placement.cpp now reflect our rules for where the attribute exhibits the legacy "sliding" behavior (with a mere warning) and where it is prohibited outright (see the expected-error cases in that test).

However, if we really wanted this, we could modify ClangAttrEmitter.cpp to produce a helper function for testing appertainment.

That's a good point. I think for the time being what we have here is sufficient however.

8371–8372

I thought about this, but I think it would be non-trivial and would prefer to leave it to a future enhancement.

9139

Thanks for pointing this out -- done!

9298

I think we should be skipping C++11 attributes here too: int [[x]] a; should not apply the attribute x to a, even if it's a declaration attribute.

Good point -- done.

I don't think this will ultimately make much of a difference because we shouldn't be putting C++11 declaration attributes on the DeclSpec anyway; there's code in ParseDeclarationSpecifiers() that prohibits that. (Prior to this change, we were prohibiting C++11 attributes on the DeclSpec outright; now, we only forbid non-type attributes, but that does mean we should never see declaration attributes here.) There are existing tests for this, for example in test/Parser/cxx0x-attributes.cpp (search for "attribute cannot be applied to a declaration).

However, it does seem more logical and consistent to exclude C++11 attributes here, so I've made this change.

One effect that this does have is the treatment of unknown C++11 attributes: Because we're excluding them now, we no longer diagnose them here; instead, I've modified processTypeAttrs() to diagnose unknown C++11 attributes on the DeclSpec there. Again, this seems the more logical way to do things: The attributes appertain to the type, so they should be diagnosed as part of processing type attributes.

clang/lib/Sema/SemaType.cpp

201

No longer applicable.

I've reverted the changes I made to TypeProcessingState that this comment applied to. I had originally modified TypeProcessingState::getCurrentAttributes() so that it would return the declaration attributes if we were currently processing those, but it turned out that this was not relevant to any of the use cases that TypeProcessingState::getCurrentAttributes() is used for.

582

This was actually a mis-formatting that clang-format didn't complain about or fix. Fixed.

1814

Again, I would prefer to exclude this from the scope of this change.

[rsmith]

clang/include/clang/Sema/DeclSpec.h

1926–1928

I think I recall seeing OpenMP pragma attributes being parsed as declaration attributes too. FIXME update this comment after review is complete

clang/lib/Parse/ParseDecl.cpp

1848

This looks wrong to me (both before and after this patch; you've faithfully retained an incorrect behavior). If DeclSpec attributes aren't allowed, they should be diagnosed by ParsedFreeStandingDeclSpec. Before and after this patch, we'll diagnose attributes in a free-standing decl-specifier-seq if we happened to tentatively parse them, not if we happened to parse them in ParseDeclarationSpecifiers. For example:

__attribute__(()) struct X; // DeclSpecAttrs will be empty, no error
void f() {
  __attribute(()) struct X; // DeclSpecAttrs will contain the attribute specifier, error
}

Comparing to GCC's behavior for that example (which GCC silently accepts) and for this one:

__attribute__((packed)) struct X; // GCC warns that packed has no meaning here, clang produces a high-quality warning.
void f() {
  __attribute((packed)) struct X; // GCC warns that packed has no meaning here, clang produces a bogus error.
}

... I think the right thing to do is to delete this call (along with OriginalDeclSpecAttrs). GNU decl-specifier attributes *are* apparently syntactically permitted here, but most (maybe even all?) GNU attributes don't have any meaning in this position.

clang/lib/Parse/ParseDeclCXX.cpp

2691–2696

Oh, neat, I think this copy isn't necessary any more, given that we don't give ownership of the DeclAttrs to the ParsingDeclarator any more, and don't mix the declaration attributes and the DeclSpec attributes together any more. We should be able to just use DeclAttrs instead of FnAttrs below now, I think?

clang/lib/Parse/ParseExprCXX.cpp

2745–2747

Given the number of times this has come up, I wonder if it's worth adding something like:

class ParsedAttributes {
public:
  // ...
  static const ParsedAttributes &none() {
    static AttributeFactory Factory;
    static AttributePool Pool(Factory);
    static const ParsedAttributes Attrs(Pool);
    return Attrs;
  }
  // ...
};

(or, better, changing Declarator to hold a const ParsedAttributesView& rather than a const ParsedAttributes&) so that we can write

Declarator D(DS, ParsedAttributes::none(), DeclaratorContext::ConversionId);

Totally optional, though, and I'm happy for this cleanup to happen at some later point in time.

clang/lib/Parse/ParseStmt.cpp

16

This header is intended to be private to Sema. If you want to use a diagnostic in both the parser and sema, please move it to DiagnosticCommonKinds.td.

243–248

• If the next token is kw_static_assert, kw_using, or kw_namespace, then prohibit attributes and call ParseDeclaration.

Or if the next token is kw_inline and the token after that is kw_namespace...

This function is parsing block declarations, so we don't have to handle inline namespace here because that can't appear as a block declaration. The only reason we need to handle namespace is to support namespace aliases (namespace A = B;), which are (perhaps surprisingly) allowed at block scope.

I think going down this path would mean duplicating all of the case distinctions in ParseDeclaration() -- and if we add more cases in the future, we'd have to make sure to replicate them here. I think overall it keeps the code simpler to accept the additional DeclSpecAttrs parameter.

It's not all the cases, only the block-declaration cases. If we wanted to directly follow the grammar, we could split a ParseBlockDeclaration function out of ParseDeclaration, but I guess there'd be so little left in ParseDeclaration that it wouldn't be worth it, and we'd still have to pass the DeclSpecAttrs parameter to ParseBlockDeclaration, so that doesn't save us anything. I suppose it'd also regress our diagnostic quality for declarations that aren't allowed at block scope. OK, I'm convinced :-)

clang/lib/Sema/ParsedAttr.cpp

240–243

Many of these were previously not permitted in type attribute position, despite being declared in Attr.td as TypeAttrs. Do they actually work in type attribute position after this patch? At least matrix_type currently expects to be applied only to a typedef declaration, so I'd expect that one does not work as a type attribute.

clang/lib/Sema/SemaDeclAttr.cpp

8325–8326

I'm not following what's going on here: the C++11 alignas keyword follows the same rules as a C++11-syntax declaration attribute, so I'd expect it to be handled the same way. Eg, int alignas(16) n; is ill-formed (even though ICC and MSVC allow it and GCC only warns).

clang/test/Parser/MicrosoftExtensions.cpp

65

This seems like a confusing diagnostic to produce for this error. Does it make sense in context (with the snippet + caret)?

clang/test/SemaCXX/address-space-placement.cpp

4–6

I'd like to see some matching tests that we *don't* warn when the attribute is placed properly.

[rsmith]

I'm very happy with how this patch is looking.

clang/include/clang/Sema/DeclSpec.h

1926–1928

Oops, forgot to circle back to this. I think I was wrong; please disregard :)

[aaron.ballman]

clang/include/clang/Sema/DeclSpec.h

1853–1860

The new comment actually makes it less clear for me -- that says the attributes are for the DeclSpec but they're actually for the Declatator (there's no relationship between Attrs and DS).

Given that DeclSpec uses Attrs for its associated attributes, I think it's okay to use Attrs here for the ones associated with the Declarator, but the comment should be updated in that case.

clang/include/clang/Sema/ParsedAttr.h

664

Because this is now specific to standard attributes, and those don't "slide" under normal circumstances, it might be nice to rename this method to make it more clear that this should not be called normally. I don't have a strong opinion on what a *good* name is, but even something like improperlySlidesFromDeclToDeclSpec() would make me happy.

clang/lib/Parse/ParseDecl.cpp

1848

Good catch!

2193

It's fine by me.

clang/lib/Parse/ParseDeclCXX.cpp

2715

I think it's okay for this to have gone from a warning to a hard error, especially given the MSVC compatibility.

clang/lib/Parse/ParseExprCXX.cpp

2745–2747

+1 to this being a pretty nice cleanup and it being fine if it happens in a follow-up.

clang/lib/Parse/ParseStmt.cpp

318–327

I think we should prohibit this for all [[]] attributes. C doesn't have an asm statement as part of the standard, but it lists it as a common extension in Annex J and uses the same syntax as the C++ feature. Might as well keep it consistent between the languages.

337–339

I don't feel super strongly about it, so this can wait until a follow-up if we want to do anything about it.

clang/lib/Sema/ParsedAttr.cpp

224

... but there may be compatibility concerns for other attributes. This may mean that we can never reduce this list to nothing, but we should try.

I would be pretty aggressive there and break compatibility over this, unless the uses were in system headers or something where the break would be too onerous to justify.

I think the other question here is whether, by default, this should be an error, not a warning, but this would then presumably require a command-line flag to downgrade the error to a warning if needed

You put DefaultError onto the warning diagnostic to have it automatically upgraded as if the user did -Werror=whatever-warning, which allows the user to downgrade it back into a warning with -Wno-error=whatever-warning.

clang/lib/Sema/SemaDeclAttr.cpp

8371–8372

Fine by me.

8381

isa is variadic.

8385

I do wonder how much code we break if we tighten this up regardless of which vendor namespace the attribute belongs to. I believe the sliding behavior is not conforming behavior unless we issue a diagnostic about it because we're extending the behavior of the language.

clang/lib/Sema/SemaType.cpp

1814

SGTM!

[mboehme]

Changes in response to review comments

[mboehme]

Changes in response to review comments.

[mboehme]

I notice that https://reviews.llvm.org/D111548, which this change is based on, has some failing flang tests in the CI. I'm pretty sure these are unrelated and stem from the base revision that I happen to be based off. Before rebasing, however, I wanted to make sure all of the big comments have been resolved so that I don't introduce too much churn into the diffs.

clang/include/clang/Sema/DeclSpec.h

1853–1860

Sorry, I don't know what I was thinking when I wrote DeclSpec. That should have read "Attributes attached to the declarator", and I've changed it accordingly.

I hope that with this change, this makes sense now?

1926–1928

Just making sure I can disregard this comment? Please respond if there's something you'd like me to address here.

clang/include/clang/Sema/ParsedAttr.h

664

I've decided to add LegacyBehavior at the end -- WDYT?

clang/lib/Parse/ParseDecl.cpp

1848

Thanks for pointing this out!

I've removed the ParseAttributes(DeclSpecAttrs) call and have added tests for the behavior of free-standing decl-specifier-seqs in test/Parser/attributes.c (for empty __attribute__(())) and test/Sema/attr-declspec-ignored.c (to make sure that we produce the correct warnings on block declarations).

clang/lib/Parse/ParseDeclCXX.cpp

2691–2696

Yes, done. Nice!

clang/lib/Parse/ParseExprCXX.cpp

2745–2747

Good point -- done (and changed Declarator to hold a const ParsedAttributesView&).

clang/lib/Parse/ParseStmt.cpp

16

Thanks, done.

243–248

Just confirming: You're not asking me to do anything here, correct?

318–327

My rationale for handling C and C++ differently here was because they treat asm differently.

In C++, the standard requires us to allow attributes, so we merely warn that they will be ignored. (Also, asm is formally a declaration, not a statement in C++, though I’m not sure that makes a difference to the syntax.)

In C, J.5.10 in “Common extensions” says “The most common implementation is via a statement [...]”. C permits attributes only on declarations, though since asm is an extension, that’s not really relevant anyway. Since this is our extension and we wouldn’t do anything with the attributes anyway, it seemed best to me to prohibit them outright.

OTOH, I’ve just checked and GCC appears to accept attributes in this position even in C mode. Is the compatibility argument strong enough that we should do this too?

clang/lib/Sema/ParsedAttr.cpp

224

I think the other question here is whether, by default, this should be an error, not a warning, but this would then presumably require a command-line flag to downgrade the error to a warning if needed

You put DefaultError onto the warning diagnostic to have it automatically upgraded as if the user did -Werror=whatever-warning, which allows the user to downgrade it back into a warning with -Wno-error=whatever-warning.

Oh nice -- I didn't realize it was this easy!

I haven't made a change yet because I wanted to give @rsmith an opportunity to weigh in -- do you have an opinion on whether this should be a warning or an error by default?

240–243

Many of these were previously not permitted in type attribute position, despite being declared in Attr.td as TypeAttrs. Do they actually work in type attribute position after this patch?

Good point -- should have thought to test this myself.

I have now added tests for all of the "sliding attributes". It was good thing I did, because I realized that the logic in processTypeAttrs() was only letting very specific attributes through. The new logic is now much more generic (see SemaType.cpp:8278 and following).

I also discovered some interesting special cases that I needed to add extra code for.

At least matrix_type currently expects to be applied only to a typedef declaration, so I'd expect that one does not work as a type attribute.

Thanks for pointing this out -- I had completely overlooked this. This is the first of the special cases I referred to above. It has unfortunately required adding some special-case code (SemaType.cpp:1819 and SemaDeclAttr.cpp:9311) to make sure we emit the right diagnostics. I've also added tests to make sure we emit the right diagnostics. The redeeming factor is that I think it will be possible to remove this code once we eliminate the "legacy sliding" behavior.

I have to say I find it unusual that a type attribute restricts itself to being used only on certain kinds of declarations; this seems a bit non-orthogonal. Is there a good reason for this, or could the attribute be "opened up" for use on types regardless of the context in which they're used?

I've confirmed by the way that none of the other "sliding" attributes is restricted to being used in a typedef, and I've added tests that demonstrate this if they didn't exist already.

The other two special cases are:

1. regparm. This is a case where it's actually not correct to slide the attribute to the DeclSpec because it should instead be applied to the function type. Again, this attribute requires some special-case code; see SemaDeclAttr.cpp:8397 and SemaType.cpp:8467. The comments there explain the situation in more detail. Because the attribute doesn't actually "slide", I've removed it from the list of attributes in slidesFromDeclToDeclSpecLegacyBehavior().
2. noderef. It turns out that this attribute currently does not work at all in the [[]] spelling; I've written up a bug with the details. Because of this, there is no legacy behavior that needs to be preserved. Instead, for the time being, I have chosen to simply emit an "attribute ignored" warning when the attribute is encountered in [[]] spelling. Again, I have removed the attribute from the list of attributes in slidesFromDeclToDeclSpecLegacyBehavior().

I have added tests that check the specific behavior of the regparm and noderef attributes.

clang/lib/Sema/SemaDeclAttr.cpp

8325–8326

My previous comment was based merely on the fact that I sometimes observed the attribute on the DeclSpec, but I did not dig any further at the time. I should have because I would have discovered the actual reason, namely that isCXX11Attribute() erroneously classifies the _Alignas spelling of the attribute as a C++11 attribute. See the changed comment above and the comment in isAlignasAttribute() for details.

I'm not sure how isAlignasAttribute() should best be fixed, so I would propose leaving the current logic in place for the time being as a workaround.

8381

Nice. Done!

8385

I do wonder how much code we break if we tighten this up regardless of which vendor namespace the attribute belongs to.

I think this is unfortunately hard to determine?

I believe the sliding behavior is not conforming behavior unless we issue a diagnostic about it because we're extending the behavior of the language.

It might not conform with the spirit of the standard, but I think it conforms with the letter. All of the attributes in question are vendor extensions anyway, so if we want to, we can define their behavior as “when applied to a declaration, changes the type of the declared entity in a certain way”. This is essentially what all of the DeclOrTypeAttr attributes do when applied to a declaration.

And GCC certainly allows putting some of these attributes on declarations. Here’s an example for vector_size:

https://godbolt.org/z/1nhjPs3PP

Maybe this means that vector_size should actually be a DeclOrTypeAttr, not a pure TypeAttr. But I’d like to defer that decision to a potential later cleanup dedicated to vector_size and leave it as a TypeAttr for now.

clang/test/Parser/MicrosoftExtensions.cpp

65

The error with snippet and caret looks like this:

MicrosoftExtensions.cpp:66:50: error: expected member name or ';' after declaration specifiers
  [uuid("000000A0-0000-0000-C000-00000000004A")] using base::a; // expected-error {{expected member name}}
                                                 ^

I would classify that as "not great, not terrible". I think it's defensible given that a) I think it's an error few people are likely to make, so few people will see the error message, and b) MSVC's error message isn't great either:

<source>(2): error C2059: syntax error: 'using'
<source>(2): error C2238: unexpected token(s) preceding ';'

(see https://godbolt.org/z/jrx6Y1Y83)

If we wanted a better error message, we'd have to do the MaybeParseMicrosoftAttributes() somewhere above ParseDeclCXX.cpp:2691, then add a ProhibitAttributes() inside the if (Tok.is(tok::kw_using)). I'm not sure if this is ultimately worth it though?

clang/test/SemaCXX/address-space-placement.cpp

4–6

Good point. I've added those tests.

[rsmith]

clang/lib/Parse/ParseStmt.cpp

243–248

Yes, no action requested. Thanks for talking through this option with me! :)

clang/lib/Sema/ParsedAttr.cpp

228

I don't think this one really slides today, in the syntactic sense, prior to this patch (and I guess the same is true for most of these). Given:

[[clang::address_space(5)]] int x;
int [[clang::address_space(5)]] y;

... we accept x and reject y, making it look like this is simply a declaration attribute. Hm, but we accept:

int *[[clang::address_space(5)]] *z;

... so it really *does* seem to behave like a type attribute sometimes?

OK, so this patch is doing two things:

1. It's permitting the use of these attributes as type attributes, where they were not consistently permitted previously.
2. It's deprecating / warning on uses of them as declaration attributes.

That means there's no way to write code that is compatible with both old and new Clang and produces no warnings, but it's easy enough to turn the warning flag off I suppose. The new behavior does seem much better than the old.

240–243

I have to say I find it unusual that a type attribute restricts itself to being used only on certain kinds of declarations; this seems a bit non-orthogonal. Is there a good reason for this, or could the attribute be "opened up" for use on types regardless of the context in which they're used?

We historically didn't have type attributes at all, only declaration attributes (and I suspect GCC was once the same in this regard), so a lot of the attributes that notionally *should* be treated as type attributes actually behave syntactically as declaration attributes instead. An obvious example of this is the aligned attribute, which notionally produces a different type -- that attribute appertains to typedef declarations (so that the typedef-name names a different type than the type that it's a typedef for) rather than appertaining to the type. Logically, I think we *should* provide versions of these attributes that appertain to types instead, but that will require a separate proposal and discussion, and is certainly outside the scope of this change.

There are even cases of declaration attributes that logically *should* be type attributes, and are listed in the .td file as TypeAttr, but are actually declaration attributes. MatrixType is an example:

• It's given a SubjectList in the .td file that contains only TypedefName because it can syntactically appertain only to a TypedefNameDecl -- it's syntactically a declaration attribute, not a type attribute
• It's modeled in the .td file as a TypeAttr, possibly because it gets semantically modeled as part of an AttributedType -- it's semantically *both* a declaration attribute (we find it on TypedefNameDecls) and a type attribute (we find it on AttributedTypes)

I'm not entirely convinced that's the right way to model this in the .td file -- the documentation for TypeAttr certainly suggests that it's about the syntactic form. Maybe there's room for improvement there -- @aaron.ballman, what do you think?

241

This one is weird. Given:

[[gnu::vector_size(8)]] int x;
int [[gnu::vector_size(8)]] y;
int *[[gnu::vector_size(8)]]* z;

• Clang and GCC accept x
• Clang rejects y and GCC warns that the attribute is ignored on y
• Clang accepts z with a warning that GCC would ignore the attribute, whereas GCC silently accepts

I guess after this patch we'll silently accept x (treated as the "sliding" behavior) and accept y and z with a warning that it's GCC-incompatible?

[mboehme]

• Changes in response to review comments
• Rebase to newer base revision

[mboehme]

clang/lib/Sema/ParsedAttr.cpp

228

I don't think this one really slides today, in the syntactic sense, prior to this patch (and I guess the same is true for most of these). Given:

[[clang::address_space(5)]] int x;
int [[clang::address_space(5)]] y;

... we accept x and reject y, making it look like this is simply a declaration attribute.

Yes, and we get the same behavior for all C++11 attributes.

This is because, today, Clang flat-out rejects _all_ C++11 attributes that are placed after a decl-specifier-seq:

From ParseDeclarationSpecifiers():

// Reject C++11 attributes that appertain to decl specifiers as
// we don't support any C++11 attributes that appertain to decl
// specifiers. This also conforms to what g++ 4.8 is doing.
ProhibitCXX11Attributes(attrs, diag::err_attribute_not_type_attr);

https://github.com/llvm/llvm-project/blob/main/clang/lib/Parse/ParseDecl.cpp#L3182

So really what the "slides" terminology means is "is treated as appertaining to the decl-specifier-seq instead of the declaration".

Hm, but we accept:

int *[[clang::address_space(5)]] *z;

... so it really *does* seem to behave like a type attribute sometimes?

Yes, because Clang does allow C++11 attributes (including address_space in particular) on declarator chunks today -- it just doesn't allow them on the decl-specifier-seq. As an aside, this makes the error message we get when putting the attribute on the decl-specifier-seq today ("'address_space' attribute cannot be applied to types") pretty misleading.

OK, so this patch is doing two things:

1. It's permitting the use of these attributes as type attributes, where they were not consistently permitted previously.
2. It's deprecating / warning on uses of them as declaration attributes.

Actually, 1) happens in https://reviews.llvm.org/D111548, which this change is based on.

I did things this way because

• I want to introduce annotate_type first, so that this change can use it in tests as an example of a type attribute that doesn't "slide"
• I wanted tests in https://reviews.llvm.org/D111548 to be able to use annotate_type in all places that it's intended for, including on the decl-specifier-seq, so I needed to open up that usage. (Actually, when I first authored https://reviews.llvm.org/D111548, I didn't even realize that this followup change would be coming.)

Is this confusing? I could instead do the following:

• Move the change that allows C++11 attributes on the decl-specifier-seq from https://reviews.llvm.org/D111548 to here.
• Move tests that use annotate_type on the decl-specifier-seq from https://reviews.llvm.org/D111548 to here.

Do you think that would be preferable?

That means there's no way to write code that is compatible with both old and new Clang and produces no warnings, but it's easy enough to turn the warning flag off I suppose.

That's true -- and I think it's the best we can do. The behavior that Clang exhibits today is of course set in stone (error out if the attribute is placed on the decl-specifier-seq), and at the same time it seems obvious that we want to nudge people away from putting the attribute on the declaration, as it's really a type attribute. (Just repeating your analysis here essentially; I think we agree, and there's nothing to do here.)

I do think this makes an argument that the new diagnostic we're introducing should be a warning initially, not an error. Otherwise, there would be no way to use the C++11 spelling in a way that compiles (albeit maybe with warnings) both before and after this patch.

The new behavior does seem much better than the old.

240–243

We historically didn't have type attributes at all, only declaration attributes (and I suspect GCC was once the same in this regard), so a lot of the attributes that notionally *should* be treated as type attributes actually behave syntactically as declaration attributes instead.

[snip]

Thanks for the context!

Logically, I think we *should* provide versions of these attributes that appertain to types instead, but that will require a separate proposal and discussion, and is certainly outside the scope of this change.

Agree. In case it was unclear: I certainly wasn't proposing doing this as part of this patch (not sure if that was unclear) -- this was more of a question about principles / intended direction.

There are even cases of declaration attributes that logically *should* be type attributes, and are listed in the .td file as TypeAttr, but are actually declaration attributes. MatrixType is an example:

• It's given a SubjectList in the .td file that contains only TypedefName because it can syntactically appertain only to a TypedefNameDecl -- it's syntactically a declaration attribute, not a type attribute
• It's modeled in the .td file as a TypeAttr, possibly because it gets semantically modeled as part of an AttributedType -- it's semantically *both* a declaration attribute (we find it on TypedefNameDecls) and a type attribute (we find it on AttributedTypes)

Yes, this is the particular example that I found confusing. Good point about there being a tension between this being a declaration attribute syntactically but a type attribute (among other things) semantically.

I'm not entirely convinced that's the right way to model this in the .td file -- the documentation for TypeAttr certainly suggests that it's about the syntactic form. Maybe there's room for improvement there -- @aaron.ballman, what do you think?

I would also be interested in this, though certainly any changes would be outside the scope of this patch.

241

This one is weird. Given:

[[gnu::vector_size(8)]] int x;
int [[gnu::vector_size(8)]] y;
int *[[gnu::vector_size(8)]]* z;

• Clang and GCC accept x
• Clang rejects y and GCC warns that the attribute is ignored on y
• Clang accepts z with a warning that GCC would ignore the attribute, whereas GCC silently accepts

Actually, for z, Clang gives me not just a warning but also an error:

<source>:1:8: warning: GCC does not allow the 'vector_size' attribute to be written on a type [-Wgcc-compat]
int *[[gnu::vector_size(8)]]* z;
       ^
<source>:1:8: error: invalid vector element type 'int *'

https://godbolt.org/z/E4ss8rzWE

I guess after this patch we'll silently accept x (treated as the "sliding" behavior) and accept y and z with a warning that it's GCC-incompatible?

Thanks for pointing this out to me!

Actually, I must not have checked the GCC behavior previously, so I went too far and gave vector_size meaning when placed on y instead of just ignoring it. I’ve now changed the code to ignore the attribute and emit a warning, like GCC does. (See tests in vector-gcc-compat.c.)

It’s particularly surprising to me that GCC allows vector_size to be applied to a pointer type (the z case) – particularly so since the documentation explicitly states: “The vector_size attribute is only applicable to integral and floating scalars, although arrays, pointers, and function return values are allowed in conjunction with this construct.”

I wanted to test whether GCC just silently ignores the attribute when placed on a pointer or whether it has an effect. Here are some test cases:

https://godbolt.org/z/Ke1E7TnYe

From looking at the generated code, it appears that vector_size, when applied to a pointer type, _does_ have an effect – though a maybe slightly surprising one: It is applied to the base type, rather than the pointer type. I suspect that GCC simply treats the C++11 spelling the same as the __attribute__ spelling (i.e. it doesn’t apply the stricter C++11 rules on what the attribute should appertain to), and it seems that both spellings get applied to the base type of the declaration no matter where they appear in the declaration (except if the attribute is ignored entirely).

Interestingly, this means that Clang’s warning (“GCC does not allow the 'vector_size' attribute to be written on a type”) is wrong. Maybe this is behavior in GCC that has changed since the warning was introduced?

Given all of this, I propose we treat the various cases as follows (and I’ve implemented this in the code):

• We continue to accept x without a warning, just as we do today (same behavior as GCC)
• We allow y but warn that the attribute doesn’t have an effect (same behavior as GCC)
• We continue to reject z, even though GCC allows it and it has an effect there. Rationale: a) We reject this today, so this isn’t a regression; b) this usage is unusual and likely not to occur often in the wild; c) fixing this to be consistent with GCC will take a non-trivial amount of code, so I’d like to keep it outside the scope of this change.

[mboehme]

Fix typos in comments.

[mboehme]

@aaron.ballman Any further comments from you on this change?

There is some breakage in the pre-merge checks, but it looks as if it's pre-existing breakage. See the comment-only change here that looks as if it exhibits similar breakage:

https://reviews.llvm.org/D127494

[aaron.ballman]

In D126061#3577054, @mboehme wrote:

@aaron.ballman Any further comments from you on this change?

Mostly just nits from me at this point, plus some answers to questions I had missed previously.

There is some breakage in the pre-merge checks, but it looks as if it's pre-existing breakage. See the comment-only change here that looks as if it exhibits similar breakage:

https://reviews.llvm.org/D127494

I agree that the precommit CI failures look unrelated to this patch.

clang/include/clang/Basic/AttributeCommonInfo.h

153

Now that C23 has attributes, it's also not clear whether _Alignas will be handled slightly differently in the future as an attribute rather than a declaration specifier as happened with _Noreturn for C23. So agreed this is a tricky area.

clang/include/clang/Sema/DeclSpec.h

1914

I know it's pre-existing code, but since you're updating the parameters and adding some great comments, can you rename ds to DS per coding style guides?

1926–1928

Can you add an && "and this is what the assert is testing for" message here so when the assertion fails there's more details as to what went sideways?

clang/include/clang/Sema/ParsedAttr.h

664

Works for me

1120

I think Concatenate implies that First and Second are untouched, but that's not really the case here. Perhaps takeAndConcatenateAll() or something along those lines instead? Also, the function should start with a lowercase letter per the usual coding style rules.

clang/lib/Parse/ParseStmt.cpp

230

Coding style nit.

231–238

The logic is correct here, but this predicate has gotten really difficult to understand. If you wanted to split some of those conditions out into named variables for clarity, I would not be sad (but I also don't insist either).

249–253

Do CXX attributes always precede GNU ones, or do we need to do a source location comparison here to see which location is lexically earlier?

318–327

In C, J.5.10 in “Common extensions” says “The most common implementation is via a statement [...]”. C permits attributes only on declarations, though since asm is an extension, that’s not really relevant anyway. Since this is our extension and we wouldn’t do anything with the attributes anyway, it seemed best to me to prohibit them outright.

C permits attributes on statements as well. I think it would be a bit odd to prohibit on assembly statements but still allow on other kinds of extensions like GNU ranged case labels.

I think we should go ahead and accept despite it being a bit useless.

clang/lib/Sema/ParsedAttr.cpp

224

I'm not certain if @rsmith has opinions here or not, but I think an error which can be downgraded to a warning is a reasonable approach. We should hear pretty quickly if this causes significant problems (in system headers or the like).

240–243

We historically didn't have type attributes at all, only declaration attributes (and I suspect GCC was once the same in this regard), so a lot of the attributes that notionally *should* be treated as type attributes actually behave syntactically as declaration attributes instead.

This is why we have DeclOrTypeAttr in Attr.td -- largely for the calling convention attributes. It's a newer construct and I don't think it's been applied everywhere it should (it sounds like MatrixType is a good example).

I'm not entirely convinced that's the right way to model this in the .td file -- the documentation for TypeAttr certainly suggests that it's about the syntactic form. Maybe there's room for improvement there -- @aaron.ballman, what do you think?

There is quite a bit of room for improvement there. IIRC, we also got away with a lot of laxity here because automated checking for type attributes is basically nonexistent. However, I think those cleanups can all happen separately from this patch.

clang/lib/Sema/SemaDeclAttr.cpp

8381

This shouldn't need to be qualified and the extra parens aren't needed.

8385

It might not conform with the spirit of the standard, but I think it conforms with the letter. All of the attributes in question are vendor extensions anyway, so if we want to, we can define their behavior as “when applied to a declaration, changes the type of the declared entity in a certain way”. This is essentially what all of the DeclOrTypeAttr attributes do when applied to a declaration.

The goal is for us to eventually conform to the spirit of the standard. Yes, vendor attributes have a lot of latitude in terms of their semantics, but the reason why we needed to devise the [[]] syntax in the first place was because the sliding behavior of __attribute__(()) caused far too many problems in practice and we needed a much tighter notion of appertainment.

Maybe this means that vector_size should actually be a DeclOrTypeAttr, not a pure TypeAttr. But I’d like to defer that decision to a potential later cleanup dedicated to vector_size and leave it as a TypeAttr for now.

Fine by me, I think that can be cleaned up later.

[rsmith]

This is a bold direction but I like it a lot. Over to @aaron.ballman for final approval.

clang/lib/Sema/ParsedAttr.cpp

224

I think I'd prefer for this to be a warning in the initial release with the new behavior, and for us to upgrade it to an error for a subsequent release. I'm not completely comfortable with there being no [[clang::...]] placement for these attributes that is accepted by default in both Clang 14 and Clang 15, but somewhat more comfortable with there being no syntax that's accepted in both Clang 14 and Clang 16 by default, even though I think these attributes are in practice mostly used with __attribute__((...)) syntax.

228

Thanks for the explanation. If we're landing both patches more or less together anyway, I'm not too concerned by how we split the changes between them. No action required here, I think.

241

https://godbolt.org/z/Ke1E7TnYe

That GCC behavior is shocking. Shocking enough that I think the following approach would make sense:

1. For compatibility, emulate the GCC behavior as much as possible for [[gnu::vector_size]], except:
   • Continue to error rather than only warning in the cases where the attribute does not create a vector type at all, and
   • Warn on cases like int *[[gnu::vector_size(N)]] (and possibly int *p [[gnu::vector_size(N)]]) that we're forming a pointer to a vector rather than a vector of pointers.
2. Add a separate [[clang::vector_size(N)]] attribute that behaves like a type attribute is supposed to: the attribute applies to the type on its left, always (and can't be applied to a declaration).

(Incidentally, I think we should add a [[clang::ext_vector_type]] spelling with behavior (2) too. The .td file claim that ext_vector_type is OpenCL-specific isn't true; it's a general kind of vector type that follows the OpenCL rules but is available across language modes.)

But... not in this patch. In this patch I think the only priority for the [[gnu::...]] attributes is that we don't make things worse (in particular, don't make GCC compatibility worse). And given that this new sliding behavior applies only to [[clang::...]] attributes I think we have that covered. So no action required here.

[mboehme]

Generally allow type attributes to be placed on the decl-specifier-seq (with
some exceptions for specific attributes that were already present in this
change).

Previously, https://reviews.llvm.org/D111548, which this change is based on,
had already allowed all type attributes to be placed on the decl-specifier-seq,
but @aaron.ballman's comments on that patch made me realize that the change is
better made here.

[aaron.ballman]

Only thing left for me are the nits I pointed out in the last review, otherwise I think this is all set. Giving my LG because I don't think we need another round of review for those nits unless you want it

clang/lib/Sema/ParsedAttr.cpp

224

Okay, that's convincing, thanks!

241

+1 to this :-)

[mboehme]

Changes in response to review comments.

[mboehme]

In D126061#3581350, @aaron.ballman wrote:

Only thing left for me are the nits I pointed out in the last review, otherwise I think this is all set.

Thanks for the quick turnaround!

Giving my LG because I don't think we need another round of review for those nits unless you want it

Just two things I'd appreciate a quick confirmation on:

• My question on isAlignasAttribute()
• Feedback on whether you think my refactoring of the complex boolean expression makes sense

clang/include/clang/Basic/AttributeCommonInfo.h

153

Thanks for pointing this out! Is there anything specific I should add to the code comment, or is your comment just for general awareness?

clang/include/clang/Sema/DeclSpec.h

1914

No problem -- done!

1926–1928

Good point -- done.

clang/include/clang/Sema/ParsedAttr.h

1120

Good point. Done, with a slightly different name -- WDYT?

clang/lib/Parse/ParseStmt.cpp

230

Done.

231–238

Yes, this is confusing. I've factored out some variables that I hope make this more readable.

By the way, it might look as if GNUAttributeLoc.isValid() implies HaveAttributes and that the latter is therefore redundant, but this isn’t actually true if we failed to parse the GNU attribute. Removing the HaveAttributes makes some tests fail, e.g. line 78 of clang/test/Parser/stmt-attributes.c.

249–253

Yes, we can rely on this being the case. This function is called from only one place where both CXX11Attrs and GNUAttrs can potentially contain attributes, namely ParseStatementOrDeclaration() (line 114 in this file). There, the CXX11Attrs are parsed before the GNUAttrs. I’ve added an assertion, however, since this guarantee is important to the correctness of the code here.

318–327

You've convinced me -- done!

clang/lib/Sema/ParsedAttr.cpp

228

As it happens, I did end up making a change here after all:

• https://reviews.llvm.org/D111548 only allows annotate_type but no other attributes on the decl-specifier-seq
• This patch allows type attributes more generally on the decl-specifier-seq

See also the discussion on https://reviews.llvm.org/D111548 for more background on why I moved the code around like this.

Given the previous discussion, I'm assuming you're OK with this change. (The final state of the code once both patches have landed will be the same as it was before -- this is just changing which patch does what.)

clang/lib/Sema/SemaDeclAttr.cpp

8381

Done. (Sorry for not getting this right the first time.)

8385

The goal is for us to eventually conform to the spirit of the standard. Yes, vendor attributes have a lot of latitude in terms of their semantics, but the reason why we needed to devise the [[]] syntax in the first place was because the sliding behavior of __attribute__(()) caused far too many problems in practice and we needed a much tighter notion of appertainment.

That makes sense -- and I've only come to appreciate while working on this patch how much variation and unpredictability there is in type attributes. Thanks for the discussion and clarifications.

[aaron.ballman]

LGTM!

clang/include/clang/Basic/AttributeCommonInfo.h

153

Nope, just spreading the information around to more people's brains -- nothing needs to be changed here.

clang/include/clang/Sema/ParsedAttr.h

1120

Works great for me!

clang/lib/Parse/ParseStmt.cpp

230

I don't insist, but I think it's a tiny bit easier to read this way.

231–238

Thanks, I think this is more readable this way!

249–253

Thank you for the confirmation and the added assertion!

318–327

[mboehme]

Small code tweaks

[mboehme]

Thank you @aaron.ballman and @rsmith for the careful and productive reviews!

clang/lib/Parse/ParseStmt.cpp

230

Done!

318–327

Done!

[nikic]

FYI this change had a measurable effect on compile-time (http://llvm-compile-time-tracker.com/compare.php?from=7acc88be0312c721bc082ed9934e381d297f4707&to=8c7b64b5ae2a09027c38db969a04fc9ddd0cd6bb&stat=instructions), about 0.5% regression for O0 builds. Not sure if that's expected.

[mboehme]

In D126061#3585681, @nikic wrote:

FYI this change had a measurable effect on compile-time (http://llvm-compile-time-tracker.com/compare.php?from=7acc88be0312c721bc082ed9934e381d297f4707&to=8c7b64b5ae2a09027c38db969a04fc9ddd0cd6bb&stat=instructions), about 0.5% regression for O0 builds. Not sure if that's expected.

Thanks for the heads-up.

Without more extensive investigation, it's hard to say. I wasn't necessarily expecting a slowdown, but I can come up with various hypotheses for what might be causing it.

I've seen the instructions on the About page on how to reproduce results and will give that a go.

The first thing to analyze would be whether the slowdown occurs only on code that uses attributes (heavily) or also on code that doesn't use attributes.

There isn't any single substantial change in the code that would cause an obvious slowdown. I could speculate on some potential causes, but it seems better to measure instead. Is there any particular tooling that you would recommend for comparing profiler runs from two different compiler versions (one with my patch, one without)?

I'll post an update here when I find out more.

[dyung]

@mboehme, one of our internal tests started to fail to compile after this change due to the compiler no longer accepting what I think should be a valid attribute declaration. I have filed issue #56077 for the problem, can you take a look?

[mboehme]

In D126061#3590896, @dyung wrote:

@mboehme, one of our internal tests started to fail to compile after this change due to the compiler no longer accepting what I think should be a valid attribute declaration. I have filed issue #56077 for the problem, can you take a look?

Attributes are not allowed to occur in this position -- I'll discuss in more detail on #56077.

See also the response I'm making on a code comment, where a reviewer pointed out to me that the C++ standard does not allow [[]] attributes before extern "C".

clang/lib/Parse/Parser.cpp

1165

Update: @dyung is seeing errors on their codebase because of this -- see also the comment they added to this patch.

It's not unexpected that people would have this incorrect usage in their codebases because we used to allow it. At the same time, it's not hard to fix, and I would generally expect this kind of error to occur in first-party code (that is easily fixed) rather than third-party libraries, because the latter usually compile on GCC, and GCC disallows this usage.

Still, I wanted to discuss whether you think we need to reinstate support for this (incorrect) usage temporarily, with a deprecation warning rather than an error?

[aaron.ballman]

clang/lib/Parse/Parser.cpp

1165

Still, I wanted to discuss whether you think we need to reinstate support for this (incorrect) usage temporarily, with a deprecation warning rather than an error?

I think it depends heavily on what's been impacted. If it's application code, the error is fine because it's pretty trivial to fix. If it's system header or popular 3rd party library code, then a warning might make more sense.

It's worth noting that what we accepted didn't have any semantic impact anyway. We would accept the attribute, but not actually add it into the AST: https://godbolt.org/z/q7n1794Tx. So I'm not certain there's any harm aside from the annoyance of getting an error where you didn't previously get one before.

[mboehme]

In D126061#3585681, @nikic wrote:

FYI this change had a measurable effect on compile-time (http://llvm-compile-time-tracker.com/compare.php?from=7acc88be0312c721bc082ed9934e381d297f4707&to=8c7b64b5ae2a09027c38db969a04fc9ddd0cd6bb&stat=instructions), about 0.5% regression for O0 builds. Not sure if that's expected.

I've found the reason for this slowdown, and a fix.

In a number of places, this patch adds additional local variables of type ParsedAttributes, typically because we need to keep track of declaration and decl-specifier-seq attributes in two separate ParsedAttribute lists where previously we were putting them in the same list. Note that in the vast majority of cases, these ParsedAttributes lists are empty.

I would have assumed that creating an empty ParsedAttributes, potentially iterating over it, then destroying it, is cheap. However, this is not true for ParsedAttributes because it uses a TinyPtrVector as the underlying container. The same is true for the AttributePool that ParsedAttributes contains.

TinyPtrVector is amazingly memory-frugal in that it consumes only a single pointer worth of memory if the vector contains zero or one elements. However, this comes at a cost: begin() and end() on this container are relatively expensive. As a result, iterating over an empty TinyPtrVector is relatively expensive.

The destructor of ParsedAttributes iterates over its AttributePool. As a result, merely creating an empty ParsedAttributes, then destroying it is a relatively slow operation. My patch does this on the order of one additional time per declaration, and this is enough to cause the observed slowdown.

The fix for this is simply to replace the TinyPtrVector in ParsedAttributes and AttributePool with a SmallVector. The extreme memory frugality of TinyPtrVector is not actually necessary in ParsedAttributes and AttributePool: These objects are not part of the AST; they are only allocated on the heap, and only a small number of them are ever in existence at any given time. Spending a few bytes more on a SmallVector has a negligible effect on memory usage, but makes iterating over the vector much faster.

In fact, making this change not only fixes the slowdown observed on this patch but actually makes compiles run slightly faster than they did before this patch.

I'll be submitting a patch with the fix described above but wanted to get this information out ahead of time.

[mboehme]

Fix for compile time regression submitted for review at https://reviews.llvm.org/D128097

[mboehme]

https://reviews.llvm.org/D128097 is now submitted. Unfortunately, it didn't fix the compile-time regression entirely (see detailed comments there).

I'll do some more investigation to see where the rest of the slowdown is coming from.

[miyuki]

Hi Martin,

I think this patch caused a regression in diagnostics. Clang used to warn about the following code:

struct X {
    [[deprecated]] struct Y {};
};

$ clang -std=c++17 -Wall test.cpp
<source>:2:7: warning: attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration [-Wignored-attributes]
    [[deprecated]] struct Y {};
      ^

And now it doesn't. Could you please have a look into it?

[aaron.ballman]

In D126061#3605276, @miyuki wrote:

Hi Martin,

I think this patch caused a regression in diagnostics. Clang used to warn about the following code:

struct X {
    [[deprecated]] struct Y {};
};

$ clang -std=c++17 -Wall test.cpp
<source>:2:7: warning: attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration [-Wignored-attributes]
    [[deprecated]] struct Y {};
      ^

And now it doesn't. Could you please have a look into it?

Good catch, that does appear to be a regression:

http://eel.is/c++draft/class#nt:member-declaration
http://eel.is/c++draft/class#mem.general-14

[mboehme]

In D126061#3605276, @miyuki wrote:

Hi Martin,

I think this patch caused a regression in diagnostics. Clang used to warn about the following code:

[snip]

And now it doesn't. Could you please have a look into it?

Thanks for alerting me to this! I'll investigate and will submit a fix.

[mboehme]

Fix in review at https://reviews.llvm.org/D128499

clang/include/clang/Basic/AttributeCommonInfo.h

public:
   /// with surrounding underscores removed as appropriate (e.g.
   /// __gnu__::__attr__ will be normalized to gnu::attr).
   std::string getNormalizedFullName() const;
 
   bool isDeclspecAttribute() const { return SyntaxUsed == AS_Declspec; }
   bool isMicrosoftAttribute() const { return SyntaxUsed == AS_Microsoft; }
 
   bool isGNUScope() const;
+  bool isClangScope() const;
 
   bool isAlignasAttribute() const {
     // FIXME: Use a better mechanism to determine this.
     return getParsedKind() == AT_Aligned && isKeywordAttribute();
   }
 
   bool isCXX11Attribute() const {
     return SyntaxUsed == AS_CXX11 || isAlignasAttribute();
   }
 
   bool isC2xAttribute() const { return SyntaxUsed == AS_C2x; }
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def note_attribute_has_no_effect_on_infinite_loop_here : Note<
   "annotating the infinite loop here">;
 def warn_attribute_has_no_effect_on_compile_time_if : Warning<
   "attribute %0 has no effect when annotating an 'if %select{constexpr|consteval}1' statement">,
    InGroup<IgnoredAttributes>;
 def note_attribute_has_no_effect_on_compile_time_if_here : Note<
   "annotating the 'if %select{constexpr|consteval}0' statement here">;
 def err_decl_attribute_invalid_on_stmt : Error<
   "%0 attribute cannot be applied to a statement">;
-def err_stmt_attribute_invalid_on_decl : Error<
+def err_attribute_invalid_on_decl : Error<
   "%0 attribute cannot be applied to a declaration">;
+def warn_type_attribute_deprecated_on_decl : Warning<
+  "applying attribute %0 to a declaration is deprecated; apply it to the type instead">,
+  InGroup<DeprecatedAttributes>;
 def warn_declspec_attribute_ignored : Warning<
   "attribute %0 is ignored, place it after "
   "\"%select{class|struct|interface|union|enum}1\" to apply attribute to "
   "type declaration">, InGroup<IgnoredAttributes>;
 def warn_attribute_precede_definition : Warning<
   "attribute declaration must precede definition">,
   InGroup<IgnoredAttributes>;
 def warn_attribute_void_function_method : Warning<

clang/include/clang/Parse/Parser.h

private:
   StmtResult
   ParseStatement(SourceLocation *TrailingElseLoc = nullptr,
                  ParsedStmtContext StmtCtx = ParsedStmtContext::SubStmt);
   StmtResult ParseStatementOrDeclaration(
       StmtVector &Stmts, ParsedStmtContext StmtCtx,
       SourceLocation *TrailingElseLoc = nullptr);
   StmtResult ParseStatementOrDeclarationAfterAttributes(
       StmtVector &Stmts, ParsedStmtContext StmtCtx,
-      SourceLocation *TrailingElseLoc, ParsedAttributes &Attrs);
+      SourceLocation *TrailingElseLoc, ParsedAttributes &DeclAttrs,
+      ParsedAttributes &DeclSpecAttrs);
   StmtResult ParseExprStatement(ParsedStmtContext StmtCtx);
   StmtResult ParseLabeledStatement(ParsedAttributes &Attrs,
                                    ParsedStmtContext StmtCtx);
   StmtResult ParseCaseStatement(ParsedStmtContext StmtCtx,
                                 bool MissingCase = false,
                                 ExprResult Expr = ExprResult());
   StmtResult ParseDefaultStatement(ParsedStmtContext StmtCtx);
   StmtResult ParseCompoundStatement(bool isStmtExpr = false);
struct ForRangeInit {
     bool ParsedForRangeDecl() { return !ColonLoc.isInvalid(); }
   };
   struct ForRangeInfo : ForRangeInit {
     StmtResult LoopVar;
   };
 
   DeclGroupPtrTy ParseDeclaration(DeclaratorContext Context,
                                   SourceLocation &DeclEnd,
-                                  ParsedAttributes &Attrs,
+                                  ParsedAttributes &DeclAttrs,
+                                  ParsedAttributes &DeclSpecAttrs,
                                   SourceLocation *DeclSpecStart = nullptr);
   DeclGroupPtrTy
   ParseSimpleDeclaration(DeclaratorContext Context, SourceLocation &DeclEnd,
-                         ParsedAttributes &Attrs, bool RequireSemi,
+                         ParsedAttributes &DeclAttrs,
+                         ParsedAttributes &DeclSpecAttrs, 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(),

clang/include/clang/Parse/RAIIObjectsForParser.h

public:
     }
   };
 
   /// A class for parsing a declarator.
   class ParsingDeclarator : public Declarator {
     ParsingDeclRAIIObject ParsingRAII;
 
   public:
-    ParsingDeclarator(Parser &P, const ParsingDeclSpec &DS, DeclaratorContext C)
-      : Declarator(DS, C), ParsingRAII(P, &DS.getDelayedDiagnosticPool()) {
-    }
+    ParsingDeclarator(Parser &P, const ParsingDeclSpec &DS,
+                      const ParsedAttributes &DeclarationAttrs,
+                      DeclaratorContext C)
+        : Declarator(DS, DeclarationAttrs, C),
+          ParsingRAII(P, &DS.getDelayedDiagnosticPool()) {}
 
     const ParsingDeclSpec &getDeclSpec() const {
       return static_cast<const ParsingDeclSpec&>(Declarator::getDeclSpec());
     }
 
     ParsingDeclSpec &getMutableDeclSpec() const {
       return const_cast<ParsingDeclSpec&>(getDeclSpec());
     }
 
     void clear() {
       Declarator::clear();
       ParsingRAII.reset();
     }
 
     void complete(Decl *D) {
       ParsingRAII.complete(D);
     }
   };
 
   /// A class for parsing a field declarator.
   class ParsingFieldDeclarator : public FieldDeclarator {
     ParsingDeclRAIIObject ParsingRAII;
 
   public:
-    ParsingFieldDeclarator(Parser &P, const ParsingDeclSpec &DS)
-      : FieldDeclarator(DS), ParsingRAII(P, &DS.getDelayedDiagnosticPool()) {
-    }
+    ParsingFieldDeclarator(Parser &P, const ParsingDeclSpec &DS,
+                           const ParsedAttributes &DeclarationAttrs)
+        : FieldDeclarator(DS, DeclarationAttrs),
+          ParsingRAII(P, &DS.getDelayedDiagnosticPool()) {}
 
     const ParsingDeclSpec &getDeclSpec() const {
       return static_cast<const ParsingDeclSpec&>(D.getDeclSpec());
     }
 
     ParsingDeclSpec &getMutableDeclSpec() const {
       return const_cast<ParsingDeclSpec&>(getDeclSpec());
     }

clang/include/clang/Sema/DeclSpec.h

private:
   unsigned ObjCWeakProperty : 1;
 
   /// Indicates whether the InlineParams / InlineBindings storage has been used.
   unsigned InlineStorageUsed : 1;
 
   /// Indicates whether this declarator has an initializer.
   unsigned HasInitializer : 1;
 
-  /// Attrs - Attributes.
+  /// Attributes attached to the DeclSpec.
   ParsedAttributes Attrs;
 
+  /// Attributes attached to the declaration. See also documentation for the
+  /// corresponding constructor parameter.
+  const ParsedAttributes &DeclarationAttrs;
+
   /// The asm label, if specified.
   Expr *AsmLabel;
 
   /// \brief The constraint-expression specified by the trailing
   /// requires-clause, or null if no such clause was specified.
   Expr *TrailingRequiresClause;
 
   /// If this declarator declares a template, its template parameter lists.
   ArrayRef<TemplateParameterList *> TemplateParameterLists;
#endif
 
   /// If provided, the source location of the ellipsis used to describe
   /// this declarator as a parameter pack.
   SourceLocation EllipsisLoc;
 
   friend struct DeclaratorChunk;
 
 public:
-  Declarator(const DeclSpec &ds, DeclaratorContext C)
+  /// `ds` and `DeclarationAttrs` must outlive the `Declarator`. In particular,
+  /// take care not to pass temporary objects for these parameters.
+  ///
+  /// `DeclarationAttrs` contains [[]] attributes from the
+  /// attribute-specifier-seq at the beginning of a declaration, which appertain
+  /// to the declared entity itself. Attributes with other syntax (e.g. GNU)
+  /// should not be placed in this attribute list; if they occur at the
+  /// beginning of a declaration, they apply to the `DeclSpec` and should be
+  /// attached to that instead.
+  ///
+  /// Here is an example of an attribute associated with a declaration:
+  ///
+  ///  [[deprecated]] int x, y;
+  ///
+  /// This attribute appertains to all of the entities declared in the
+  /// declaration, i.e. `x` and `y` in this case.
+  Declarator(const DeclSpec &ds, const ParsedAttributes &DeclarationAttrs,
+             DeclaratorContext C)
       : DS(ds), Range(ds.getSourceRange()), Context(C),
         InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
         GroupingParens(false), FunctionDefinition(static_cast<unsigned>(
                                    FunctionDefinitionKind::Declaration)),
         Redeclaration(false), Extension(false), ObjCIvar(false),
         ObjCWeakProperty(false), InlineStorageUsed(false),
         HasInitializer(false), Attrs(ds.getAttributePool().getFactory()),
-        AsmLabel(nullptr), TrailingRequiresClause(nullptr),
-        InventedTemplateParameterList(nullptr) {}
+        DeclarationAttrs(DeclarationAttrs), AsmLabel(nullptr),
+        TrailingRequiresClause(nullptr),
+        InventedTemplateParameterList(nullptr) {
+    assert(llvm::all_of(DeclarationAttrs, [](const ParsedAttr &AL) {
+      return AL.isStandardAttributeSyntax();
+    }));
+  }
 
   ~Declarator() {
     clear();
   }
   /// getDeclSpec - Return the declaration-specifier that this declarator was
   /// declared with.
   const DeclSpec &getDeclSpec() const { return DS; }
 
public:
   void ExtendWithDeclSpec(const DeclSpec &DS) {
     SourceRange SR = DS.getSourceRange();
     if (Range.getBegin().isInvalid())
       Range.setBegin(SR.getBegin());
     if (!SR.getEnd().isInvalid())
       Range.setEnd(SR.getEnd());
   }
 
   /// Reset the contents of this Declarator.
   void clear() {
     SS.clear();
     Name.clear();
     Range = DS.getSourceRange();
     BindingGroup.clear();
 
     for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i)
       DeclTypeInfo[i].destroy();
     DeclTypeInfo.clear();
     Attrs.clear();
void takeAttributes(ParsedAttributes &attrs) {
 
     if (attrs.Range.getEnd().isValid())
       SetRangeEnd(attrs.Range.getEnd());
   }
 
   const ParsedAttributes &getAttributes() const { return Attrs; }
   ParsedAttributes &getAttributes() { return Attrs; }
 
+  const ParsedAttributes &getDeclarationAttributes() const {
+    return DeclarationAttrs;
+  }
+
   /// hasAttributes - do we contain any attributes?
   bool hasAttributes() const {
-    if (!getAttributes().empty() || getDeclSpec().hasAttributes())
+    if (!getAttributes().empty() || !getDeclarationAttributes().empty() ||
+        getDeclSpec().hasAttributes())
       return true;
     for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i)
       if (!getTypeObject(i).getAttrs().empty())
         return true;
     return false;
   }
 
   /// Return a source range list of C++11 attributes associated
public:
   bool isRedeclaration() const { return Redeclaration; }
 };
 
 /// This little struct is used to capture information about
 /// structure field declarators, which is basically just a bitfield size.
 struct FieldDeclarator {
   Declarator D;
   Expr *BitfieldSize;
-  explicit FieldDeclarator(const DeclSpec &DS)
-      : D(DS, DeclaratorContext::Member), BitfieldSize(nullptr) {}
+  explicit FieldDeclarator(const DeclSpec &DS,
+                           const ParsedAttributes &DeclarationAttrs)
+      : D(DS, DeclarationAttrs, DeclaratorContext::Member),
+        BitfieldSize(nullptr) {}
 };
 
 /// Represents a C++11 virt-specifier-seq.
 class VirtSpecifiers {
 public:
   enum Specifier {
     VS_None = 0,
     VS_Override = 1,

clang/include/clang/Sema/ParsedAttr.h

public:
   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;
 
+  /// Returns whether a [[]] attribute, if specified ahead of a declaration,
+  /// should be applied to the decl-specifier-seq instead (i.e. whether it
+  /// "slides" to the decl-specifier-seq).
+  ///
+  /// By the standard, attributes specified before the declaration always
+  /// appertain to the declaration, but historically we have allowed some of
+  /// these attributes to slide to the decl-specifier-seq, so we need to keep
+  /// supporting this behavior.
+  ///
+  /// This may only be called if isStandardAttributeSyntax() returns true.
+  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;
 
   /// If this is an OpenCL address space attribute, returns its representation
addNewPropertyAttr(IdentifierInfo *attrName, SourceRange attrRange,
     addAtEnd(attr);
     return attr;
   }
 
 private:
   mutable AttributePool pool;
 };
 
+/// Consumes the attributes from `First` and `Second` and concatenates them into
+/// `Result`. Sets `Result.Range` to the combined range of `First` and `Second`.
+void ConcatenateAttributes(ParsedAttributes &First, ParsedAttributes &Second,
+                           ParsedAttributes &Result);
+
 /// These constants match the enumerated choices of
 /// err_attribute_argument_n_type and err_attribute_argument_type.
 enum AttributeArgumentNType {
   AANT_ArgumentIntOrBool,
   AANT_ArgumentIntegerConstant,
   AANT_ArgumentString,
   AANT_ArgumentIdentifier,
   AANT_ArgumentConstantExpr,

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);
+
+  // Options for ProcessDeclAttributeList().
+  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;
+    }
+
+    // Should C++11 attributes be processed?
+    bool IncludeCXX11Attributes;
+
+    // Should any type attributes encountered be ignored?
+    // If this option is false, a diagnostic will be emitted for any type
+    // attributes of a kind that does not "slide" from the declaration to
+    // the decl-specifier-seq.
+    bool IgnoreTypeAttributes;
+  };
+
+  void ProcessDeclAttributeList(Scope *S, Decl *D,
+                                const ParsedAttributesView &AttrList,
+                                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/Basic/Attributes.cpp

static StringRef normalizeAttrName(const IdentifierInfo *Name,
 
   return AttrName;
 }
 
 bool AttributeCommonInfo::isGNUScope() const {
   return ScopeName && (ScopeName->isStr("gnu") || ScopeName->isStr("__gnu__"));
 }
 
+bool AttributeCommonInfo::isClangScope() const {
+  return ScopeName && (ScopeName->isStr("clang") || ScopeName->isStr("_Clang"));
+}
+
 #include "clang/Sema/AttrParsedAttrKinds.inc"
 
 static SmallString<64> normalizeName(const IdentifierInfo *Name,
                                      const IdentifierInfo *Scope,
                                      AttributeCommonInfo::Syntax SyntaxUsed) {
   StringRef ScopeName = normalizeAttrScopeName(Scope, SyntaxUsed);
   StringRef AttrName = normalizeAttrName(Name, ScopeName, SyntaxUsed);
 

clang/lib/Parse/ParseDecl.cpp

TypeResult Parser::ParseTypeName(SourceRange *Range, DeclaratorContext Context,
   DeclSpec DS(AttrFactory);
   if (Attrs)
     DS.addAttributes(*Attrs);
   ParseSpecifierQualifierList(DS, AS, DSC);
   if (OwnedType)
     *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : nullptr;
 
   // Parse the abstract-declarator, if present.
-  Declarator DeclaratorInfo(DS, Context);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs, Context);
   ParseDeclarator(DeclaratorInfo);
   if (Range)
     *Range = DeclaratorInfo.getSourceRange();
 
   if (DeclaratorInfo.isInvalidType())
     return true;
 
   return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);

 /// [C++]   namespace-definition
 /// [C++]   using-directive
 /// [C++]   using-declaration
 /// [C++11/C11] static_assert-declaration
 ///         others... [FIXME]
 ///
 Parser::DeclGroupPtrTy Parser::ParseDeclaration(DeclaratorContext Context,
                                                 SourceLocation &DeclEnd,
-                                                ParsedAttributes &Attrs,
+                                                ParsedAttributes &DeclAttrs,
+                                                ParsedAttributes &DeclSpecAttrs,
                                                 SourceLocation *DeclSpecStart) {
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
   // Must temporarily exit the objective-c container scope for
   // parsing c none objective-c decls.
   ObjCDeclContextSwitch ObjCDC(*this);
 
   Decl *SingleDecl = nullptr;
   switch (Tok.getKind()) {
   case tok::kw_template:
   case tok::kw_export:
-    ProhibitAttributes(Attrs);
-    SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd, Attrs);
+    ProhibitAttributes(DeclAttrs);
+    ProhibitAttributes(DeclSpecAttrs);
+    SingleDecl =
+        ParseDeclarationStartingWithTemplate(Context, DeclEnd, DeclAttrs);
     break;
   case tok::kw_inline:
     // Could be the start of an inline namespace. Allowed as an ext in C++03.
     if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
-      ProhibitAttributes(Attrs);
+      ProhibitAttributes(DeclAttrs);
+      ProhibitAttributes(DeclSpecAttrs);
       SourceLocation InlineLoc = ConsumeToken();
       return ParseNamespace(Context, DeclEnd, InlineLoc);
     }
-    return ParseSimpleDeclaration(Context, DeclEnd, Attrs, true, nullptr,
-                                  DeclSpecStart);
+    return ParseSimpleDeclaration(Context, DeclEnd, DeclAttrs, DeclSpecAttrs,
+                                  true, nullptr, DeclSpecStart);
   case tok::kw_namespace:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(DeclAttrs);
+    ProhibitAttributes(DeclSpecAttrs);
     return ParseNamespace(Context, DeclEnd);
-  case tok::kw_using:
+  case tok::kw_using: {
+    ParsedAttributes Attrs(AttrFactory);
+    ConcatenateAttributes(DeclAttrs, DeclSpecAttrs, Attrs);
     return ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
                                             DeclEnd, Attrs);
+  }
   case tok::kw_static_assert:
   case tok::kw__Static_assert:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(DeclAttrs);
+    ProhibitAttributes(DeclSpecAttrs);
     SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
     break;
   default:
-    return ParseSimpleDeclaration(Context, DeclEnd, Attrs, true, nullptr,
-                                  DeclSpecStart);
+    return ParseSimpleDeclaration(Context, DeclEnd, DeclAttrs, DeclSpecAttrs,
+                                  true, nullptr, DeclSpecStart);
   }
 
   // This routine returns a DeclGroup, if the thing we parsed only contains a
   // single decl, convert it now.
   return Actions.ConvertDeclToDeclGroup(SingleDecl);
 }
 
 ///       simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]

 /// If FRI is non-null, we might be parsing a for-range-declaration instead
 /// of a simple-declaration. If we find that we are, we also parse the
 /// for-range-initializer, and place it here.
 ///
 /// DeclSpecStart is used when decl-specifiers are parsed before parsing
 /// the Declaration. The SourceLocation for this Decl is set to
 /// DeclSpecStart if DeclSpecStart is non-null.
 Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(
-    DeclaratorContext Context, SourceLocation &DeclEnd, ParsedAttributes &Attrs,
+    DeclaratorContext Context, SourceLocation &DeclEnd,
+    ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs,
     bool RequireSemi, ForRangeInit *FRI, SourceLocation *DeclSpecStart) {
   // Parse the common declaration-specifiers piece.
   ParsingDeclSpec DS(*this);
 
   DeclSpecContext DSContext = getDeclSpecContextFromDeclaratorContext(Context);
   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, DSContext);
 
   // If we had a free-standing type definition with a missing semicolon, we
   // may get this far before the problem becomes obvious.
   if (DS.hasTagDefinition() &&
       DiagnoseMissingSemiAfterTagDefinition(DS, AS_none, DSContext))
     return nullptr;
 
   // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
   // declaration-specifiers init-declarator-list[opt] ';'
   if (Tok.is(tok::semi)) {
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(DeclAttrs);
+    ProhibitAttributes(DeclSpecAttrs);
     DeclEnd = Tok.getLocation();
     if (RequireSemi) ConsumeToken();
     RecordDecl *AnonRecord = nullptr;
     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
                                                        DS, AnonRecord);
     DS.complete(TheDecl);
     if (AnonRecord) {
       Decl* decls[] = {AnonRecord, TheDecl};
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
   if (DeclSpecStart)
     DS.SetRangeStart(*DeclSpecStart);
 
-  DS.takeAttributesFrom(Attrs);
-  return ParseDeclGroup(DS, Context, &DeclEnd, FRI);
+  DS.takeAttributesFrom(DeclSpecAttrs);
+  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);
+  // Consume all of the attributes from `Attrs` my moving them to our own local
+  // list. This ensures that we will not attempt to interpret them as statement
+  // attributes higher up the callchain.
+  ParsedAttributes LocalAttrs(AttrFactory);
+  LocalAttrs.takeAllFrom(Attrs);
+  ParsingDeclarator D(*this, DS, LocalAttrs, Context);
   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.
     D.clear();
     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);
-  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)) {
+    // C2x 6.7.2.1p9 : "The optional attribute specifier sequence in a
+    // member declaration appertains to each of the members declared by the
+    // member declarator list; it shall not appear if the optional member
+    // declarator list is omitted."
+    ProhibitAttributes(Attrs);
     RecordDecl *AnonRecord = nullptr;
     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);
+    ParsingFieldDeclarator DeclaratorInfo(*this, DS, Attrs);
     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) {
     // or an error, bail out.
     if (!TryConsumeToken(tok::comma, CommaLoc))
       return;
 
     FirstDeclarator = false;
   }
 }
 
 /// ParseStructUnionBody
 ///       struct-contents:
 ///         struct-declaration-list
 /// [EXT]   empty
 /// [GNU]   "struct-declaration-list" without terminating ';'
 ///       struct-declaration-list:
 ///         struct-declaration
 ///         struct-declaration-list struct-declaration
 /// [OBC]   '@' 'defs' '(' class-name ')'
if (CanBeBitfield && !isEnumBase(CanBeOpaqueEnumDeclaration)) {
       SourceLocation ColonLoc = ConsumeToken();
 
       // Parse a type-specifier-seq as a type. We can't just ParseTypeName here,
       // because under -fms-extensions,
       //   enum E : int *p;
       // declares 'enum E : int; E *p;' not 'enum E : int*; E p;'.
       DeclSpec DS(AttrFactory);
       ParseSpecifierQualifierList(DS, AS, DeclSpecContext::DSC_type_specifier);
-      Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+      ParsedAttributes EmptyDeclAttrs(AttrFactory);
+      Declarator DeclaratorInfo(DS, EmptyDeclAttrs,
+                                DeclaratorContext::TypeName);
       BaseType = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
 
       BaseRange = SourceRange(ColonLoc, DeclaratorInfo.getSourceRange().getEnd());
 
       if (!getLangOpts().ObjC) {
         if (getLangOpts().CPlusPlus11)
           Diag(ColonLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type)
               << BaseRange;
void Parser::InitCXXThisScopeForDeclaratorIfRelevant(
   ThisScope.emplace(Actions, dyn_cast<CXXRecordDecl>(Actions.CurContext), Q,
                     IsCXX11MemberFunction);
 }
 
 /// ParseFunctionDeclarator - We are after the identifier and have parsed the
 /// declarator D up to a paren, which indicates that we are parsing function
 /// arguments.
 ///
-/// If FirstArgAttrs is non-null, then the caller parsed those arguments
-/// immediately after the open paren - they should be considered to be the
-/// first argument of a parameter.
+/// If FirstArgAttrs is non-null, then the caller parsed those attributes
+/// immediately after the open paren - they will be applied to the DeclSpec
+/// of the first parameter.
 ///
 /// If RequiresArg is true, then the first argument of the function is required
 /// to be present and required to not be an identifier list.
 ///
 /// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],
 /// (C++11) ref-qualifier[opt], exception-specification[opt],
 /// (C++11) attribute-specifier-seq[opt], (C++11) trailing-return-type[opt] and
 /// (C++2a) the trailing requires-clause.

 }
 
 /// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
 /// after the opening parenthesis. This function will not parse a K&R-style
 /// identifier list.
 ///
 /// DeclContext is the context of the declarator being parsed.  If FirstArgAttrs
 /// is non-null, then the caller parsed those attributes immediately after the
-/// open paren - they should be considered to be part of the first parameter.
+/// open paren - they will be applied to the DeclSpec of the first parameter.
 ///
 /// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
 /// be the location of the ellipsis, if any was parsed.
 ///
 ///       parameter-type-list: [C99 6.7.5]
 ///         parameter-list
 ///         parameter-list ',' '...'
 /// [C++]   parameter-list '...'
do {
     // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
     // 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);
 
+    ParsedAttributes ArgDeclAttrs(AttrFactory);
+    ParsedAttributes ArgDeclSpecAttrs(AttrFactory);
+
+    if (FirstArgAttrs.Range.isValid()) {
+      // 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.
+      // We have already started parsing the decl-specifier sequence, so don't
+      // parse any parameter-declaration pieces that precede it.
+      ArgDeclSpecAttrs.takeAllFrom(FirstArgAttrs);
+    } else {
       // Parse any C++11 attributes.
-    MaybeParseCXX11Attributes(DS.getAttributes());
+      MaybeParseCXX11Attributes(ArgDeclAttrs);
 
       // Skip any Microsoft attributes before a param.
-    MaybeParseMicrosoftAttributes(DS.getAttributes());
+      MaybeParseMicrosoftAttributes(ArgDeclSpecAttrs);
+    }
 
     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.
-    // 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);
-
     ParseDeclarationSpecifiers(DS);
-
+    DS.takeAttributesFrom(ArgDeclSpecAttrs);
 
     // Parse the declarator.  This is "PrototypeContext" or
     // "LambdaExprParameterContext", because we must accept either
     // 'declarator' or 'abstract-declarator' here.
-    Declarator ParmDeclarator(
-        DS, DeclaratorCtx == DeclaratorContext::RequiresExpr
+    Declarator ParmDeclarator(DS, ArgDeclAttrs,
+                              DeclaratorCtx == DeclaratorContext::RequiresExpr
                                   ? DeclaratorContext::RequiresExpr
                               : DeclaratorCtx == DeclaratorContext::LambdaExpr
                                   ? DeclaratorContext::LambdaExprParameter
                                   : DeclaratorContext::Prototype);
     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,

 }
 
 /// Diagnose brackets before an identifier.
 void Parser::ParseMisplacedBracketDeclarator(Declarator &D) {
   assert(Tok.is(tok::l_square) && "Missing opening bracket");
   assert(!D.mayOmitIdentifier() && "Declarator cannot omit identifier");
 
   SourceLocation StartBracketLoc = Tok.getLocation();
-  Declarator TempDeclarator(D.getDeclSpec(), D.getContext());
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator TempDeclarator(D.getDeclSpec(), EmptyDeclAttrs, D.getContext());
 
   while (Tok.is(tok::l_square)) {
     ParseBracketDeclarator(TempDeclarator);
   }
 
   // Stuff the location of the start of the brackets into the Declarator.
   // The diagnostics from ParseDirectDeclarator will make more sense if
   // they use this location instead.

clang/lib/Parse/ParseDeclCXX.cpp

Decl *Parser::ParseLinkage(ParsingDeclSpec &DS, DeclaratorContext Context) {
   ParseScope LinkageScope(this, Scope::DeclScope);
   Decl *LinkageSpec =
       Lang.isInvalid()
           ? nullptr
           : Actions.ActOnStartLinkageSpecification(
                 getCurScope(), DS.getSourceRange().getBegin(), Lang.get(),
                 Tok.is(tok::l_brace) ? Tok.getLocation() : SourceLocation());
 
-  ParsedAttributes attrs(AttrFactory);
-  MaybeParseCXX11Attributes(attrs);
+  ParsedAttributes DeclAttrs(AttrFactory);
+  MaybeParseCXX11Attributes(DeclAttrs);
 
   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);
-    ParseExternalDeclaration(attrs, &DS);
+    ParseExternalDeclaration(DeclAttrs, &DS);
     return LinkageSpec ? Actions.ActOnFinishLinkageSpecification(
                              getCurScope(), LinkageSpec, SourceLocation())
                        : nullptr;
   }
 
   DS.abort();
 
-  ProhibitAttributes(attrs);
+  ProhibitAttributes(DeclAttrs);
 
   BalancedDelimiterTracker T(*this, tok::l_brace);
   T.consumeOpen();
 
   unsigned NestedModules = 0;
   while (true) {
     switch (Tok.getKind()) {
     case tok::annot_module_begin:
if (Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) {
     if (SS.isNotEmpty())
       Diag(SS.getBeginLoc(), diag::err_unexpected_scope_on_base_decltype)
         << FixItHint::CreateRemoval(SS.getRange());
     // Fake up a Declarator to use with ActOnTypeName.
     DeclSpec DS(AttrFactory);
 
     EndLocation = ParseDecltypeSpecifier(DS);
 
-    Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+    ParsedAttributes EmptyDeclAttrs(AttrFactory);
+    Declarator DeclaratorInfo(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
     return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
   }
 
   // Check whether we have a template-id that names a type.
   if (Tok.is(tok::annot_template_id)) {
     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
     if (TemplateId->mightBeType()) {
       AnnotateTemplateIdTokenAsType(SS, /*IsClassName*/true);
TypeResult Parser::ParseBaseTypeSpecifier(SourceLocation &BaseLoc,
   DS.SetRangeEnd(EndLocation);
   DS.getTypeSpecScope() = SS;
 
   const char *PrevSpec = nullptr;
   unsigned DiagID;
   DS.SetTypeSpecType(TST_typename, IdLoc, PrevSpec, DiagID, Type,
                      Actions.getASTContext().getPrintingPolicy());
 
-  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
   return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
 }
 
 void Parser::ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs) {
   while (Tok.isOneOf(tok::kw___single_inheritance,
                      tok::kw___multiple_inheritance,
                      tok::kw___virtual_inheritance)) {
     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
   if (Tok.is(tok::kw___extension__)) {
     // __extension__ silences extension warnings in the subexpression.
     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
     ConsumeToken();
     return ParseCXXClassMemberDeclaration(AS, AccessAttrs,
                                           TemplateInfo, TemplateDiags);
   }
 
-  ParsedAttributes attrs(AttrFactory);
-  ParsedAttributesView FnAttrs;
+  ParsedAttributes DeclAttrs(AttrFactory);
   // Optional C++11 attribute-specifier
-  MaybeParseCXX11Attributes(attrs);
+  MaybeParseCXX11Attributes(DeclAttrs);
 
   // 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);
+    return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, DeclAttrs);
 
-  // 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);
+  // We need to keep these attributes for future diagnostics
+  // before they are taken over by the declaration.
+  ParsedAttributesView FnAttrs;
+  FnAttrs.addAll(DeclAttrs.begin(), DeclAttrs.end());
+  FnAttrs.Range = DeclAttrs.Range;
 
   if (Tok.is(tok::kw_using)) {
     // Eat 'using'.
     SourceLocation UsingLoc = ConsumeToken();
 
     // Consume unexpected 'template' keywords.
     while (Tok.is(tok::kw_template)) {
       SourceLocation TemplateLoc = ConsumeToken();
       Diag(TemplateLoc, diag::err_unexpected_template_after_using)
           << FixItHint::CreateRemoval(TemplateLoc);
     }
 
     if (Tok.is(tok::kw_namespace)) {
       Diag(UsingLoc, diag::err_using_namespace_in_class);
       SkipUntil(tok::semi, StopBeforeMatch);
       return nullptr;
     }
     SourceLocation DeclEnd;
     // Otherwise, it must be a using-declaration or an alias-declaration.
     return ParseUsingDeclaration(DeclaratorContext::Member, TemplateInfo,
-                                 UsingLoc, DeclEnd, attrs, AS);
+                                 UsingLoc, DeclEnd, DeclAttrs, AS);
   }
 
+  ParsedAttributes DeclSpecAttrs(AttrFactory);
+  MaybeParseMicrosoftAttributes(DeclSpecAttrs);
+
   // 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);
-  DS.takeAttributesFrom(attrs);
+  DS.takeAttributesFrom(DeclSpecAttrs);
+
   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
   // explicit instantiation and explicit specialization.
if (TryConsumeToken(tok::semi)) {
     DS.complete(TheDecl);
     if (AnonRecord) {
       Decl* decls[] = {AnonRecord, TheDecl};
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
-  ParsingDeclarator DeclaratorInfo(*this, DS, DeclaratorContext::Member);
+  ParsingDeclarator DeclaratorInfo(*this, DS, DeclAttrs,
+                                   DeclaratorContext::Member);
   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;

clang/lib/Parse/ParseExpr.cpp

if (getLangOpts().ObjC &&
             DeclSpec DS(AttrFactory);
             DS.SetRangeStart(ILoc);
             DS.SetRangeEnd(ILoc);
             const char *PrevSpec = nullptr;
             unsigned DiagID;
             DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ,
                                Actions.getASTContext().getPrintingPolicy());
 
-            Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+            ParsedAttributes EmptyDeclAttrs(AttrFactory);
+            Declarator DeclaratorInfo(DS, EmptyDeclAttrs,
+                                      DeclaratorContext::TypeName);
             TypeResult Ty = Actions.ActOnTypeName(getCurScope(),
                                                   DeclaratorInfo);
             if (Ty.isInvalid())
               break;
 
             Res = ParseObjCMessageExpressionBody(SourceLocation(),
                                                  SourceLocation(),
                                                  Ty.get(), nullptr);
if (isStartOfObjCClassMessageMissingOpenBracket()) {
       DS.SetRangeEnd(Tok.getLastLoc());
 
       const char *PrevSpec = nullptr;
       unsigned DiagID;
       DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(),
                          PrevSpec, DiagID, Type,
                          Actions.getASTContext().getPrintingPolicy());
 
-      Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+      ParsedAttributes EmptyDeclAttrs(AttrFactory);
+      Declarator DeclaratorInfo(DS, EmptyDeclAttrs,
+                                DeclaratorContext::TypeName);
       TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
       if (Ty.isInvalid())
         break;
 
       ConsumeAnnotationToken();
       Res = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
                                            Ty.get(), nullptr);
       break;
Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
   if (Tok.isNot(tok::l_paren)) {
     // If construct allows a form without parenthesis, user may forget to put
     // pathenthesis around type name.
     if (OpTok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof,
                       tok::kw__Alignof)) {
       if (isTypeIdUnambiguously()) {
         DeclSpec DS(AttrFactory);
         ParseSpecifierQualifierList(DS);
-        Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+        ParsedAttributes EmptyDeclAttrs(AttrFactory);
+        Declarator DeclaratorInfo(DS, EmptyDeclAttrs,
+                                  DeclaratorContext::TypeName);
         ParseDeclarator(DeclaratorInfo);
 
         SourceLocation LParenLoc = PP.getLocForEndOfToken(OpTok.getLocation());
         SourceLocation RParenLoc = PP.getLocForEndOfToken(PrevTokLocation);
         if (LParenLoc.isInvalid() || RParenLoc.isInvalid()) {
           Diag(OpTok.getLocation(),
                diag::err_expected_parentheses_around_typename)
               << OpTok.getName();
if (isAmbiguousTypeId && !stopIfCastExpr) {
                                                         ColonProtection);
       RParenLoc = T.getCloseLocation();
       return res;
     }
 
     // Parse the type declarator.
     DeclSpec DS(AttrFactory);
     ParseSpecifierQualifierList(DS);
-    Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+    ParsedAttributes EmptyDeclAttrs(AttrFactory);
+    Declarator DeclaratorInfo(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
     ParseDeclarator(DeclaratorInfo);
 
     // If our type is followed by an identifier and either ':' or ']', then
     // this is probably an Objective-C message send where the leading '[' is
     // missing. Recover as if that were the case.
     if (!DeclaratorInfo.isInvalidType() && Tok.is(tok::identifier) &&
         !InMessageExpression && getLangOpts().ObjC &&
         (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) {
if (Tok.is(tok::code_completion)) {
     return;
   }
 
   // Parse the specifier-qualifier-list piece.
   DeclSpec DS(AttrFactory);
   ParseSpecifierQualifierList(DS);
 
   // Parse the block-declarator.
-  Declarator DeclaratorInfo(DS, DeclaratorContext::BlockLiteral);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs,
+                            DeclaratorContext::BlockLiteral);
   DeclaratorInfo.setFunctionDefinitionKind(FunctionDefinitionKind::Definition);
   ParseDeclarator(DeclaratorInfo);
 
   MaybeParseGNUAttributes(DeclaratorInfo);
 
   // Inform sema that we are starting a block.
   Actions.ActOnBlockArguments(CaretLoc, DeclaratorInfo, getCurScope());
 }
ExprResult Parser::ParseBlockLiteralExpression() {
   ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope |
                                   Scope::CompoundStmtScope | Scope::DeclScope);
 
   // Inform sema that we are starting a block.
   Actions.ActOnBlockStart(CaretLoc, getCurScope());
 
   // Parse the return type if present.
   DeclSpec DS(AttrFactory);
-  Declarator ParamInfo(DS, DeclaratorContext::BlockLiteral);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator ParamInfo(DS, EmptyDeclAttrs, DeclaratorContext::BlockLiteral);
   ParamInfo.setFunctionDefinitionKind(FunctionDefinitionKind::Definition);
   // FIXME: Since the return type isn't actually parsed, it can't be used to
   // fill ParamInfo with an initial valid range, so do it manually.
   ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation()));
 
   // If this block has arguments, parse them.  There is no ambiguity here with
   // the expression case, because the expression case requires a parameter list.
   if (Tok.is(tok::l_paren)) {

clang/lib/Parse/ParseExprCXX.cpp

ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
 
 
 
   // FIXME: Call into Actions to add any init-capture declarations to the
   // scope while parsing the lambda-declarator and compound-statement.
 
   // Parse lambda-declarator[opt].
   DeclSpec DS(AttrFactory);
-  Declarator D(DS, DeclaratorContext::LambdaExpr);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator D(DS, EmptyDeclAttrs, DeclaratorContext::LambdaExpr);
   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
   Actions.PushLambdaScope();
 
   ParsedAttributes Attr(AttrFactory);
   if (getLangOpts().CUDA) {
     // In CUDA code, GNU attributes are allowed to appear immediately after the
     // "[...]", even if there is no "(...)" before the lambda body.
     MaybeParseGNUAttributes(D);
ExprResult Parser::ParseCXXCasts() {
   if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
     return ExprError();
 
   // Parse the common declaration-specifiers piece.
   DeclSpec DS(AttrFactory);
   ParseSpecifierQualifierList(DS);
 
   // Parse the abstract-declarator, if present.
-  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
   ParseDeclarator(DeclaratorInfo);
 
   SourceLocation RAngleBracketLoc = Tok.getLocation();
 
   if (ExpectAndConsume(tok::greater))
     return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
 
   BalancedDelimiterTracker T(*this, tok::l_paren);

 ///         simple-type-specifier '(' expression-list[opt] ')'
 /// [C++0x] simple-type-specifier braced-init-list
 ///         typename-specifier '(' expression-list[opt] ')'
 /// [C++0x] typename-specifier braced-init-list
 ///
 /// In C++1z onwards, the type specifier can also be a template-name.
 ExprResult
 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
-  Declarator DeclaratorInfo(DS, DeclaratorContext::FunctionalCast);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs,
+                            DeclaratorContext::FunctionalCast);
   ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
 
   assert((Tok.is(tok::l_paren) ||
           (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
          && "Expected '(' or '{'!");
 
   if (Tok.is(tok::l_brace)) {
     PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());
Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc,
 
   case ConditionOrInitStatement::InitStmtDecl: {
     WarnOnInit();
     DeclGroupPtrTy DG;
     SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
     if (Tok.is(tok::kw_using))
       DG = ParseAliasDeclarationInInitStatement(
           DeclaratorContext::SelectionInit, attrs);
-    else
+    else {
+      ParsedAttributes DeclSpecAttrs(AttrFactory);
       DG = ParseSimpleDeclaration(DeclaratorContext::SelectionInit, DeclEnd,
-                                  attrs, /*RequireSemi=*/true);
+                                  attrs, DeclSpecAttrs, /*RequireSemi=*/true);
+    }
     *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
     return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
   }
 
   case ConditionOrInitStatement::ForRangeDecl: {
     // This is 'for (init-stmt; for-range-decl : range-expr)'.
     // We're not actually in a for loop yet, so 'break' and 'continue' aren't
     // permitted here.
     assert(FRI && "should not parse a for range declaration here");
     SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
-    DeclGroupPtrTy DG = ParseSimpleDeclaration(DeclaratorContext::ForInit,
-                                               DeclEnd, attrs, false, FRI);
+    ParsedAttributes DeclSpecAttrs(AttrFactory);
+    DeclGroupPtrTy DG = ParseSimpleDeclaration(
+        DeclaratorContext::ForInit, DeclEnd, attrs, DeclSpecAttrs, false, FRI);
     FRI->LoopVar = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
     assert((FRI->ColonLoc.isValid() || !DG) &&
            "cannot find for range declaration");
     return Sema::ConditionResult();
   }
 
   case ConditionOrInitStatement::ConditionDecl:
   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);
-  DS.takeAttributesFrom(attrs);
   ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_condition);
 
   // declarator
-  Declarator DeclaratorInfo(DS, DeclaratorContext::Condition);
+  Declarator DeclaratorInfo(DS, attrs, DeclaratorContext::Condition);
   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);
#include "clang/Basic/OperatorKinds.def"
 
   // Parse the type-specifier-seq.
   DeclSpec DS(AttrFactory);
   if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
     return true;
 
   // Parse the conversion-declarator, which is merely a sequence of
   // ptr-operators.
-  Declarator D(DS, DeclaratorContext::ConversionId);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator D(DS, EmptyDeclAttrs, DeclaratorContext::ConversionId);
   ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
 
   // Finish up the type.
   TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
   if (Ty.isInvalid())
     return true;
 
   // Note that this is a conversion-function-id.
   Result.setConversionFunctionId(KeywordLoc, Ty.get(),
Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
   // A '(' now can be a new-placement or the '(' wrapping the type-id in the
   // second form of new-expression. It can't be a new-type-id.
 
   ExprVector PlacementArgs;
   SourceLocation PlacementLParen, PlacementRParen;
 
   SourceRange TypeIdParens;
   DeclSpec DS(AttrFactory);
-  Declarator DeclaratorInfo(DS, DeclaratorContext::CXXNew);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs, DeclaratorContext::CXXNew);
   if (Tok.is(tok::l_paren)) {
     // If it turns out to be a placement, we change the type location.
     BalancedDelimiterTracker T(*this, tok::l_paren);
     T.consumeOpen();
     PlacementLParen = T.getOpenLocation();
     if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
       SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
       return ExprError();
PP.EnterTokenStream(Toks, /*DisableMacroExpansion*/ true,
                       /*IsReinject*/ true);
   // Drop the current token and bring the first cached one. It's the same token
   // as when we entered this function.
   ConsumeAnyToken();
 
   if (ParseAs >= CompoundLiteral) {
     // Parse the type declarator.
     DeclSpec DS(AttrFactory);
-    Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+    ParsedAttributes EmptyDeclAttrs(AttrFactory);
+    Declarator DeclaratorInfo(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
     {
       ColonProtectionRAIIObject InnerColonProtection(*this);
       ParseSpecifierQualifierList(DS);
       ParseDeclarator(DeclaratorInfo);
     }
 
     // Match the ')'.
     Tracker.consumeClose();
ExprResult Parser::ParseBuiltinBitCast() {
   if (T.expectAndConsume(diag::err_expected_lparen_after, "__builtin_bit_cast"))
     return ExprError();
 
   // Parse the common declaration-specifiers piece.
   DeclSpec DS(AttrFactory);
   ParseSpecifierQualifierList(DS);
 
   // Parse the abstract-declarator, if present.
-  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
   ParseDeclarator(DeclaratorInfo);
 
   if (ExpectAndConsume(tok::comma)) {
     Diag(Tok.getLocation(), diag::err_expected) << tok::comma;
     SkipUntil(tok::r_paren, StopAtSemi);
     return ExprError();
   }
 

clang/lib/Parse/ParseObjc.cpp

while (true) {
     // If we don't have an @ directive, parse it as a function definition.
     if (Tok.isNot(tok::at)) {
       // The code below does not consume '}'s because it is afraid of eating the
       // end of a namespace.  Because of the way this code is structured, an
       // erroneous r_brace would cause an infinite loop if not handled here.
       if (Tok.is(tok::r_brace))
         break;
 
-      ParsedAttributes attrs(AttrFactory);
+      ParsedAttributes EmptyAttrs(AttrFactory);
 
       // Since we call ParseDeclarationOrFunctionDefinition() instead of
       // ParseExternalDeclaration() below (so that this doesn't parse nested
       // @interfaces), this needs to duplicate some code from the latter.
       if (Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert)) {
         SourceLocation DeclEnd;
-        allTUVariables.push_back(
-            ParseDeclaration(DeclaratorContext::File, DeclEnd, attrs));
+        ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+        allTUVariables.push_back(ParseDeclaration(
+            DeclaratorContext::File, DeclEnd, EmptyAttrs, EmptyDeclSpecAttrs));
         continue;
       }
 
-      allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs));
+      allTUVariables.push_back(
+          ParseDeclarationOrFunctionDefinition(EmptyAttrs));
       continue;
     }
 
     // Otherwise, we have an @ directive, eat the @.
     SourceLocation AtLoc = ConsumeToken(); // the "@"
     if (Tok.is(tok::code_completion)) {
       cutOffParsing();
       Actions.CodeCompleteObjCAtDirective(getCurScope());
for (auto &AL : llvm::reverse(from)) {
     }
   }
 }
 
 /// takeDeclAttributes - Take all the decl attributes from the given
 /// declarator and add them to the given list.
 static void takeDeclAttributes(ParsedAttributes &attrs,
                                Declarator &D) {
+  // This gets called only from Parser::ParseObjCTypeName(), and that should
+  // never add declaration attributes to the Declarator.
+  assert(D.getDeclarationAttributes().empty());
+
   // First, take ownership of all attributes.
   attrs.getPool().takeAllFrom(D.getAttributePool());
   attrs.getPool().takeAllFrom(D.getDeclSpec().getAttributePool());
 
   // Now actually move the attributes over.
   takeDeclAttributes(attrs, D.getMutableDeclSpec().getAttributes());
   takeDeclAttributes(attrs, D.getAttributes());
   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
     takeDeclAttributes(attrs, D.getTypeObject(i).getAttrs());
 }
 
 ///   objc-type-name:
 ///     '(' objc-type-qualifiers[opt] type-name ')'
 ///     '(' objc-type-qualifiers[opt] ')'
 ///
ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS,
   if (isTypeSpecifierQualifier() || isObjCInstancetype()) {
     // Parse an abstract declarator.
     DeclSpec declSpec(AttrFactory);
     declSpec.setObjCQualifiers(&DS);
     DeclSpecContext dsContext = DeclSpecContext::DSC_normal;
     if (context == DeclaratorContext::ObjCResult)
       dsContext = DeclSpecContext::DSC_objc_method_result;
     ParseSpecifierQualifierList(declSpec, AS_none, dsContext);
-    Declarator declarator(declSpec, context);
+    ParsedAttributes EmptyDeclAttrs(AttrFactory);
+    Declarator declarator(declSpec, EmptyDeclAttrs, context);
     ParseDeclarator(declarator);
 
     // If that's not invalid, extract a type.
     if (!declarator.isInvalidType()) {
       // Map a nullability specifier to a context-sensitive keyword attribute.
       bool addedToDeclSpec = false;
       if (DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability)
         addContextSensitiveTypeNullability(*this, declarator,
while (Tok.is(tok::comma)) {
     }
     if (!cStyleParamWarned) {
       Diag(Tok, diag::warn_cstyle_param);
       cStyleParamWarned = true;
     }
     DeclSpec DS(AttrFactory);
     ParseDeclarationSpecifiers(DS);
     // Parse the declarator.
-    Declarator ParmDecl(DS, DeclaratorContext::Prototype);
+    ParsedAttributes EmptyDeclAttrs(AttrFactory);
+    Declarator ParmDecl(DS, EmptyDeclAttrs, DeclaratorContext::Prototype);
     ParseDeclarator(ParmDecl);
     IdentifierInfo *ParmII = ParmDecl.getIdentifier();
     Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
     CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
                                                     ParmDecl.getIdentifierLoc(),
                                                     Param,
                                                     nullptr));
   }
for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
     if (typeArg) {
       DeclSpec DS(AttrFactory);
       const char *prevSpec = nullptr;
       unsigned diagID;
       DS.SetTypeSpecType(TST_typename, identifierLocs[i], prevSpec, diagID,
                          typeArg, Actions.getASTContext().getPrintingPolicy());
 
       // Form a declarator to turn this into a type.
-      Declarator D(DS, DeclaratorContext::TypeName);
+      ParsedAttributes EmptyDeclAttrs(AttrFactory);
+      Declarator D(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
       TypeResult fullTypeArg = Actions.ActOnTypeName(getCurScope(), D);
       if (fullTypeArg.isUsable()) {
         typeArgs.push_back(fullTypeArg.get());
         if (!foundValidTypeId) {
           foundValidTypeId = identifiers[i];
           foundValidTypeSrcLoc = identifierLocs[i];
         }
       } else {
if (Tok.isObjCAtKeyword(tok::objc_catch)) {
       if (Tok.is(tok::l_paren)) {
         ConsumeParen();
         ParseScope CatchScope(this, Scope::DeclScope |
                                         Scope::CompoundStmtScope |
                                         Scope::AtCatchScope);
         if (Tok.isNot(tok::ellipsis)) {
           DeclSpec DS(AttrFactory);
           ParseDeclarationSpecifiers(DS);
-          Declarator ParmDecl(DS, DeclaratorContext::ObjCCatch);
+          ParsedAttributes EmptyDeclAttrs(AttrFactory);
+          Declarator ParmDecl(DS, EmptyDeclAttrs, DeclaratorContext::ObjCCatch);
           ParseDeclarator(ParmDecl);
 
           // Inform the actions module about the declarator, so it
           // gets added to the current scope.
           FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl);
         } else
           ConsumeToken(); // consume '...'
 
if (Tok.is(tok::l_paren)) {
     IsExpr = true;
     TypeOrExpr = Receiver.get();
     return false;
   }
 
   // We have a class message. Turn the simple-type-specifier or
   // typename-specifier we parsed into a type and parse the
   // remainder of the class message.
-  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
   TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
   if (Type.isInvalid())
     return true;
 
   IsExpr = false;
   TypeOrExpr = Type.get().getAsOpaquePtr();
   return false;
 }

clang/lib/Parse/ParseOpenMP.cpp

TypeResult Parser::parseOpenMPDeclareMapperVarDecl(SourceRange &Range,
                                                    AccessSpecifier AS) {
   // Parse the common declaration-specifiers piece.
   Parser::DeclSpecContext DSC = Parser::DeclSpecContext::DSC_type_specifier;
   DeclSpec DS(AttrFactory);
   ParseSpecifierQualifierList(DS, AS, DSC);
 
   // Parse the declarator.
   DeclaratorContext Context = DeclaratorContext::Prototype;
-  Declarator DeclaratorInfo(DS, Context);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator DeclaratorInfo(DS, EmptyDeclAttrs, Context);
   ParseDeclarator(DeclaratorInfo);
   Range = DeclaratorInfo.getSourceRange();
   if (DeclaratorInfo.getIdentifier() == nullptr) {
     Diag(Tok.getLocation(), diag::err_omp_mapper_expected_declarator);
     return true;
   }
   Name = Actions.GetNameForDeclarator(DeclaratorInfo).getName();
 

clang/lib/Parse/ParseStmt.cpp

 //===--- ParseStmt.cpp - Statement and Block Parser -----------------------===//
 //
 // 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 Statement and Block portions of the Parser
 // interface.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/PrettyDeclStackTrace.h"
 #include "clang/Basic/Attributes.h"
+#include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PrettyStackTrace.h"
 #include "clang/Parse/LoopHint.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/TypoCorrection.h"
 #include "llvm/ADT/STLExtras.h"
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.
-  ParsedAttributes Attrs(AttrFactory);
-  MaybeParseCXX11Attributes(Attrs, /*MightBeObjCMessageSend*/ true);
+  ParsedAttributes CXX11Attrs(AttrFactory);
+  MaybeParseCXX11Attributes(CXX11Attrs, /*MightBeObjCMessageSend*/ true);
+  ParsedAttributes GNUAttrs(AttrFactory);
   if (getLangOpts().OpenCL)
-    MaybeParseGNUAttributes(Attrs);
+    MaybeParseGNUAttributes(GNUAttrs);
 
   StmtResult Res = ParseStatementOrDeclarationAfterAttributes(
-      Stmts, StmtCtx, TrailingElseLoc, Attrs);
+      Stmts, StmtCtx, TrailingElseLoc, CXX11Attrs, GNUAttrs);
   MaybeDestroyTemplateIds();
 
+  // Attributes that are left should all go on the statement, so concatenate the
+  // two lists.
+  ParsedAttributes Attrs(AttrFactory);
+  ConcatenateAttributes(CXX11Attrs, GNUAttrs, Attrs);
+
   assert((Attrs.empty() || Res.isInvalid() || Res.isUsable()) &&
          "attributes on empty statement");
 
   if (Attrs.empty() || Res.isInvalid())
     return Res;
 
   return Actions.ActOnAttributedStmt(Attrs, Res.get());
 }

 
 private:
   Token NextToken;
 };
 }
 
 StmtResult Parser::ParseStatementOrDeclarationAfterAttributes(
     StmtVector &Stmts, ParsedStmtContext StmtCtx,
-    SourceLocation *TrailingElseLoc, ParsedAttributes &Attrs) {
+    SourceLocation *TrailingElseLoc, ParsedAttributes &CXX11Attrs,
+    ParsedAttributes &GNUAttrs) {
   const char *SemiError = nullptr;
   StmtResult Res;
   SourceLocation GNUAttributeLoc;
 
   // Cases in this switch statement should fall through if the parser expects
   // the token to end in a semicolon (in which case SemiError should be set),
   // or they directly 'return;' if not.
 Retry:
Retry:
   case tok::code_completion:
     cutOffParsing();
     Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Statement);
     return StmtError();
 
   case tok::identifier: {
     Token Next = NextToken();
     if (Next.is(tok::colon)) { // C99 6.8.1: labeled-statement
+      // Both C++11 and GNU attributes preceding the label appertain to the
+      // label, so put them in a single list to pass on to
+      // ParseLabeledStatement().
+      ParsedAttributes Attrs(AttrFactory);
+      ConcatenateAttributes(CXX11Attrs, GNUAttrs, Attrs);
+
       // identifier ':' statement
       return ParseLabeledStatement(Attrs, StmtCtx);
     }
 
     // Look up the identifier, and typo-correct it to a keyword if it's not
     // found.
     if (Next.isNot(tok::coloncolon)) {
       // Try to limit which sets of keywords should be included in typo
if (Next.isNot(tok::coloncolon)) {
         goto Retry;
     }
 
     // Fall through
     LLVM_FALLTHROUGH;
   }
 
   default: {
+    auto isStmtAttr = [](ParsedAttr &Attr) { return Attr.isStmtAttr(); };
     if ((getLangOpts().CPlusPlus || getLangOpts().MicrosoftExt ||
          (StmtCtx & ParsedStmtContext::AllowDeclarationsInC) !=
              ParsedStmtContext()) &&
         ((GNUAttributeLoc.isValid() &&
-          !(!Attrs.empty() &&
-            llvm::all_of(
-                Attrs, [](ParsedAttr &Attr) { return Attr.isStmtAttr(); }))) ||
+          !(!(CXX11Attrs.empty() && GNUAttrs.empty()) &&
+            llvm::all_of(CXX11Attrs, isStmtAttr) &&
+            llvm::all_of(GNUAttrs, isStmtAttr))) ||
          isDeclarationStatement())) {
       SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
       DeclGroupPtrTy Decl;
       if (GNUAttributeLoc.isValid()) {
         DeclStart = GNUAttributeLoc;
-        Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, Attrs,
-                                &GNUAttributeLoc);
+        Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, CXX11Attrs,
+                                GNUAttrs, &GNUAttributeLoc);
       } else {
-        Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, Attrs);
+        Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, CXX11Attrs,
+                                GNUAttrs);
       }
-      if (Attrs.Range.getBegin().isValid())
-        DeclStart = Attrs.Range.getBegin();
+      if (CXX11Attrs.Range.getBegin().isValid())
+        DeclStart = CXX11Attrs.Range.getBegin();
+      else if (GNUAttrs.Range.getBegin().isValid())
+        DeclStart = GNUAttrs.Range.getBegin();
       return Actions.ActOnDeclStmt(Decl, DeclStart, DeclEnd);
     }
 
     if (Tok.is(tok::r_brace)) {
       Diag(Tok, diag::err_expected_statement);
       return StmtError();
     }
 
     return ParseExprStatement(StmtCtx);
   }
 
   case tok::kw___attribute: {
     GNUAttributeLoc = Tok.getLocation();
-    ParseGNUAttributes(Attrs);
+    ParseGNUAttributes(GNUAttrs);
     goto Retry;
   }
 
   case tok::kw_case:                // C99 6.8.1: labeled-statement
     return ParseCaseStatement(StmtCtx);
   case tok::kw_default:             // C99 6.8.1: labeled-statement
     return ParseDefaultStatement(StmtCtx);
 
case tok::kw_return:              // C99 6.8.6.4: return-statement
     SemiError = "return";
     break;
   case tok::kw_co_return:            // C++ Coroutines: co_return statement
     Res = ParseReturnStatement();
     SemiError = "co_return";
     break;
 
   case tok::kw_asm: {
-    ProhibitAttributes(Attrs);
+    if (getLangOpts().CPlusPlus) {
+      for (const ParsedAttr &AL : CXX11Attrs) {
+        Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
+      }
+      // Prevent these from being interpreted as statement attributes later on.
+      CXX11Attrs.clear();
+    } else
+      ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     bool msAsm = false;
     Res = ParseAsmStatement(msAsm);
     Res = Actions.ActOnFinishFullStmt(Res.get());
     if (msAsm) return Res;
     SemiError = "asm";
     break;
   }
 
   case tok::kw___if_exists:
   case tok::kw___if_not_exists:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     ParseMicrosoftIfExistsStatement(Stmts);
     // An __if_exists block is like a compound statement, but it doesn't create
     // a new scope.
     return StmtEmpty();
 
   case tok::kw_try:                 // C++ 15: try-block
     return ParseCXXTryBlock();
 
   case tok::kw___try:
-    ProhibitAttributes(Attrs); // TODO: is it correct?
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     return ParseSEHTryBlock();
 
   case tok::kw___leave:
     Res = ParseSEHLeaveStatement();
     SemiError = "__leave";
     break;
 
   case tok::annot_pragma_vis:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaVisibility();
     return StmtEmpty();
 
   case tok::annot_pragma_pack:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaPack();
     return StmtEmpty();
 
   case tok::annot_pragma_msstruct:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaMSStruct();
     return StmtEmpty();
 
   case tok::annot_pragma_align:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaAlign();
     return StmtEmpty();
 
   case tok::annot_pragma_weak:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaWeak();
     return StmtEmpty();
 
   case tok::annot_pragma_weakalias:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaWeakAlias();
     return StmtEmpty();
 
   case tok::annot_pragma_redefine_extname:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaRedefineExtname();
     return StmtEmpty();
 
   case tok::annot_pragma_fp_contract:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     Diag(Tok, diag::err_pragma_file_or_compound_scope) << "fp_contract";
     ConsumeAnnotationToken();
     return StmtError();
 
   case tok::annot_pragma_fp:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     Diag(Tok, diag::err_pragma_file_or_compound_scope) << "clang fp";
     ConsumeAnnotationToken();
     return StmtError();
 
   case tok::annot_pragma_fenv_access:
   case tok::annot_pragma_fenv_access_ms:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     Diag(Tok, diag::err_pragma_file_or_compound_scope)
         << (Kind == tok::annot_pragma_fenv_access ? "STDC FENV_ACCESS"
                                                     : "fenv_access");
     ConsumeAnnotationToken();
     return StmtEmpty();
 
   case tok::annot_pragma_fenv_round:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     Diag(Tok, diag::err_pragma_file_or_compound_scope) << "STDC FENV_ROUND";
     ConsumeAnnotationToken();
     return StmtError();
 
   case tok::annot_pragma_float_control:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     Diag(Tok, diag::err_pragma_file_or_compound_scope) << "float_control";
     ConsumeAnnotationToken();
     return StmtError();
 
   case tok::annot_pragma_opencl_extension:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaOpenCLExtension();
     return StmtEmpty();
 
   case tok::annot_pragma_captured:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     return HandlePragmaCaptured();
 
   case tok::annot_pragma_openmp:
     // Prohibit attributes that are not OpenMP attributes, but only before
     // processing a #pragma omp clause.
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     LLVM_FALLTHROUGH;
   case tok::annot_attr_openmp:
     // Do not prohibit attributes if they were OpenMP attributes.
     return ParseOpenMPDeclarativeOrExecutableDirective(StmtCtx);
 
   case tok::annot_pragma_ms_pointers_to_members:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaMSPointersToMembers();
     return StmtEmpty();
 
   case tok::annot_pragma_ms_pragma:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaMSPragma();
     return StmtEmpty();
 
   case tok::annot_pragma_ms_vtordisp:
-    ProhibitAttributes(Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
     HandlePragmaMSVtorDisp();
     return StmtEmpty();
 
   case tok::annot_pragma_loop_hint:
-    ProhibitAttributes(Attrs);
-    return ParsePragmaLoopHint(Stmts, StmtCtx, TrailingElseLoc, Attrs);
+    ProhibitAttributes(CXX11Attrs);
+    ProhibitAttributes(GNUAttrs);
+    return ParsePragmaLoopHint(Stmts, StmtCtx, TrailingElseLoc, CXX11Attrs);
 
   case tok::annot_pragma_dump:
     HandlePragmaDump();
     return StmtEmpty();
 
   case tok::annot_pragma_attribute:
     HandlePragmaAttribute();
     return StmtEmpty();
if (Tok.is(tok::kw___attribute)) {
     //
     // This doesn't quite match what GCC does; if the attribute list is empty
     // and followed by a semicolon, GCC will reject (it appears to parse the
     // attributes as part of a statement in that case). That looks like a bug.
     if (!getLangOpts().CPlusPlus || Tok.is(tok::semi))
       Attrs.takeAllFrom(TempAttrs);
     else {
       StmtVector Stmts;
-      SubStmt = ParseStatementOrDeclarationAfterAttributes(Stmts, StmtCtx,
-                                                           nullptr, TempAttrs);
+      ParsedAttributes EmptyCXX11Attrs(AttrFactory);
+      SubStmt = ParseStatementOrDeclarationAfterAttributes(
+          Stmts, StmtCtx, nullptr, EmptyCXX11Attrs, TempAttrs);
       if (!TempAttrs.empty() && !SubStmt.isInvalid())
         SubStmt = Actions.ActOnAttributedStmt(TempAttrs, SubStmt.get());
     }
   }
 
   // If we've not parsed a statement yet, parse one now.
   if (!SubStmt.isInvalid() && !SubStmt.isUsable())
     SubStmt = ParseStatement(nullptr, StmtCtx);
if (Tok.isNot(tok::kw___extension__)) {
 
       // 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;
-        DeclGroupPtrTy Res =
-            ParseDeclaration(DeclaratorContext::Block, DeclEnd, attrs);
+        ParsedAttributes DeclSpecAttrs(AttrFactory);
+        DeclGroupPtrTy Res = ParseDeclaration(DeclaratorContext::Block, DeclEnd,
+                                              attrs, DeclSpecAttrs);
         R = Actions.ActOnDeclStmt(Res, DeclStart, DeclEnd);
       } else {
         // Otherwise this was a unary __extension__ marker.
         ExprResult Res(ParseExpressionWithLeadingExtension(ExtLoc));
 
         if (Res.isInvalid()) {
           SkipUntil(tok::semi);
           continue;
if (Tok.is(tok::kw_using)) {
       DG = ParseAliasDeclarationInInitStatement(DeclaratorContext::ForInit,
                                                 attrs);
     } else {
       // In C++0x, "for (T NS:a" might not be a typo for ::
       bool MightBeForRangeStmt = getLangOpts().CPlusPlus;
       ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt);
 
       SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
+      ParsedAttributes DeclSpecAttrs(AttrFactory);
       DG = ParseSimpleDeclaration(
-          DeclaratorContext::ForInit, DeclEnd, attrs, false,
+          DeclaratorContext::ForInit, DeclEnd, attrs, DeclSpecAttrs, false,
           MightBeForRangeStmt ? &ForRangeInfo : nullptr);
       FirstPart = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
       if (ForRangeInfo.ParsedForRangeDecl()) {
         Diag(ForRangeInfo.ColonLoc, getLangOpts().CPlusPlus11
                                         ? diag::warn_cxx98_compat_for_range
                                         : diag::ext_for_range);
         ForRangeInfo.LoopVar = FirstPart;
         FirstPart = StmtResult();
while (Tok.is(tok::annot_pragma_loop_hint)) {
     TempAttrs.addNew(Hint.PragmaNameLoc->Ident, Hint.Range, nullptr,
                      Hint.PragmaNameLoc->Loc, ArgHints, 4,
                      ParsedAttr::AS_Pragma);
   }
 
   // Get the next statement.
   MaybeParseCXX11Attributes(Attrs);
 
+  ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
   StmtResult S = ParseStatementOrDeclarationAfterAttributes(
-      Stmts, StmtCtx, TrailingElseLoc, Attrs);
+      Stmts, StmtCtx, TrailingElseLoc, Attrs, EmptyDeclSpecAttrs);
 
   Attrs.takeAllFrom(TempAttrs);
 
   // Start of attribute range may already be set for some invalid input.
   // See PR46336.
   if (Attrs.Range.getBegin().isInvalid())
     Attrs.Range.setBegin(StartLoc);
 
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);
 
     DeclSpec DS(AttrFactory);
-    DS.takeAttributesFrom(Attributes);
 
     if (ParseCXXTypeSpecifierSeq(DS))
       return StmtError();
 
-    Declarator ExDecl(DS, DeclaratorContext::CXXCatch);
+    Declarator ExDecl(DS, Attributes, DeclaratorContext::CXXCatch);
     ParseDeclarator(ExDecl);
     ExceptionDecl = Actions.ActOnExceptionDeclarator(getCurScope(), ExDecl);
   } else
     ConsumeToken();
 
   T.consumeClose();
   if (T.getCloseLocation().isInvalid())
     return StmtError();

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
-    DS.takeAttributesFrom(prefixAttrs);
 
   // Parse the declarator.
-  ParsingDeclarator DeclaratorInfo(*this, DS, (DeclaratorContext)Context);
+  ParsingDeclarator DeclaratorInfo(*this, DS, prefixAttrs,
+                                   (DeclaratorContext)Context);
   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:
case TPResult::Error: {
     // We return an invalid parameter as opposed to null to avoid having bogus
     // diagnostics about an empty template parameter list.
     // FIXME: Fix ParseTemplateParameterList to better handle nullptr results
     //  from here.
     // Return a NTTP as if there was an error in a scope specifier, the user
     // probably meant to write the type of a NTTP.
     DeclSpec DS(getAttrFactory());
     DS.SetTypeSpecError();
-    Declarator D(DS, DeclaratorContext::TemplateParam);
+    ParsedAttributes EmptyDeclAttrs(AttrFactory);
+    Declarator D(DS, EmptyDeclAttrs, DeclaratorContext::TemplateParam);
     D.SetIdentifier(nullptr, Tok.getLocation());
     D.setInvalidType(true);
     NamedDecl *ErrorParam = Actions.ActOnNonTypeTemplateParameter(
         getCurScope(), D, Depth, Position, /*EqualLoc=*/SourceLocation(),
         /*DefaultArg=*/nullptr);
     ErrorParam->setInvalidDecl(true);
     SkipUntil(tok::comma, tok::greater, tok::greatergreater,
               StopAtSemi | StopBeforeMatch);
Parser::ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position) {
   // Parse the declaration-specifiers (i.e., the type).
   // FIXME: The type should probably be restricted in some way... Not all
   // declarators (parts of declarators?) are accepted for parameters.
   DeclSpec DS(AttrFactory);
   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none,
                              DeclSpecContext::DSC_template_param);
 
   // Parse this as a typename.
-  Declarator ParamDecl(DS, DeclaratorContext::TemplateParam);
+  ParsedAttributes EmptyDeclAttrs(AttrFactory);
+  Declarator ParamDecl(DS, EmptyDeclAttrs, DeclaratorContext::TemplateParam);
   ParseDeclarator(ParamDecl);
   if (DS.getTypeSpecType() == DeclSpec::TST_unspecified) {
     Diag(Tok.getLocation(), diag::err_expected_template_parameter);
     return nullptr;
   }
 
   // Recover from misplaced ellipsis.
   SourceLocation EllipsisLoc;

clang/lib/Parse/Parser.cpp

else if (ImportState == Sema::ModuleImportState::ImportAllowed)
       // Non-imports disallow further imports.
       ImportState = Sema::ModuleImportState::ImportFinished;
   }
   return false;
 }
 
 /// ParseExternalDeclaration:
 ///
+/// The `Attrs` that are passed in are C++11 attributes and appertain to the
+/// declaration.
+///
 ///       external-declaration: [C99 6.9], declaration: [C++ dcl.dcl]
 ///         function-definition
 ///         declaration
 /// [GNU]   asm-definition
 /// [GNU]   __extension__ external-declaration
 /// [OBJC]  objc-class-definition
 /// [OBJC]  objc-class-declaration
 /// [OBJC]  objc-alias-declaration
Parser::DeclGroupPtrTy Parser::ParseExternalDeclaration(ParsedAttributes &Attrs,
   case tok::kw_namespace:
   case tok::kw_typedef:
   case tok::kw_template:
   case tok::kw_static_assert:
   case tok::kw__Static_assert:
     // A function definition cannot start with any of these keywords.
     {
       SourceLocation DeclEnd;
-      return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs);
+      ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+      return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs,
+                              EmptyDeclSpecAttrs);
     }
 
   case tok::kw_static:
     // Parse (then ignore) 'static' prior to a template instantiation. This is
     // a GCC extension that we intentionally do not support.
     if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) {
       Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored)
         << 0;
       SourceLocation DeclEnd;
-      return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs);
+      ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+      return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs,
+                              EmptyDeclSpecAttrs);
     }
     goto dont_know;
 
   case tok::kw_inline:
     if (getLangOpts().CPlusPlus) {
       tok::TokenKind NextKind = NextToken().getKind();
 
       // Inline namespaces. Allowed as an extension even in C++03.
       if (NextKind == tok::kw_namespace) {
         SourceLocation DeclEnd;
-        return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs);
+        ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+        return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs,
+                                EmptyDeclSpecAttrs);
       }
 
       // Parse (then ignore) 'inline' prior to a template instantiation. This is
       // a GCC extension that we intentionally do not support.
       if (NextKind == tok::kw_template) {
         Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored)
           << 1;
         SourceLocation DeclEnd;
-        return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs);
+        ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+        return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs,
+                                EmptyDeclSpecAttrs);
       }
     }
     goto dont_know;
 
   case tok::kw_extern:
     if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) {
       // Extern templates
       SourceLocation ExternLoc = ConsumeToken();
if (Tok.is(tok::semi)) {
     DS.complete(TheDecl);
     if (AnonRecord) {
       Decl* decls[] = {AnonRecord, TheDecl};
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
-  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) &&
         !Tok.isObjCAtKeyword(tok::objc_protocol) &&
         !Tok.isObjCAtKeyword(tok::objc_implementation)) {
       Diag(Tok, diag::err_objc_unexpected_attr);
       SkipUntil(tok::semi);
       return nullptr;
     }
 
     DS.abort();
+    DS.takeAttributesFrom(Attrs);
 
     const char *PrevSpec = nullptr;
     unsigned DiagID;
     if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID,
                            Actions.getASTContext().getPrintingPolicy()))
       Diag(AtLoc, DiagID) << PrevSpec;
 
     if (Tok.isObjCAtKeyword(tok::objc_protocol))
       return ParseObjCAtProtocolDeclaration(AtLoc, DS.getAttributes());
 
     if (Tok.isObjCAtKeyword(tok::objc_implementation))
       return ParseObjCAtImplementationDeclaration(AtLoc, DS.getAttributes());
 
     return Actions.ConvertDeclToDeclGroup(
             ParseObjCAtInterfaceDeclaration(AtLoc, DS.getAttributes()));
   }
 
   // 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) {
+    ProhibitAttributes(Attrs);
     Decl *TheDecl = ParseLinkage(DS, DeclaratorContext::File);
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
-  return ParseDeclGroup(DS, DeclaratorContext::File);
+  return ParseDeclGroup(DS, DeclaratorContext::File, Attrs);
 }
 
 Parser::DeclGroupPtrTy Parser::ParseDeclarationOrFunctionDefinition(
     ParsedAttributes &Attrs, ParsingDeclSpec *DS, AccessSpecifier AS) {
   if (DS) {
     return ParseDeclOrFunctionDefInternal(Attrs, *DS, AS);
   } else {
     ParsingDeclSpec PDS(*this);
while (isDeclarationSpecifier()) {
     }
     if (DS.getThreadStorageClassSpec() != DeclSpec::TSCS_unspecified) {
       Diag(DS.getThreadStorageClassSpecLoc(),
            diag::err_invalid_storage_class_in_func_decl);
       DS.ClearStorageClassSpecs();
     }
 
     // Parse the first declarator attached to this declspec.
-    Declarator ParmDeclarator(DS, DeclaratorContext::KNRTypeList);
+    ParsedAttributes EmptyDeclAttrs(AttrFactory);
+    Declarator ParmDeclarator(DS, EmptyDeclAttrs,
+                              DeclaratorContext::KNRTypeList);
     ParseDeclarator(ParmDeclarator);
 
     // Handle the full declarator list.
     while (true) {
       // If attributes are present, parse them.
       MaybeParseGNUAttributes(ParmDeclarator);
 
       // Ask the actions module to compute the type for this declarator.

clang/lib/Sema/ParsedAttr.cpp

 }
 
 bool ParsedAttr::isKnownToGCC() const { return getInfo().IsKnownToGCC; }
 
 bool ParsedAttr::isSupportedByPragmaAttribute() const {
   return getInfo().IsSupportedByPragmaAttribute;
 }
 
+bool ParsedAttr::slidesFromDeclToDeclSpec() const {
+  assert(isStandardAttributeSyntax());
+
+  // We have historically allowed some type attributes with standard attribute
+  // syntax to slide to the decl-specifier-seq, so we have to keep supporting
+  // it. This property is consciously not defined as a flag in Attr.td because
+  // we don't want new attributes to specify it.
+  //
+  // Note: No new entries should be added to this list. Entries should be
+  // removed from this list after a suitable deprecation period, provided that
+  // there are no compatibility considerations with other compilers. If
+  // possible, we would like this list to go away entirely.
+  switch (getParsedKind()) {
+  case AT_AddressSpace:
+  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_ArmMveStrictPolymorphism:
+  case AT_BTFTypeTag:
+  case AT_Regparm:
+  case AT_NoDeref:
+  case AT_ObjCGC:
+  case AT_VectorSize:
+  case AT_MatrixType:
+    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
return checkAttributeNumArgsImpl(S, *this, Num,
                                    diag::err_attribute_too_few_arguments,
                                    std::less<unsigned>());
 }
 bool ParsedAttr::checkAtMostNumArgs(Sema &S, unsigned Num) const {
   return checkAttributeNumArgsImpl(S, *this, Num,
                                    diag::err_attribute_too_many_arguments,
                                    std::greater<unsigned>());
 }
+
+void clang::ConcatenateAttributes(ParsedAttributes &First,
+                                  ParsedAttributes &Second,
+                                  ParsedAttributes &Result) {
+  // Note that takeAllFrom() puts the attributes at the beginning of the list,
+  // so to obtain the correct ordering, we add `Second`, then `First`.
+  Result.takeAllFrom(Second);
+  Result.takeAllFrom(First);
+  if (First.Range.getBegin().isValid())
+    Result.Range.setBegin(First.Range.getBegin());
+  else
+    Result.Range.setBegin(Second.Range.getBegin());
+  if (Second.Range.getEnd().isValid())
+    Result.Range.setEnd(Second.Range.getEnd());
+  else
+    Result.Range.setEnd(First.Range.getEnd());
+}

clang/lib/Sema/SemaDecl.cpp

Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
   //   each such member-declaration shall either declare at least one member
   //   name of the class or declare at least one unnamed bit-field
   //
   // For C this is an error even for a named struct, and is diagnosed elsewhere.
   if (getLangOpts().CPlusPlus && Record->field_empty())
     Diag(DS.getBeginLoc(), diag::ext_no_declarators) << DS.getSourceRange();
 
   // Mock up a declarator.
-  Declarator Dc(DS, DeclaratorContext::Member);
+  ParsedAttributes EmptyDeclAttrs(DS.getAttributePool().getFactory());
+  Declarator Dc(DS, EmptyDeclAttrs, DeclaratorContext::Member);
   TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
   assert(TInfo && "couldn't build declarator info for anonymous struct/union");
 
   // Create a declaration for this anonymous struct/union.
   NamedDecl *Anon = nullptr;
   if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
     Anon = FieldDecl::Create(
         Context, OwningClass, DS.getBeginLoc(), Record->getLocation(),

 ///   var.a = 3;
 /// }
 ///
 Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
                                            RecordDecl *Record) {
   assert(Record && "expected a record!");
 
   // Mock up a declarator.
-  Declarator Dc(DS, DeclaratorContext::TypeName);
+  ParsedAttributes EmptyDeclAttrs(DS.getAttributePool().getFactory());
+  Declarator Dc(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
   TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
   assert(TInfo && "couldn't build declarator info for anonymous struct");
 
   auto *ParentDecl = cast<RecordDecl>(CurContext);
   QualType RecTy = Context.getTypeDeclType(Record);
 
   // Create a declaration for this anonymous struct.
   NamedDecl *Anon =
static bool hasParsedAttr(Scope *S, const Declarator &PD,
   // Walk the declarator structure, checking decl attributes that were in a type
   // position to the decl itself.
   for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
     if (PD.getTypeObject(I).getAttrs().hasAttribute(Kind))
       return true;
   }
 
   // Finally, check attributes on the decl itself.
-  return PD.getAttributes().hasAttribute(Kind);
+  return PD.getAttributes().hasAttribute(Kind) ||
+         PD.getDeclarationAttributes().hasAttribute(Kind);
 }
 
 /// Adjust the \c DeclContext for a function or variable that might be a
 /// function-local external declaration.
 bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) {
   if (!DC->isFunctionOrMethod())
     return false;
 
StmtResult Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
   //      for ( auto&& for-range-identifier : for-range-initializer ) statement
   DeclSpec DS(Attrs.getPool().getFactory());
 
   const char *PrevSpec;
   unsigned DiagID;
   DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
                      getPrintingPolicy());
 
-  Declarator D(DS, DeclaratorContext::ForInit);
+  ParsedAttributes EmptyDeclAttrs(DS.getAttributePool().getFactory());
+  Declarator D(DS, EmptyDeclAttrs, DeclaratorContext::ForInit);
   D.SetIdentifier(Ident, IdentLoc);
   D.takeAttributes(Attrs);
 
   D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/ false),
                 IdentLoc);
   Decl *Var = ActOnDeclarator(S, D);
   cast<VarDecl>(Var)->setCXXForRangeDecl(true);
   FinalizeDeclaration(Var);
for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
         DeclSpec DS(attrs);
         const char* PrevSpec; // unused
         unsigned DiagID; // unused
         DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
                            DiagID, Context.getPrintingPolicy());
         // Use the identifier location for the type source range.
         DS.SetRangeStart(FTI.Params[i].IdentLoc);
         DS.SetRangeEnd(FTI.Params[i].IdentLoc);
-        Declarator ParamD(DS, DeclaratorContext::KNRTypeList);
+        ParsedAttributes EmptyDeclAttrs(DS.getAttributePool().getFactory());
+        Declarator ParamD(DS, EmptyDeclAttrs, DeclaratorContext::KNRTypeList);
         ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
         FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
       }
     }
   }
 }
 
 Decl *
NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
   AttributeFactory attrFactory;
   DeclSpec DS(attrFactory);
   unsigned DiagID;
   bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
                                   Context.getPrintingPolicy());
   (void)Error; // Silence warning.
   assert(!Error && "Error setting up implicit decl!");
   SourceLocation NoLoc;
-  Declarator D(DS, DeclaratorContext::Block);
+  ParsedAttributes EmptyDeclAttrs(attrFactory);
+  Declarator D(DS, EmptyDeclAttrs, DeclaratorContext::Block);
   D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
                                              /*IsAmbiguous=*/false,
                                              /*LParenLoc=*/NoLoc,
                                              /*Params=*/nullptr,
                                              /*NumParams=*/0,
                                              /*EllipsisLoc=*/NoLoc,
                                              /*RParenLoc=*/NoLoc,
                                              /*RefQualifierIsLvalueRef=*/true,

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)
+  // We intentionally check the attribute syntax directly instead of using
+  // ParsedAttr::isCXX11Attribute() as the latter includes the alignas
+  // attribute.  The alignas attribute is a declaration attribute but can appear
+  // on the `DeclSpec`, so we want to let it through here.
+  if (AL.getSyntax() == ParsedAttr::AS_CXX11 && !Options.IncludeCXX11Attributes)
     return;
 
   // Unknown attributes are automatically warned on. Target-specific attributes
   // which do not apply to the current target architecture are treated as
   // though they were unknown attributes.
   if (AL.getKind() == ParsedAttr::UnknownAttribute ||
       !AL.existsInTarget(S.Context.getTargetInfo())) {
     S.Diag(AL.getLoc(),
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.isStandardAttributeSyntax()) {
+        // Non-[[]] type attributes are handled in processTypeAttrs(); silently
+        // move on.
         break;
       }
+
+      // According to the C and C++ standards, we should never see a
+      // [[]] type attribute on a declaration. However, we have in the past
+      // allowed some type attributes to "slide" to the `DeclSpec`, so we need
+      // to continue to support this legacy behavior. We only do this, however,
+      // if
+      // - we actually have a `DeclSpec`, i.e. if we're looking at a
+      //   `DeclaratorDecl`, or
+      // - we are looking at an alias-declaration, where historically we have
+      //   allowed type attributes after the identifier to slide to the type.
+      if (AL.slidesFromDeclToDeclSpec() &&
+          (clang::isa<DeclaratorDecl>(D) || clang::isa<TypeAliasDecl>(D))) {
+        // Suggest moving the attribute to the type instead, but only for our
+        // own vendor attributes; moving other vendors' attributes might hurt
+        // portability.
+        if (AL.isClangScope()) {
+          S.Diag(AL.getLoc(), diag::warn_type_attribute_deprecated_on_decl)
+              << AL << D->getLocation();
+        }
+
+        // Allow this type attribute to be handled in processTypeAttrs();
+        // 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)
+    // needed for type attributes as well as statement attributes in Attr.td
+    // that do not list any subjects.
+    S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
         << AL << D->getLocation();
     break;
   case ParsedAttr::AT_Interrupt:
     handleInterruptAttr(S, D, AL);
     break;
   case ParsedAttr::AT_X86ForceAlignArgPointer:
     handleX86ForceAlignArgPointerAttr(S, D, AL);
     break;
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());
+      ProcessDeclAttribute(*this, nullptr, ASDecl, AL,
+                           ProcessDeclAttributeOptions());
     } else {
       Diag(AL.getLoc(), diag::err_only_annotate_after_access_spec);
       return true;
     }
   }
   return false;
 }
 
for (const ParsedAttr &AL : A) {
     }
   }
 }
 
 /// checkUnusedDeclAttributes - Given a declarator which is not being
 /// used to build a declaration, complain about any decl attributes
 /// which might be lying around on it.
 void Sema::checkUnusedDeclAttributes(Declarator &D) {
   ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes());
+  ::checkUnusedDeclAttributes(*this, D.getDeclarationAttributes());
   ::checkUnusedDeclAttributes(*this, D.getAttributes());
   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
     ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs());
 }
 
 /// DeclClonePragmaWeak - clone existing decl (maybe definition),
 /// \#pragma weak needs a non-definition decl and source may not have one.
 NamedDecl *Sema::DeclClonePragmaWeak(NamedDecl *ND, const IdentifierInfo *II,
                                      SourceLocation Loc) {
if (IdentifierInfo *Id = ND->getIdentifier()) {
     }
   }
 }
 
 /// 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) {
+  // Ordering of attributes can be important, so we take care to process
+  // attributes in the order in which they appeared in the source code.
+
+  // First, process attributes that appeared on the declaration itself (but
+  // only if they don't have the legacy behavior of "sliding" to the DeclSepc).
+  ParsedAttributesView NonSlidingAttrs;
+  for (ParsedAttr &AL : PD.getDeclarationAttributes()) {
+    if (!AL.slidesFromDeclToDeclSpec()) {
+      NonSlidingAttrs.addAtEnd(&AL);
+    }
+  }
+  ProcessDeclAttributeList(S, D, NonSlidingAttrs);
+
   // 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()
+                                 .WithIncludeCXX11Attributes(false)
+                                 .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);
 }
 
 /// Is the given declaration allowed to use a forbidden type?
 /// If so, it'll still be annotated with an attribute that makes it
 /// illegal to actually use.
 static bool isForbiddenTypeAllowed(Sema &S, Decl *D,
                                    const DelayedDiagnostic &diag,
                                    UnavailableAttr::ImplicitReason &reason) {
   // Private ivars are always okay.  Unfortunately, people don't
   // always properly make their ivars private, even in system headers.
   // Plus we need to make fields okay, too.
   if (!isa<FieldDecl>(D) && !isa<ObjCPropertyDecl>(D) &&
       !isa<FunctionDecl>(D))
     return false;

clang/lib/Sema/SemaDeclCXX.cpp

if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
       Diag(DS.getAtomicSpecLoc(), diag::err_friend_decl_spec) << "_Atomic";
     if (DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)
       Diag(DS.getUnalignedSpecLoc(), diag::err_friend_decl_spec) << "__unaligned";
   }
 
   // Try to convert the decl specifier to a type.  This works for
   // friend templates because ActOnTag never produces a ClassTemplateDecl
   // for a TUK_Friend.
-  Declarator TheDeclarator(DS, DeclaratorContext::Member);
+  ParsedAttributes EmptyDeclAttrs(DS.getAttributePool().getFactory());
+  Declarator TheDeclarator(DS, EmptyDeclAttrs, DeclaratorContext::Member);
   TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
   QualType T = TSI->getType();
   if (TheDeclarator.isInvalidType())
     return nullptr;
 
   if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
     return nullptr;
 

clang/lib/Sema/SemaDeclObjC.cpp

auto resolveTypeReference = [&](TypeOrClassDecl typeDecl, SourceLocation loc)
     ParsedType parsedType = CreateParsedType(type, parsedTSInfo);
     DS.SetTypeSpecType(DeclSpec::TST_typename, loc, prevSpec, diagID,
                        parsedType, Context.getPrintingPolicy());
     // Use the identifier location for the type source range.
     DS.SetRangeStart(loc);
     DS.SetRangeEnd(loc);
 
     // Form the declarator.
-    Declarator D(DS, DeclaratorContext::TypeName);
+    ParsedAttributes EmptyDeclAttrs(attrFactory);
+    Declarator D(DS, EmptyDeclAttrs, DeclaratorContext::TypeName);
 
     // If we have a typedef of an Objective-C class type that is missing a '*',
     // add the '*'.
     if (type->getAs<ObjCInterfaceType>()) {
       SourceLocation starLoc = getLocForEndOfToken(loc);
       D.AddTypeInfo(DeclaratorChunk::getPointer(/*TypeQuals=*/0, starLoc,
                                                 SourceLocation(),
                                                 SourceLocation(),

clang/lib/Sema/SemaType.cpp

class TypeProcessingState {
     /// stored in a MacroQualifiedTypeLoc.
     llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;
 
     /// Flag to indicate we parsed a noderef attribute. This is used for
     /// validating that noderef was used on a pointer or array.
     bool parsedNoDeref;
 
   public:
     TypeProcessingState(Sema &sema, Declarator &declarator)
         : sema(sema), declarator(declarator),
           chunkIndex(declarator.getNumTypeObjects()), trivial(true),
           hasSavedAttrs(false), parsedNoDeref(false) {}
 
     Sema &getSema() const {
       return sema;
     }
 
if (innermost != -1U) {
     moveAttrFromListToList(attr, declarator.getAttributes(),
                            declarator.getTypeObject(innermost).getAttrs());
     return;
   }
 
   // Otherwise, diagnose when we're done building the type.
   declarator.getAttributes().remove(&attr);
   state.addIgnoredTypeAttr(attr);
 }
 
 /// A function type attribute was written somewhere in a declaration
 /// *other* than on the declarator itself or in the decl spec.  Given
 /// that it didn't apply in whatever position it was written in, try
 /// to move it to a more appropriate position.
 static void distributeFunctionTypeAttr(TypeProcessingState &state,
                                        ParsedAttr &attr, QualType type) {
   Declarator &declarator = state.getDeclarator();

 
 /// A function type attribute was written in the decl spec.  Try to
 /// apply it somewhere.
 static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state,
                                                    ParsedAttr &attr,
                                                    QualType &declSpecType) {
   state.saveDeclSpecAttrs();
 
-  // C++11 attributes before the decl specifiers actually appertain to
-  // the declarators. Move them straight there. We don't support the
-  // 'put them wherever you like' semantics we allow for GNU attributes.
-  if (attr.isStandardAttributeSyntax()) {
-    moveAttrFromListToList(attr, state.getCurrentAttributes(),
-                           state.getDeclarator().getAttributes());
-    return;
-  }
-
   // Try to distribute to the innermost.
   if (distributeFunctionTypeAttrToInnermost(
           state, attr, state.getCurrentAttributes(), declSpecType))
     return;
 
   // If that failed, diagnose the bad attribute when the declarator is
   // fully built.
   state.addIgnoredTypeAttr(attr);
 }
 
-/// A function type attribute was written on the declarator.  Try to
-/// apply it somewhere.
+/// A function type attribute was written on the declarator or declaration.
+/// Try to apply it somewhere.
+/// `Attrs` is the attribute list containing the declaration (either of the
+/// declarator or the declaration).
 static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state,
                                                      ParsedAttr &attr,
                                                      QualType &declSpecType) {
   Declarator &declarator = state.getDeclarator();
 
   // Try to distribute to the innermost.
   if (distributeFunctionTypeAttrToInnermost(
           state, attr, declarator.getAttributes(), declSpecType))
     return;
 
   // If that failed, diagnose the bad attribute when the declarator is
   // fully built.
   declarator.getAttributes().remove(&attr);
   state.addIgnoredTypeAttr(attr);
 }
 
-/// Given that there are attributes written on the declarator
+/// Given that there are attributes written on the declarator or declaration
 /// itself, try to distribute any type attributes to the appropriate
 /// declarator chunk.
 ///
 /// These are attributes like the following:
 ///   int f ATTR;
 ///   int (f ATTR)();
 /// but not necessarily this:
 ///   int f() ATTR;
+///
+/// `Attrs` is the attribute list containing the declaration (either of the
+/// declarator or the declaration).
 static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state,
                                               QualType &declSpecType) {
-  // Collect all the type attributes from the declarator itself.
-  assert(!state.getDeclarator().getAttributes().empty() &&
-         "declarator has no attrs!");
   // The called functions in this loop actually remove things from the current
   // list, so iterating over the existing list isn't possible.  Instead, make a
   // non-owning copy and iterate over that.
   ParsedAttributesView AttrsCopy{state.getDeclarator().getAttributes()};
   for (ParsedAttr &attr : AttrsCopy) {
     // Do not distribute [[]] attributes. They have strict rules for what
     // they appertain to.
     if (attr.isStandardAttributeSyntax())
#include "clang/Basic/OpenCLImageTypes.def"
   // function declarator if necessary.
   if (declarator.getContext() == DeclaratorContext::BlockLiteral)
     maybeSynthesizeBlockSignature(state, Result);
 
   // Apply any type attributes from the decl spec.  This may cause the
   // list of type attributes to be temporarily saved while the type
   // attributes are pushed around.
   // pipe attributes will be handled later ( at GetFullTypeForDeclarator )
-  if (!DS.isTypeSpecPipe())
+  if (!DS.isTypeSpecPipe()) {
+    // We also apply declaration attributes that "slide" to the decl spec.
+    // Ordering can be important for attributes. The decalaration attributes
+    // come syntactically before the decl spec attributes, so we process them
+    // in that order.
+    ParsedAttributesView SlidingAttrs;
+    for (ParsedAttr &AL : declarator.getDeclarationAttributes()) {
+      if (AL.slidesFromDeclToDeclSpec()) {
+        SlidingAttrs.addAtEnd(&AL);
+
+        // For standard syntax attributes, which would normally appertain to the
+        // declaration here, suggest moving them to the type instead. But only
+        // do this for our own vendor attributes; moving other vendors'
+        // attributes might hurt portability.
+        if (AL.isStandardAttributeSyntax() && AL.isClangScope()) {
+          S.Diag(AL.getLoc(), diag::warn_type_attribute_deprecated_on_decl)
+              << AL;
+        }
+      }
+    }
+    // During this call to processTypeAttrs(),
+    // TypeProcessingState::getCurrentAttributes() will erroneously return a
+    // reference to the DeclSpec attributes, rather than the declaration
+    // attributes. However, this doesn't matter, as getCurrentAttributes()
+    // is only called when distributing attributes from one attribute list
+    // to another. Declaration attributes are always C++11 attributes, and these
+    // are never distributed.
+    processTypeAttrs(state, Result, TAL_DeclSpec, SlidingAttrs);
     processTypeAttrs(state, Result, TAL_DeclSpec, DS.getAttributes());
+  }
 
   // Apply const/volatile/restrict qualifiers to T.
   if (unsigned TypeQuals = DS.getTypeQualifiers()) {
     // Warn about CV qualifiers on function types.
     // C99 6.7.3p8:
     //   If the specification of a function type includes any type qualifiers,
     //   the behavior is undefined.
     // C++11 [dcl.fct]p7:
static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
   case UnqualifiedIdKind::IK_ConversionFunctionId:
     // The result type of a conversion function is the type that it
     // converts to.
     T = SemaRef.GetTypeFromParser(D.getName().ConversionFunctionId,
                                   &ReturnTypeInfo);
     break;
   }
 
-  if (!D.getAttributes().empty())
-    distributeTypeAttrsFromDeclarator(state, T);
+  // Note: We don't need to distribute declaration attributes (i.e.
+  // D.getDeclarationAttributes()) because those are always C++11 attributes,
+  // and those don't get distributed.
 
   // Find the deduced type in this type. Look in the trailing return type if we
   // have one, otherwise in the DeclSpec type.
   // FIXME: The standard wording doesn't currently describe this.
   DeducedType *Deduced = T->getContainedDeducedType();
   bool DeducedIsTrailingReturnType = false;
   if (Deduced && isa<AutoType>(Deduced) && D.hasTrailingReturnType()) {
     QualType T = SemaRef.GetTypeFromParser(D.getTrailingReturnType());
case DeclaratorContext::KNRTypeList: {
           // cf_returns_not_retained, if the outer pointer is explicit then
           // infer the inner pointer as _Nullable.
           auto hasCFReturnsAttr =
               [](const ParsedAttributesView &AttrList) -> bool {
             return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
                    AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
           };
           if (const auto *InnermostChunk = D.getInnermostNonParenChunk()) {
-            if (hasCFReturnsAttr(D.getAttributes()) ||
+            if (hasCFReturnsAttr(D.getDeclarationAttributes()) ||
+                hasCFReturnsAttr(D.getAttributes()) ||
                 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
                 hasCFReturnsAttr(D.getDeclSpec().getAttributes())) {
               inferNullability = NullabilityKind::Nullable;
               inferNullabilityInnerOnly = true;
             }
           }
         }
         break;
case DeclaratorChunk::Function: {
           !LangOpts.requiresStrictPrototypes() && !LangOpts.OpenCL) {
         // Simple void foo(), where the incoming T is the result type.
         T = Context.getFunctionNoProtoType(T, EI);
       } else {
         // We allow a zero-parameter variadic function in C if the
         // function is marked with the "overloadable" attribute. Scan
         // for this attribute now.
         if (!FTI.NumParams && FTI.isVariadic && !LangOpts.CPlusPlus)
-          if (!D.getAttributes().hasAttribute(ParsedAttr::AT_Overloadable) &&
+          if (!D.getDeclarationAttributes().hasAttribute(
+                  ParsedAttr::AT_Overloadable) &&
+              !D.getAttributes().hasAttribute(ParsedAttr::AT_Overloadable) &&
               !D.getDeclSpec().getAttributes().hasAttribute(
                   ParsedAttr::AT_Overloadable))
             S.Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_param);
 
         if (FTI.NumParams && FTI.Params[0].Param == nullptr) {
           // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function
           // definition.
           S.Diag(FTI.Params[0].IdentLoc,
if (IsQualifiedFunction &&
       for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
         if (D.getTypeObject(i).Kind != DeclaratorChunk::Paren)
           break;
         T = S.BuildParenType(T);
       }
     }
   }
 
-  // Apply any undistributed attributes from the declarator.
+  // Apply any undistributed attributes from the declaration or declarator.
+  ParsedAttributesView NonSlidingAttrs;
+  for (ParsedAttr &AL : D.getDeclarationAttributes()) {
+    if (!AL.slidesFromDeclToDeclSpec()) {
+      NonSlidingAttrs.addAtEnd(&AL);
+    }
+  }
+  processTypeAttrs(state, T, TAL_DeclName, NonSlidingAttrs);
   processTypeAttrs(state, T, TAL_DeclName, D.getAttributes());
 
   // Diagnose any ignored type attributes.
   state.diagnoseIgnoredTypeAttrs(T);
 
   // C++0x [dcl.constexpr]p9:
   //  A constexpr specifier used in an object declaration declares the object
   //  as const.
if (attr.isStandardAttributeSyntax()) {
                                IsTypeAttr
                                    ? diag::warn_gcc_ignores_type_attr
                                    : diag::warn_cxx11_gnu_attribute_on_type)
               << attr;
           if (!IsTypeAttr)
             continue;
         }
       } else if (TAL != TAL_DeclChunk && !isAddressSpaceKind(attr) &&
-                 attr.getKind() != ParsedAttr::AT_AnnotateType) {
+                 attr.getKind() != ParsedAttr::AT_AnnotateType &&
+                 attr.getKind() != ParsedAttr::UnknownAttribute) {
         // Otherwise, only consider type processing for a C++11 attribute if
         // it's actually been applied to a type.
-        // We also allow C++11 address_space and annotate_type and
-        // OpenCL language address space attributes to pass through.
+        // We also allow some attributes to pass through generally:
+        // - C++11 address_space and OpenCL language address space attributes
+        // - annotate_type
+        // - Unknown attributes (for generating warnings)
         continue;
       }
     }
 
     // If this is an attribute we can handle, do so now,
     // otherwise, add it to the FnAttrs list for rechaining.
     switch (attr.getKind()) {
     default:
       // A [[]] attribute on a declarator chunk must appertain to a type.
       if (attr.isStandardAttributeSyntax() && TAL == TAL_DeclChunk) {
         state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr)
             << attr;
         attr.setUsedAsTypeAttr();
       }
       break;
 
     case ParsedAttr::UnknownAttribute:
-      if (attr.isStandardAttributeSyntax() && TAL == TAL_DeclChunk)
+      if (attr.isStandardAttributeSyntax() &&
+          (TAL == TAL_DeclChunk || TAL == TAL_DeclSpec)) {
         state.getSema().Diag(attr.getLoc(),
                              diag::warn_unknown_attribute_ignored)
             << attr << attr.getRange();
+        // Mark the attribute as invalid so we don't emit the same diagnostic
+        // multiple times.
+        attr.setInvalid();
+      }
       break;
 
     case ParsedAttr::IgnoredAttribute:
       break;
 
     case ParsedAttr::AT_BTFTypeTag:
       HandleBTFTypeTagAttribute(type, attr, state);
       attr.setUsedAsTypeAttr();

clang/test/Parser/MicrosoftExtensions.cpp

 [uuid("000000000000-0000-1234-000000000047")] struct uuid_attr_bad6 { };// expected-error {{uuid attribute contains a malformed GUID}}
 
 __declspec(uuid("000000A0-0000-0000-C000-000000000046")) int i; // expected-warning {{'uuid' attribute only applies to structs, unions, classes, and enums}}
 
 struct __declspec(uuid("000000A0-0000-0000-C000-000000000046"))
 struct_with_uuid { };
 struct struct_without_uuid { };
 
+struct base {
+  int a;
+};
+struct derived : base {
+  // Can't apply a UUID to a using declaration.
+  [uuid("000000A0-0000-0000-C000-00000000004A")] using base::a; // expected-error {{expected member name}}
+};
+
 struct __declspec(uuid("000000A0-0000-0000-C000-000000000049"))
 struct_with_uuid2;
 
 [uuid("000000A0-0000-0000-C000-000000000049")] struct struct_with_uuid3; // expected-warning{{specifying 'uuid' as an ATL attribute is deprecated; use __declspec instead}}
 
 struct
 struct_with_uuid2 {} ;
 

clang/test/Parser/asm.c

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -verify %s
 
 #if !__has_extension(gnu_asm)
 #error Extension 'gnu_asm' should be available by default
 #endif
 
 void f1(void) {
   // PR7673: Some versions of GCC support an empty clobbers section.
   asm ("ret" : : :);
 }
 
 void f2(void) {
   asm("foo" : "=r" (a)); // expected-error {{use of undeclared identifier 'a'}}
   asm("foo" : : "r" (b)); // expected-error {{use of undeclared identifier 'b'}} 
+
+  // C does not allow attribute lists before asm blocks.
+  [[]] asm(""); // expected-error {{an attribute list cannot appear here}}
 }
 
 void a(void) __asm__(""); // expected-error {{cannot use an empty string literal in 'asm'}}
 void a(void) {
   __asm__(""); // ok
 }
 
 // rdar://5952468

clang/test/Parser/asm.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 int foo1 asm ("bar1");
 int foo2 asm (L"bar2"); // expected-error {{cannot use wide string literal in 'asm'}}
 int foo3 asm (u8"bar3"); // expected-error {{cannot use unicode string literal in 'asm'}}
 int foo4 asm (u"bar4"); // expected-error {{cannot use unicode string literal in 'asm'}}
 int foo5 asm (U"bar5"); // expected-error {{cannot use unicode string literal in 'asm'}}
 int foo6 asm ("bar6"_x); // expected-error {{string literal with user-defined suffix cannot be used here}}
 int foo6 asm ("" L"bar7"); // expected-error {{cannot use wide string literal in 'asm'}}
+
+void f() {
+  [[]] asm("");
+  [[gnu::deprecated]] asm(""); // expected-warning {{'deprecated' attribute ignored}}
+}

clang/test/Parser/c2x-attributes.c

struct [[]] S1 {
   int [[]] j;
   int k[10] [[]];
   int l[[]][10];
   [[]] int m, n;
   int o [[]] : 12;
   int [[]] : 0; // OK, attribute applies to the type.
   int p, [[]] : 0; // expected-error {{an attribute list cannot appear here}}
   int q, [[]] r; // expected-error {{an attribute list cannot appear here}}
+  [[]] int; // expected-error {{an attribute list cannot appear here}} \
+            // expected-warning {{declaration does not declare anything}}
 };
 
 [[]] struct S2 { int a; }; // expected-error {{misplaced attributes}}
 struct S3 [[]] { int a; }; // expected-error {{an attribute list cannot appear here}}
 
 union [[]] U {
   double d [[]];
   [[]] int i;

clang/test/Parser/cxx0x-attributes.cpp

 int scope_attr [[foo::]]; // expected-error {{expected identifier}}
 int (paren_attr) [[]]; // expected-error {{an attribute list cannot appear here}}
 unsigned [[]] int attr_in_decl_spec; // expected-error {{an attribute list cannot appear here}}
 unsigned [[]] int [[]] const double_decl_spec = 0; // expected-error 2{{an attribute list cannot appear here}}
 class foo {
   void const_after_attr () [[]] const; // expected-error {{expected ';'}}
 };
 extern "C++" [[]] { } // expected-error {{an attribute list cannot appear here}}
+[[]] extern "C++" { } // expected-error {{an attribute list cannot appear here}}
 [[]] template <typename T> void before_template_attr (); // expected-error {{an attribute list cannot appear here}}
 [[]] namespace ns { int i; } // expected-error {{an attribute list cannot appear here}} expected-note {{declared here}}
 [[]] static_assert(true, ""); //expected-error {{an attribute list cannot appear here}}
 [[]] asm(""); // expected-error {{an attribute list cannot appear here}}
 
 [[]] using ns::i;
 [[unknown]] using namespace ns; // expected-warning {{unknown attribute 'unknown' ignored}}
 [[noreturn]] using namespace ns; // expected-error {{'noreturn' attribute only applies to functions}}

 
 // Check that we can parse an attribute in our vendor namespace.
 [[clang::annotate("test")]] void annotate1();
 [[_Clang::annotate("test")]] void annotate2();
 // Note: __clang__ is a predefined macro, which is why _Clang is the
 // prefered "protected" vendor namespace. We support __clang__ only for
 // people expecting it to behave the same as __gnu__.
 [[__clang__::annotate("test")]] void annotate3();  // expected-warning {{'__clang__' is a predefined macro name, not an attribute scope specifier; did you mean '_Clang' instead?}}
+
+// Check ordering: C++11 attributes must appear before GNU attributes.
+class Ordering {
+  void f1(
+    int ([[]] __attribute__(()) int n)
+  ) {
+  }
+
+  void f2(
+      int (*)([[]] __attribute__(()) int n)
+  ) {
+  }
+
+  void f3(
+    int (__attribute__(()) [[]] int n) // expected-error {{an attribute list cannot appear here}}
+  ) {
+  }
+
+  void f4(
+      int (*)(__attribute__(()) [[]] int n) // expected-error {{an attribute list cannot appear here}}
+  ) {
+  }
+};

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 on the following two lines.
-  // 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;
-  int *z2 [[clang::annotate_type("bar")]];
+  [[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 annotated_function([[clang::annotate_type("bar")]] int);
-void g([[clang::annotate_type("bar")]] int);
-struct [[clang::annotate_type("foo")]] S;
-struct [[clang::annotate_type("foo")]] S{
-  [[clang::annotate_type("foo")]] int member;
-  [[clang::annotate_type("foo")]] union {
+[[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}}
+struct [[clang::annotate_type("foo")]] S; // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
+struct [[clang::annotate_type("foo")]] S{ // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
+  [[clang::annotate_type("foo")]] int member; // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
+  [[clang::annotate_type("foo")]] union { // expected-error {{an attribute list cannot appear here}}
     int i;
     float f;
   };
 };

clang/test/SemaCXX/address-space-placement.cpp

+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify %s
+
+// Check that we emit the correct warnings in various situations where the C++11
+// spelling of the `address_space` attribute is applied to a declaration instead
+// of a type.
+
+void f([[clang::address_space(1)]] int* param) { // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+  [[clang::address_space(1)]] int* local1; // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+  int* local2 [[clang::address_space(1)]]; // expected-error {{automatic variable qualified with an address space}} expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+
+  for ([[clang::address_space(1)]] int* p = nullptr; p; ++p) {} // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+  for (; [[clang::address_space(1)]] int* p = nullptr; ) {} // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+  while([[clang::address_space(1)]] int* p = nullptr) {} // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+  if ([[clang::address_space(1)]] int* p = nullptr) {} // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+  try {
+  } catch([[clang::address_space(1)]] int& i) { // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+  }
+}
+
+[[clang::address_space(1)]] int* return_value(); // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+
+[[clang::address_space(1)]] int global1; // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+int global2 [[clang::address_space(1)]]; // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+
+struct [[clang::address_space(1)]] S { // expected-error {{'address_space' attribute cannot be applied to a declaration}}
+  [[clang::address_space(1)]] int* member_function(); // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+};
+
+template <class T>
+[[clang::address_space(1)]] T var_template; // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+
+using void_ptr [[clang::address_space(1)]] = void *; // expected-warning {{applying attribute 'address_space' to a declaration is deprecated; apply it to the type instead}}
+
+namespace N {}
+[[clang::address_space(1)]] using namespace N; // expected-error {{'address_space' attribute cannot be applied to a declaration}}

clang/test/SemaCXX/annotate-type.cpp

 // 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;
-struct [[clang::annotate_type("foo")]] S3{
-  [[clang::annotate_type("foo")]] int member;
+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}}
+struct [[clang::annotate_type("foo")]] S3{ // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
+  [[clang::annotate_type("foo")]] int member; // 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")]] bool b = false;) {}
-  while ([[clang::annotate_type("foo")]] bool b = false) {}
-  if ([[clang::annotate_type("foo")]] bool b = false) {}
+  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) {
+  } 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;
-[[clang::annotate_type("foo")]] extern "C" int extern_c_func();
-extern "C" [[clang::annotate_type("foo")]] int extern_c_func();
+[[clang::annotate_type("foo")]] T var_template; // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}
+[[clang::annotate_type("foo")]] extern "C" int extern_c_func(); // expected-error {{an attribute list cannot appear here}}
+extern "C" [[clang::annotate_type("foo")]] int extern_c_func(); // expected-error {{'annotate_type' attribute cannot be applied to a declaration}}

clang/test/SemaOpenCL/address-spaces.cl

void func_multiple_addr2(void) {
   __attribute__((opencl_global)) __private int var1;   // expected-error {{multiple address spaces specified for type}} \
                                                        // expected-error {{function scope variable cannot be declared in global address space}}
   __private __attribute__((opencl_global)) int *var2;  // expected-error {{multiple address spaces specified for type}}
   __attribute__((opencl_global)) private_int_t var3;   // expected-error {{multiple address spaces specified for type}}
   __attribute__((opencl_global)) private_int_t *var4;  // expected-error {{multiple address spaces specified for type}}
   __attribute__((opencl_private)) private_int_t var5;  // expected-warning {{multiple identical address spaces specified for type}}
   __attribute__((opencl_private)) private_int_t *var6; // expected-warning {{multiple identical address spaces specified for type}}
 #if __OPENCL_CPP_VERSION__
-  [[clang::opencl_private]] __global int var7;         // expected-error {{multiple address spaces specified for type}}
-  [[clang::opencl_private]] __global int *var8;        // expected-error {{multiple address spaces specified for type}}
-  [[clang::opencl_private]] private_int_t var9;        // expected-warning {{multiple identical address spaces specified for type}}
-  [[clang::opencl_private]] private_int_t *var10;      // expected-warning {{multiple identical address spaces specified for type}}
+  __global int [[clang::opencl_private]] var7;         // expected-error {{multiple address spaces specified for type}}
+  __global int [[clang::opencl_private]] *var8;        // expected-error {{multiple address spaces specified for type}}
+  private_int_t [[clang::opencl_private]] var9;        // expected-warning {{multiple identical address spaces specified for type}}
+  private_int_t [[clang::opencl_private]] *var10;      // expected-warning {{multiple identical address spaces specified for type}}
 #endif // !__OPENCL_CPP_VERSION__
 }

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