[Parse] Add parsing support for C++ attributes on using-declarations

[ldionne]

Summary

This is split off from D90188.

[aaron.ballman]

Can you mention this change in the release notes? Also, should we document it explicitly in the Language Extensions documentation, or do you think this is too tiny of a feature to warrant that?

clang/include/clang/Parse/Parser.h

2648

In general, things named with CXX11Attributes really mean double square bracket attributes more than C++, so they also impact [[]] behavior in C. I think the function name here is fine (it's just as bad as the other names) but the comment should probably also include C2x attributes.

clang/lib/Parse/ParseDecl.cpp

1606

And the implementation side of things should probably be checking isC2xAttribute() as well.

1607

Can you also pass in << PA.getRange()? (This ensures that the whole attribute is underlined for the diagnostic instead of just the first token of the attribute, which may be just the vendor namespace.)

[aaron.ballman]

clang/test/Parser/cxx0x-attributes.cpp

134

Btw, a -pedantic test for the parser behavior would be useful so that we can be sure the new diagnostic is firing as expected.

[Mordante]

Thanks for the patch!
No further comments regarding the patch, except the items Aaron already mentioned.

[rsmith]

Do [[deprecated]] and [[maybe_unused]] now work for using-declarators? If so, a test for that would be useful.

clang/lib/Parse/ParseDeclCXX.cpp

714

Should we suggest moving the attributes after the identifier in this case (even though that will leave the program ill-formed), as we do for alias-declarations?

737

Should the prefix attributes go before the suffix attributes? (I could imagine there might be attributes for which order matters.) What do we do in the simple-declaration case?

[aaron.ballman]

In D91630#2400731, @rsmith wrote:

Do [[deprecated]] and [[maybe_unused]] now work for using-declarators? If so, a test for that would be useful.

I think the answer is yes and no, respectively (at least in terms of whether the attribute will apply to the subject) -- but [[clang::annotate("whatever")]] is also a good test attribute as would be any attribute whose Subjects includes Named (for NamedDecls).

[erik.pilkington]

Address review comments.

[erik.pilkington]

In D91630#2399995, @aaron.ballman wrote:

Can you mention this change in the release notes? Also, should we document it explicitly in the Language Extensions documentation, or do you think this is too tiny of a feature to warrant that?

Sure, I added release notes and language extension docs. I also added a __has_extension for this. That might all be a little overkill, I'm happy to pull out those changes if so.

In D91630#2400731, @rsmith wrote:

Do [[deprecated]] and [[maybe_unused]] now work for using-declarators? If so, a test for that would be useful.

[[deprecated]] gets applied, but it doesn't have any effect, since we don't attach an attribute to the UsingShadowDecl, and regardless, we already look past the UsingShadowDecl before we reach DiagnoseUseOfDecl. I added a -Wignored-attributes diagnostic to call this out.

clang/lib/Parse/ParseDeclCXX.cpp

714

Sure, I added this in the new patch.

737

Surprisingly, this does apply attributes to the beginning of the list:

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

This is consistent with simple-declarations.

clang/test/Parser/cxx0x-attributes.cpp

134

Sure, I added that in a new test file.

[aaron.ballman]

LGTM aside from a few minor NFC changes and a documentation request. Thank you for this!

clang/docs/LanguageExtensions.rst

623

Wrong number of = here -- should extend them to the end of the heading.

630

Can you also add using foo::bar [[clang::using_if_exists]]; to show that we support the syntax in two locations?

clang/lib/Sema/SemaDeclAttr.cpp

2419

isa<UsingDecl, UnresolvedUsingTypenameDecl, UnresolvedUsingValueDecl>(D)

6952

Same suggestion here.

[ldionne]

Gentle ping! Can we merge this? I'd love to move forward with https://reviews.llvm.org/D90257.

[erik.pilkington]

Address @aaron.ballman's review comments. Also, fix a bug where we failed to properly parse an inherited constructor declaration with a trailing attribute.

[aaron.ballman]

LGTM with a minor improvement for attribute ordering.

clang/lib/Parse/ParseDeclCXX.cpp

732–733

You should replace these two lines with a call to: MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs); so that order of GNU vs CXX syntax doesn't matter (they can be interleaved).

[ldionne]

Rebase onto main and apply Aaron's comment.

[aaron.ballman]

LGTM aside from some minor nits.

clang/include/clang/Basic/DiagnosticSemaKinds.td

3961

clang/lib/Parse/ParseDeclCXX.cpp

501

Might as well clang-format this (same for the other clang-format issues where you've changed the code).

693

You can ignore this clang-format message though.

[ldionne]

Apply review comments.

[thakis]

Looks like this breaks tests http://45.33.8.238/linux/47752/step_7.txt

[thakis]

This is breaking check-clang everywhere, eg https://lab.llvm.org/buildbot/#/builders/109/builds/15757

Please run tests before landing, or failing that watch the bots after committing.

Reverted in f63adf5b67f7a25b15f81d3a1a207aba4f226dc4 for now.

[ormris]

This is also failing on several buildbots: https://lab.llvm.org/buildbot/#/builders/139/builds/4812

Since it's been failing for a few hours, I'd like to revert this in the near future to unclog our internal CI and the buildbots.

EDIT: @thakis beat me to it...

[ldionne]

In D91630#2787438, @thakis wrote:

This is breaking check-clang everywhere, eg https://lab.llvm.org/buildbot/#/builders/109/builds/15757

Please run tests before landing, or failing that watch the bots after committing.

Reverted in f63adf5b67f7a25b15f81d3a1a207aba4f226dc4 for now.

Sorry about that, I thought the pre-commit CI here on Phabricator had passed those tests successfully. The only failures I was seeing were related to clang-format. I'm not sure what happened. Anyway, thanks for reverting, I'll take a look at this.

[ldionne]

Rebase onto main. I want to trigger CI again.

[ldionne]

Fix embarrassingly obvious oversight when I applied Aaron's feedback.

clang/docs/LanguageExtensions.rst

     OM_Terrified __attribute__((deprecated)),
     OM_AbortOnError __attribute__((deprecated)) = 4
   };
 
 Attributes on the ``enum`` declaration do not apply to individual enumerators.
 
 Query for this feature with ``__has_extension(enumerator_attributes)``.
 
+C++11 Attributes on using-declarations
+================================
+
+Clang allows C++-style ``[[]]`` attributes to be written on using-declarations.
+For instance:
+
+.. code-block:: c++
+
+  [[clang::using_if_exists]] using foo::bar;
+
+You can test for support for this extension with
+``__has_extension(cxx_attributes_on_using_declarations)``.
+
 'User-Specified' System Frameworks
 ==================================
 
 Clang provides a mechanism by which frameworks can be built in such a way that
 they will always be treated as being "system frameworks", even if they are not
 present in a system framework directory.  This can be useful to system
 framework developers who want to be able to test building other applications
 with development builds of their framework, including the manner in which the

clang/docs/ReleaseNotes.rst

 
 Attribute Changes in Clang
 --------------------------
 
 - Added support for the C++20 likelihood attributes ``[[likely]]`` and
   ``[[unlikely]]``. As an extension they can be used in C++11 and newer.
   This extension is enabled by default.
 
+- Added support for C++11-style ``[[]]`` attributes on using-declarations, as a
+  clang extension.
+
 Windows Support
 ---------------
 
 C Language Changes in Clang
 ---------------------------
 
 - ...
 

clang/include/clang/Basic/DiagnosticParseKinds.td

   "default scope specifier for attributes is incompatible with C++ standards "
   "before C++17">, InGroup<CXXPre17Compat>, DefaultIgnore;
 def ext_using_attribute_ns : ExtWarn<
   "default scope specifier for attributes is a C++17 extension">,
   InGroup<CXX17>;
 def err_using_attribute_ns_conflict : Error<
   "attribute with scope specifier cannot follow default scope specifier">;
 def err_attributes_not_allowed : Error<"an attribute list cannot appear here">;
+def ext_cxx11_attr_placement : ExtWarn<
+  "ISO C++ does not allow an attribute list to appear here">,
+  InGroup<DiagGroup<"cxx-attribute-extension">>;
 def err_attributes_misplaced : Error<"misplaced attributes; expected attributes here">;
 def err_l_square_l_square_not_attribute : Error<
   "C++11 only allows consecutive left square brackets when "
   "introducing an attribute">;
 def err_ms_declspec_type : Error<
   "__declspec attributes must be an identifier or string literal">;
 def err_ms_property_no_getter_or_putter : Error<
   "property does not specify a getter or a putter">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def note_declared_nonnull : Note<
   "declared %select{'returns_nonnull'|'nonnull'}0 here">;
 def warn_attribute_sentinel_named_arguments : Warning<
   "'sentinel' attribute requires named arguments">,
   InGroup<IgnoredAttributes>;
 def warn_attribute_sentinel_not_variadic : Warning<
   "'sentinel' attribute only supported for variadic %select{functions|blocks}0">,
   InGroup<IgnoredAttributes>;
+def warn_deprecated_ignored_on_using : Warning<
+  "%0 currently has no effect on using-declarations">,
+  InGroup<IgnoredAttributes>;
 def err_attribute_sentinel_less_than_zero : Error<
   "'sentinel' parameter 1 less than zero">;
 def err_attribute_sentinel_not_zero_or_one : Error<
   "'sentinel' parameter 2 not 0 or 1">;
 def warn_cleanup_ext : Warning<
   "GCC does not allow the 'cleanup' attribute argument to be anything other "
   "than a simple identifier">,
   InGroup<GccCompat>;

 def warn_objc_designated_init_non_designated_init_call : Warning<
   "designated initializer invoked a non-designated initializer">,
   InGroup<ObjCDesignatedInit>;
 def warn_objc_secondary_init_super_init_call : Warning<
   "convenience initializer should not invoke an initializer on 'super'">,
   InGroup<ObjCDesignatedInit>;
 def warn_objc_secondary_init_missing_init_call : Warning<
   "convenience initializer missing a 'self' call to another initializer">,
   InGroup<ObjCDesignatedInit>;
 def warn_objc_implementation_missing_designated_init_override : Warning<
   "method override for the designated initializer of the superclass %objcinstance0 not found">,
   InGroup<ObjCDesignatedInit>;
 def err_designated_init_attr_non_init : Error<
   "'objc_designated_initializer' attribute only applies to init methods "
   "of interface or class extension declarations">;
 
 // objc_bridge attribute diagnostics.

clang/include/clang/Basic/Features.def

 EXTENSION(cxx_variable_templates, LangOpts.CPlusPlus)
 // Miscellaneous language extensions
 EXTENSION(overloadable_unmarked, true)
 EXTENSION(pragma_clang_attribute_namespaces, true)
 EXTENSION(pragma_clang_attribute_external_declaration, true)
 EXTENSION(gnu_asm, LangOpts.GNUAsm)
 EXTENSION(gnu_asm_goto_with_outputs, LangOpts.GNUAsm)
 EXTENSION(matrix_types, LangOpts.MatrixTypes)
+EXTENSION(cxx_attributes_on_using_declarations, LangOpts.CPlusPlus11)
 
 FEATURE(cxx_abi_relative_vtable, LangOpts.CPlusPlus && LangOpts.RelativeCXXABIVTables)
 
 #undef EXTENSION
 #undef FEATURE

clang/include/clang/Parse/Parser.h

                                     SourceLocation FixItLoc);
 
   // Forbid C++11 and C2x attributes that appear on certain syntactic locations
   // which standard permits but we don't supported yet, for example, attributes
   // appertain to decl specifiers.
   void ProhibitCXX11Attributes(ParsedAttributesWithRange &Attrs,
                                unsigned DiagID);
 
+  /// Emit warnings for C++11 and C2x attributes that are in a position that
+  /// clang accepts as an extension.
+  void DiagnoseCXX11AttributeExtension(ParsedAttributesWithRange &Attrs);
+
   /// Skip C++11 and C2x attributes and return the end location of the
   /// last one.
   /// \returns SourceLocation() if there are no attributes.
   SourceLocation SkipCXX11Attributes();
 
   /// Diagnose and skip C++11 and C2x attributes that appear in syntactic
   /// locations where attributes are not allowed.
   void DiagnoseAndSkipCXX11Attributes();

     }
   };
 
   bool ParseUsingDeclarator(DeclaratorContext Context, UsingDeclarator &D);
   DeclGroupPtrTy ParseUsingDeclaration(DeclaratorContext Context,
                                        const ParsedTemplateInfo &TemplateInfo,
                                        SourceLocation UsingLoc,
                                        SourceLocation &DeclEnd,
+                                       ParsedAttributesWithRange &Attrs,
                                        AccessSpecifier AS = AS_none);
   Decl *ParseAliasDeclarationAfterDeclarator(
       const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc,
       UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS,
       ParsedAttributes &Attrs, Decl **OwnedType = nullptr);
 
   Decl *ParseStaticAssertDeclaration(SourceLocation &DeclEnd);
   Decl *ParseNamespaceAlias(SourceLocation NamespaceLoc,

clang/lib/Parse/ParseDecl.cpp

           << AL << AL.getRange();
     else {
       Diag(AL.getLoc(), DiagID) << AL;
       AL.setInvalid();
     }
   }
 }
 
+void Parser::DiagnoseCXX11AttributeExtension(ParsedAttributesWithRange &Attrs) {
+  for (const ParsedAttr &PA : Attrs) {
+    if (PA.isCXX11Attribute() || PA.isC2xAttribute())
+      Diag(PA.getLoc(), diag::ext_cxx11_attr_placement) << PA << PA.getRange();
+  }
+}
+
 // Usually, `__attribute__((attrib)) class Foo {} var` means that attribute
 // applies to var, not the type Foo.
 // As an exception to the rule, __declspec(align(...)) before the
 // class-key affects the type instead of the variable.
 // Also, Microsoft-style [attributes] seem to affect the type instead of the
 // variable.
 // This function moves attributes that should apply to the type off DS to Attrs.
 void Parser::stripTypeAttributesOffDeclSpec(ParsedAttributesWithRange &Attrs,

clang/lib/Parse/ParseDeclCXX.cpp

         << 0 /* directive */ << R << FixItHint::CreateRemoval(R);
     }
 
     Decl *UsingDir = ParseUsingDirective(Context, UsingLoc, DeclEnd, attrs);
     return Actions.ConvertDeclToDeclGroup(UsingDir);
   }
 
   // Otherwise, it must be a using-declaration or an alias-declaration.
-
-  // Using declarations can't have attributes.
-  ProhibitAttributes(attrs);
-
   return ParseUsingDeclaration(Context, TemplateInfo, UsingLoc, DeclEnd,
-                               AS_none);
+                               attrs, AS_none);
 }
 
 /// ParseUsingDirective - Parse C++ using-directive, assumes
 /// that current token is 'namespace' and 'using' was already parsed.
 ///
 ///       using-directive: [C++ 7.3.p4: namespace.udir]
 ///        'using' 'namespace' ::[opt] nested-name-specifier[opt]
 ///                 namespace-name ;

 ///
 ///     alias-declaration: C++11 [dcl.dcl]p1
 ///       'using' identifier attribute-specifier-seq[opt] = type-id ;
 ///
 Parser::DeclGroupPtrTy
 Parser::ParseUsingDeclaration(DeclaratorContext Context,
                               const ParsedTemplateInfo &TemplateInfo,
                               SourceLocation UsingLoc, SourceLocation &DeclEnd,
+                              ParsedAttributesWithRange &PrefixAttrs,
                               AccessSpecifier AS) {
   // Check for misplaced attributes before the identifier in an
   // alias-declaration.
   ParsedAttributesWithRange MisplacedAttrs(AttrFactory);
   MaybeParseCXX11Attributes(MisplacedAttrs);
 
   UsingDeclarator D;
   bool InvalidDeclarator = ParseUsingDeclarator(Context, D);
 
   ParsedAttributesWithRange Attrs(AttrFactory);
   MaybeParseGNUAttributes(Attrs);
   MaybeParseCXX11Attributes(Attrs);
 
+  // If we had any misplaced attributes from earlier, this is where they
+  // should have been written.
+  if (MisplacedAttrs.Range.isValid()) {
+    Diag(MisplacedAttrs.Range.getBegin(), diag::err_attributes_not_allowed)
+        << FixItHint::CreateInsertionFromRange(
+            Tok.getLocation(),
+            CharSourceRange::getTokenRange(MisplacedAttrs.Range))
+        << FixItHint::CreateRemoval(MisplacedAttrs.Range);
+    Attrs.takeAllFrom(MisplacedAttrs);
+  }
+
   // Maybe this is an alias-declaration.
   if (Tok.is(tok::equal)) {
     if (InvalidDeclarator) {
       SkipUntil(tok::semi);
       return nullptr;
     }
 
-    // If we had any misplaced attributes from earlier, this is where they
-    // should have been written.
-    if (MisplacedAttrs.Range.isValid()) {
-      Diag(MisplacedAttrs.Range.getBegin(), diag::err_attributes_not_allowed)
-        << FixItHint::CreateInsertionFromRange(
-               Tok.getLocation(),
-               CharSourceRange::getTokenRange(MisplacedAttrs.Range))
-        << FixItHint::CreateRemoval(MisplacedAttrs.Range);
-      Attrs.takeAllFrom(MisplacedAttrs);
-    }
+    ProhibitAttributes(PrefixAttrs);
 
     Decl *DeclFromDeclSpec = nullptr;
     Decl *AD = ParseAliasDeclarationAfterDeclarator(
         TemplateInfo, UsingLoc, D, DeclEnd, AS, Attrs, &DeclFromDeclSpec);
     return Actions.ConvertDeclToDeclGroup(AD, DeclFromDeclSpec);
   }
 
-  // C++11 attributes are not allowed on a using-declaration, but GNU ones
-  // are.
-  ProhibitAttributes(MisplacedAttrs);
-  ProhibitAttributes(Attrs);
+  DiagnoseCXX11AttributeExtension(PrefixAttrs);
 
   // Diagnose an attempt to declare a templated using-declaration.
   // In C++11, alias-declarations can be templates:
   //   template <...> using id = type;
   if (TemplateInfo.Kind) {
     SourceRange R = TemplateInfo.getSourceRange();
     Diag(UsingLoc, diag::err_templated_using_directive_declaration)
       << 1 /* declaration */ << R << FixItHint::CreateRemoval(R);
 
     // Unfortunately, we have to bail out instead of recovering by
     // ignoring the parameters, just in case the nested name specifier
     // depends on the parameters.
     return nullptr;
   }
 
   SmallVector<Decl *, 8> DeclsInGroup;
   while (true) {
-    // Parse (optional) attributes (most likely GNU strong-using extension).
+    // Parse (optional) attributes.
     MaybeParseGNUAttributes(Attrs);
+    MaybeParseCXX11Attributes(Attrs);
+    DiagnoseCXX11AttributeExtension(Attrs);
+    Attrs.addAll(PrefixAttrs.begin(), PrefixAttrs.end());
 
     if (InvalidDeclarator)
       SkipUntil(tok::comma, tok::semi, StopBeforeMatch);
     else {
       // "typename" keyword is allowed for identifiers only,
       // because it may be a type definition.
       if (D.TypenameLoc.isValid() &&
           D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {
         Diag(D.Name.getSourceRange().getBegin(),
              diag::err_typename_identifiers_only)

   // We need to keep these attributes for future diagnostic
   // before they are taken over by declaration specifier.
   FnAttrs.addAll(attrs.begin(), attrs.end());
   FnAttrs.Range = attrs.Range;
 
   MaybeParseMicrosoftAttributes(attrs);
 
   if (Tok.is(tok::kw_using)) {
-    ProhibitAttributes(attrs);
-
     // 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, AS);
+                                 UsingLoc, DeclEnd, attrs, AS);
   }
 
   // Hold late-parsed attributes so we can attach a Decl to them later.
   LateParsedAttrList CommonLateParsedAttrs;
 
   // decl-specifier-seq:
   // Parse the common declaration-specifiers piece.
   ParsingDeclSpec DS(*this, TemplateDiags);

clang/lib/Sema/SemaDeclAttr.cpp

         Message, IsStrict, Replacement, Priority);
     Avail->setImplicit(Implicit);
     return Avail;
   }
   return nullptr;
 }
 
 static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  if (isa<UsingDecl>(D) || isa<UnresolvedUsingTypenameDecl>(D) ||
+      isa<UnresolvedUsingValueDecl>(D)) {
+    S.Diag(AL.getRange().getBegin(), diag::warn_deprecated_ignored_on_using)
+        << AL;
+    return;
+  }
+
   if (!checkAttributeNumArgs(S, AL, 1))
     return;
   IdentifierLoc *Platform = AL.getArgAsIdent(0);
 
   IdentifierInfo *II = Platform->Ident;
   if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
     S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
       << Platform->Ident;

   if (const auto *NSD = dyn_cast<NamespaceDecl>(D)) {
     if (NSD->isAnonymousNamespace()) {
       S.Diag(AL.getLoc(), diag::warn_deprecated_anonymous_namespace);
       // Do not want to attach the attribute to the namespace because that will
       // cause confusing diagnostic reports for uses of declarations within the
       // namespace.
       return;
     }
+  } else if (isa<UsingDecl>(D) ||
+             isa<UnresolvedUsingTypenameDecl>(D) ||
+             isa<UnresolvedUsingValueDecl>(D)) {
+    S.Diag(AL.getRange().getBegin(), diag::warn_deprecated_ignored_on_using)
+        << AL;
+    return;
   }
 
   // Handle the cases where the attribute has a text message.
   StringRef Str, Replacement;
   if (AL.isArgExpr(0) && AL.getArgAsExpr(0) &&
       !S.checkStringLiteralArgumentAttr(AL, 0, Str))
     return;
 

clang/lib/Sema/SemaDeclCXX.cpp

     return nullptr;
 
   // Check for bad qualifiers.
   if (CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword, SS, NameInfo,
                               IdentLoc))
     return nullptr;
 
   DeclContext *LookupContext = computeDeclContext(SS);
-  NamedDecl *D;
   NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
   if (!LookupContext || EllipsisLoc.isValid()) {
+    NamedDecl *D;
     if (HasTypenameKeyword) {
       // FIXME: not all declaration name kinds are legal here
       D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
                                               UsingLoc, TypenameLoc,
                                               QualifierLoc,
                                               IdentLoc, NameInfo.getName(),
                                               EllipsisLoc);
     } else {
       D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
                                            QualifierLoc, NameInfo, EllipsisLoc);
     }
     D->setAccess(AS);
     CurContext->addDecl(D);
+    ProcessDeclAttributeList(S, D, AttrList);
     return D;
   }
 
   auto Build = [&](bool Invalid) {
     UsingDecl *UD =
         UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
                           UsingName, HasTypenameKeyword);
     UD->setAccess(AS);
     CurContext->addDecl(UD);
+    ProcessDeclAttributeList(S, UD, AttrList);
     UD->setInvalidDecl(Invalid);
     return UD;
   };
   auto BuildInvalid = [&]{ return Build(true); };
   auto BuildValid = [&]{ return Build(false); };
 
   if (RequireCompleteDeclContext(SS, LookupContext))
     return BuildInvalid();

clang/test/Parser/cxx0x-attributes.cpp

class foo {
   void const_after_attr () [[]] const; // expected-error {{expected ';'}}
 };
 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; // 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}}
 namespace [[]] ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}}
 
-using [[]] alignas(4) [[]] ns::i; // expected-error {{an attribute list cannot appear here}}
+using [[]] alignas(4) [[]] ns::i; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to variables, data members and tag types}} expected-warning {{ISO C++}}
 using [[]] alignas(4) [[]] foobar = int; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to}}
 
 void bad_attributes_in_do_while() {
   do {} while (
       [[ns::i); // expected-error {{expected ']'}} \
                 // expected-note {{to match this '['}} \
                 // expected-error {{expected expression}}
   do {} while (
       [[a]b ns::i); // expected-error {{expected ']'}} \
                     // expected-note {{to match this '['}} \
                     // expected-error {{expected expression}}
   do {} while (
       [[ab]ab] ns::i); // expected-error {{an attribute list cannot appear here}}
   do {} while ( // expected-note {{to match this '('}}
       alignas(4 ns::i; // expected-note {{to match this '('}}
 } // expected-error 2{{expected ')'}} expected-error {{expected expression}}
 
 [[]] using T = int; // expected-error {{an attribute list cannot appear here}}
 using T [[]] = int; // ok
 template<typename T> using U [[]] = T;
-using ns::i [[]]; // expected-error {{an attribute list cannot appear here}}
+using ns::i [[]];
+using ns::i [[]], ns::i [[]]; // expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}}
+struct using_in_struct_base {
+  typedef int i, j, k, l;
+};
+struct using_in_struct : using_in_struct_base {
+  [[]] using using_in_struct_base::i;
+  using using_in_struct_base::j [[]];
+  [[]] using using_in_struct_base::k [[]], using_in_struct_base::l [[]]; // expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}}
+};
 using [[]] ns::i; // expected-error {{an attribute list cannot appear here}}
 using T [[unknown]] = int; // expected-warning {{unknown attribute 'unknown' ignored}}
 using T [[noreturn]] = int; // expected-error {{'noreturn' attribute only applies to functions}}
 using V = int; // expected-note {{previous}}
 using V [[gnu::vector_size(16)]] = int; // expected-error {{redefinition with different types}}
 
 auto trailing() -> [[]] const int; // expected-error {{an attribute list cannot appear here}}
 auto trailing() -> const [[]] int; // expected-error {{an attribute list cannot appear here}}

clang/test/SemaCXX/cxx11-attributes-on-using-declaration.cpp

+// RUN: %clang_cc1 -pedantic -triple x86_64-apple-macos11 -std=c++20 -fsyntax-only -verify %s
+
+static_assert(__has_extension(cxx_attributes_on_using_declarations), "");
+
+namespace NS { typedef int x; }
+
+[[clang::annotate("foo")]] using NS::x; // expected-warning{{ISO C++ does not allow an attribute list to appear here}}
+
+
+[[deprecated]] using NS::x; // expected-warning {{'deprecated' currently has no effect on using-declarations}} expected-warning{{ISO C++ does not allow}}
+using NS::x [[deprecated]]; // expected-warning {{'deprecated' currently has no effect on using-declarations}} expected-warning{{ISO C++ does not allow}}
+using NS::x __attribute__((deprecated)); // expected-warning {{'deprecated' currently has no effect on using-declarations}}
+using NS::x __attribute__((availability(macos,introduced=1))); // expected-warning {{'availability' currently has no effect on using-declarations}}
+
+[[clang::availability(macos,introduced=1)]] using NS::x; // expected-warning {{'availability' currently has no effect on using-declarations}} expected-warning{{ISO C++ does not allow}}
+
+// expected-warning@+1 3 {{ISO C++ does not allow an attribute list to appear here}}
+[[clang::annotate("A")]] using NS::x [[clang::annotate("Y")]], NS::x [[clang::annotate("Z")]];
+
+template <class T>
+struct S : T {
+  [[deprecated]] using typename T::x; // expected-warning{{ISO C++ does not allow}} expected-warning {{'deprecated' currently has no effect on using-declarations}}
+  [[deprecated]] using T::y; // expected-warning{{ISO C++ does not allow}} expected-warning {{'deprecated' currently has no effect on using-declarations}}
+
+  using typename T::z [[deprecated]]; // expected-warning{{ISO C++ does not allow}} expected-warning {{'deprecated' currently has no effect on using-declarations}}
+  using T::a [[deprecated]]; // expected-warning{{ISO C++ does not allow}} expected-warning {{'deprecated' currently has no effect on using-declarations}}
+};