[clang] Enable C++11-style attributes in all language modes

[philnik]

Summary

This also ignores and deprecates the -fdouble-square-bracket-attributes command line flag, which seems to not be used anywhere. At least a code search exclusively found mentions of it in documentation: https://sourcegraph.com/search?q=context:global+-fdouble-square-bracket-attributes+-file:clang/*+-file:test/Sema/*+-file:test/Parser/*+-file:test/AST/*+-file:test/Preprocessor/*+-file:test/Misc/*+archived:yes&patternType=standard&sm=0&groupBy=repo

RFC: https://discourse.llvm.org/t/rfc-enable-c-11-c2x-attributes-in-all-standard-modes-as-an-extension-and-remove-fdouble-square-bracket-attributes

This enables [[]] attributes in all C and C++ language modes without warning by default. -Wc++-extensions does warn. GCC has enabled this extension in all C modes since GCC 10.

[philnik]

clang/test/ParserHLSL/group_shared.hlsl

14

Should this also get an extension warning/should attributes be disabled for HLSL?

[erichkeane]

What is the justification for this? Do other compilers do this? Was there an RFC?

[philnik]

In D151683#4380877, @erichkeane wrote:

What is the justification for this?

What exactly are you asking for? Why I'd like to back port it? This would make quite a bit of code in libc++ simpler and avoids pit-falls where an attribute works in some place in some version but not in another.

Do other compilers do this?

ICC and NVC++ support this: https://godbolt.org/z/TeMnGdGsY

Was there an RFC?

No. I guess, since you are asking I should write one for this? Only for the removal of -fdouble-square-bracket-attributes, or also for back porting this?

[erichkeane]

In D151683#4382408, @philnik wrote:

In D151683#4380877, @erichkeane wrote:

What is the justification for this?

What exactly are you asking for? Why I'd like to back port it? This would make quite a bit of code in libc++ simpler and avoids pit-falls where an attribute works in some place in some version but not in another.

Do other compilers do this?

ICC and NVC++ support this: https://godbolt.org/z/TeMnGdGsY

Was there an RFC?

No. I guess, since you are asking I should write one for this? Only for the removal of -fdouble-square-bracket-attributes, or also for back porting this?

The RFC I would expect for "allow C/C++ style attributes as an extension in previous modes". This is a pretty significant feature to allow as an extension, particularly since our two main alternative compilers (G++/MSVC) don't have this as an extension. I'd be curious how the other C compilers do this as well.

[aaron.ballman]

In D151683#4384017, @erichkeane wrote:

In D151683#4382408, @philnik wrote:

No. I guess, since you are asking I should write one for this? Only for the removal of -fdouble-square-bracket-attributes, or also for back porting this?

The RFC I would expect for "allow C/C++ style attributes as an extension in previous modes". This is a pretty significant feature to allow as an extension, particularly since our two main alternative compilers (G++/MSVC) don't have this as an extension. I'd be curious how the other C compilers do this as well.

I think this does warrant an RFC because it impacts both C++ and C, but I'm hoping the RFC is uncontroversial. It's mostly to establish what the use cases are for needing the extension. The feature is conforming as an extension to both languages, and I don't know of any breakage that would come from enabling it by default. I'm not certain whether we want to remove the feature flag immediately or whether we'd like to give one release of warning about it being removed (I'll defer to whatever @MaskRay thinks is reasonable) -- that search is compelling for why it's safe to remove the option, but there's plenty of proprietary code which we don't know about, so it's possible the option is still used. I'd be especially curious to know if anyone is using -fno-double-square-bracket-attributes to disable the feature in a mode where it would otherwise be enabled. I'm adding the clang-vendors group as a subscriber as an early warning that removing the command line option could be a potentially breaking change.

In terms of implementation work, there's still some minor stuff to address. Also, please be sure to also add a release note about the changes, and a potentially breaking entry for removing the command line option (assuming we elect to go that route).

clang/docs/LanguageExtensions.rst

1462

You need to add an entry here as well, as this also extends C.

clang/include/clang/Basic/DiagnosticParseKinds.td

556

Spurious whitespace change.

clang/include/clang/Driver/Options.td

3672

Spurious whitespace change.

clang/lib/Driver/ToolChains/Clang.cpp

1196 ↗

(On Diff #526514)

Spurious whitespace change.

clang/lib/Parse/ParseDeclCXX.cpp

4509–4515

Missing the same "not compatible with standards before C2x" warning as for C++ (might want to reword the C++ warning at the same time to fit the newer style)

clang/test/OpenMP/assumes_messages_attr.c

57

Spurious removal.

clang/test/Parser/asm.c

14

Spurious whitespace change

clang/test/Parser/cxx-decl.cpp

316

Huh... I wasn't expecting to see a change here because there's no attribute nearby. Probably fine, but still a bit curious.

322

Spurious change.

clang/test/Parser/objc-attr.m

17

Spurious change.

clang/test/ParserHLSL/group_shared.hlsl

14

CC @beanz

I was wondering the same thing. :-)

clang/test/Sema/attr-type-safety.c

45

Spurious change.

clang/test/Sema/overloadable.c

77

Spurious change.

clang/test/SemaCXX/attr-cxx-disabled.cpp

0

This whole test file can go away -- we no longer let you disable attributes with this extension.

[beanz]

clang/test/ParserHLSL/group_shared.hlsl

14

By bug rather than design DXC allows C++ attribute syntax in some places for HLSL.

I'm totally fine with (and prefer) following the rest of the languages here and having HLSL in Clang always allow C++ attributes regardless of language version.

[philnik]

clang/test/Parser/cxx-decl.cpp

316

This is probably because of the whitespace trim below.

clang/test/ParserHLSL/group_shared.hlsl

14

Would you like some sort of warning?

[beanz]

clang/test/ParserHLSL/group_shared.hlsl

14

Since DXC accepts the syntax without a warning/error I think we're fine without one here. There won't be any portability issues with code that use C++ attributes in HLSL unless they go back to the _extremely_ old compiler that we don't really support anyways.

[MaskRay]

In D151683#4409633, @aaron.ballman wrote:

In D151683#4384017, @erichkeane wrote:

In D151683#4382408, @philnik wrote:

No. I guess, since you are asking I should write one for this? Only for the removal of -fdouble-square-bracket-attributes, or also for back porting this?

The RFC I would expect for "allow C/C++ style attributes as an extension in previous modes". This is a pretty significant feature to allow as an extension, particularly since our two main alternative compilers (G++/MSVC) don't have this as an extension. I'd be curious how the other C compilers do this as well.

I think this does warrant an RFC because it impacts both C++ and C, but I'm hoping the RFC is uncontroversial. It's mostly to establish what the use cases are for needing the extension. The feature is conforming as an extension to both languages, and I don't know of any breakage that would come from enabling it by default. I'm not certain whether we want to remove the feature flag immediately or whether we'd like to give one release of warning about it being removed (I'll defer to whatever @MaskRay thinks is reasonable) -- that search is compelling for why it's safe to remove the option, but there's plenty of proprietary code which we don't know about, so it's possible the option is still used. I'd be especially curious to know if anyone is using -fno-double-square-bracket-attributes to disable the feature in a mode where it would otherwise be enabled. I'm adding the clang-vendors group as a subscriber as an early warning that removing the command line option could be a potentially breaking change.

In terms of implementation work, there's still some minor stuff to address. Also, please be sure to also add a release note about the changes, and a potentially breaking entry for removing the command line option (assuming we elect to go that route).

If allowing the extension in older language modes deems good, removing -fno-double-square-bracket-attributes seems fine if (and thanks for CCing the clang-vendors group).
If we want to play safely, we can default -fdouble-square-bracket-attributes to true in this patch and remove the option in a follow-up change possibly after some time.

[philnik]

Address comments

[philnik]

Try to fix CI

[aaron.ballman]

Aside from the failing precommit CI test case in C, I think this LGTM. I've added @MaskRay as the code owner for the command line option changes in case he's got concerns regarding the deprecation/removal plans.

[MaskRay]

In D151683#4486321, @aaron.ballman wrote:

Aside from the failing precommit CI test case in C, I think this LGTM. I've added @MaskRay as the code owner for the command line option changes in case he's got concerns regarding the deprecation/removal plans.

- ``-fdouble-square-bracket-attributes`` has been deprecated. It is ignored now
  and will be removed in CLang 18.

sounds good. (Minor case typo in CLang). As you said in

https://discourse.llvm.org/t/rfc-enable-c-11-c2x-attributes-in-all-standard-modes-as-an-extension-and-remove-fdouble-square-bracket-attributes/71268/2

I’m in support of this idea. I think we should enable the extension unconditionally for Clang 17 with a release note mentioning that -fdouble-square-bracket-attributes will be removed in Clang 18 just as a kindness to users with proprietary code bases that might be using it.

I think a clear summary/commit message should mention that this patch makes [[...]]` available to C++03/C17 and older language standards with no warning by default.

It's also worth calling out that GCC since 10 supports [[]] in all C language modes (AFAICT there is no warning even with gcc -std=c89 -c a.c) (there is a warning -pedantic).

% gcc -c a.c -std=c89  # no warning
% g++ -c a.cc -std=c++03
a.cc:2:1: error: expected unqualified-id before ‘[’ token
    2 | [[nodiscard]] int without_underscores(void);
      | ^
% myclang++ -c a.cc -std=c++03  # no warning with this patch

[MaskRay]

Reverse ping @philnik :)

The release/17.x branch will be created soon (https://discourse.llvm.org/t/llvm-17-0-0-release-planning-and-update/71762).

[philnik]

In D151683#4508209, @MaskRay wrote:

Reverse ping @philnik :)

The release/17.x branch will be created soon (https://discourse.llvm.org/t/llvm-17-0-0-release-planning-and-update/71762).

I know. I just didn't have the time yet. If you want to make sure it's in 17 feel free to commandeer and fix the last bits.

[philnik]

• Address comments
• Try to fix CI
• Rebased

[aaron.ballman]

LGTM!

[eaeltsin]

Hi,

Is it a known issue, that clang doesn't compile void foo(char *argv[] [[maybe_unused]]) {} ? The error is error: 'maybe_unused' attribute cannot be applied to types.

https://godbolt.org/z/r9E81cWxh - clang fails, but gcc doesn't.

It looks like there is a lot of oss code of the form void foo(char *argv[] ATTRIBUTE_UNUSED), where ATTRIBUTE_UNUSED was configured to __attribute__((unused)) before this change (thus compiled ok) and to [[maybe_unused]] after this change (thus started to break).

[aaron.ballman]

In D151683#4566907, @eaeltsin wrote:

Hi,

Is it a known issue, that clang doesn't compile void foo(char *argv[] [[maybe_unused]]) {} ? The error is error: 'maybe_unused' attribute cannot be applied to types.

https://godbolt.org/z/r9E81cWxh - clang fails, but gcc doesn't.

It looks like there is a lot of oss code of the form void foo(char *argv[] ATTRIBUTE_UNUSED), where ATTRIBUTE_UNUSED was configured to __attribute__((unused)) before this change (thus compiled ok) and to [[maybe_unused]] after this change (thus started to break).

https://eel.is/c++draft/dcl.array#3.sentence-2 -- an attribute in that position appertains to the array type and maybe_unused cannot be applied to types in that way, so I believe Clang's behavior is correct. So I think the C++ attribute behavior is expected, but the change between __attribute__ and [[]] may be catching folks off-guard.

clang/docs/LanguageExtensions.rst

 Use ``__has_feature(modules)`` to determine if Modules have been enabled.
 For example, compiling code with ``-fmodules`` enables the use of Modules.
 
 More information could be found `here <https://clang.llvm.org/docs/Modules.html>`_.
 
 Language Extensions Back-ported to Previous Standards
 =====================================================
 
-====================================== ================================ ============= ============= ==================================
-Feature                                Feature Test Macro               Introduced In Backported To Required Flags
-====================================== ================================ ============= ============= ==================================
+====================================== ================================ ============= =============
+Feature                                Feature Test Macro               Introduced In Backported To
+====================================== ================================ ============= =============
 variadic templates                     __cpp_variadic_templates         C++11         C++03
 Alias templates                        __cpp_alias_templates            C++11         C++03
 Non-static data member initializers    __cpp_nsdmi                      C++11         C++03
 Range-based ``for`` loop               __cpp_range_based_for            C++11         C++03
 RValue references                      __cpp_rvalue_references          C++11         C++03
-Attributes                             __cpp_attributes                 C++11         C++03         -fdouble-square-bracket-attributes
+Attributes                             __cpp_attributes                 C++11         C++03
 variable templates                     __cpp_variable_templates         C++14         C++03
 Binary literals                        __cpp_binary_literals            C++14         C++03
 Relaxed constexpr                      __cpp_constexpr                  C++14         C++11
 ``if constexpr``                       __cpp_if_constexpr               C++17         C++11
 fold expressions                       __cpp_fold_expressions           C++17         C++03
 Lambda capture of \*this by value      __cpp_capture_star_this          C++17         C++11
 Attributes on enums                    __cpp_enumerator_attributes      C++17         C++11
 Guaranteed copy elision                __cpp_guaranteed_copy_elision    C++17         C++03
 Hexadecimal floating literals          __cpp_hex_float                  C++17         C++03
 ``inline`` variables                   __cpp_inline_variables           C++17         C++03
 Attributes on namespaces               __cpp_namespace_attributes       C++17         C++11
 Structured bindings                    __cpp_structured_bindings        C++17         C++03
 template template arguments            __cpp_template_template_args     C++17         C++03
 ``static operator[]``                  __cpp_multidimensional_subscript C++20         C++03
 Designated initializers                __cpp_designated_initializers    C++20         C++03
 Conditional ``explicit``               __cpp_conditional_explicit       C++20         C++03
 ``using enum``                         __cpp_using_enum                 C++20         C++03
 ``if consteval``                       __cpp_if_consteval               C++23         C++20
 ``static operator()``                  __cpp_static_call_operator       C++23         C++03
--------------------------------------- -------------------------------- ------------- ------------- ----------------------------------
+-------------------------------------- -------------------------------- ------------- -------------
 Designated initializers (N494)                                          C99           C89
 Array & element qualification (N2607)                                   C2x           C89
-====================================== ================================ ============= ============= ==================================
+Attributes (N2335)                                                      C2x           C89
+====================================== ================================ ============= =============
 
 Type Trait Primitives
 =====================
 
 Type trait primitives are special builtin constant expressions that can be used
 by the standard C++ library to facilitate or simplify the implementation of
 user-facing type traits in the <type_traits> header.
 

clang/docs/ReleaseNotes.rst

- ``-dumpdir`` has been implemented to specify auxiliary and dump output
   filenames for features like ``-gsplit-dwarf``.
 - ``-fcaret-diagnostics-max-lines=`` has been added as a driver options, which
   lets users control the maximum number of source lines printed for a
   caret diagnostic.
 
 Deprecated Compiler Flags
 -------------------------
 
+- ``-fdouble-square-bracket-attributes`` has been deprecated. It is ignored now
+  and will be removed in Clang 18.
+
 Modified Compiler Flags
 -----------------------
 
 - ``clang -g -gsplit-dwarf a.c -o obj/x`` (compile and link) now generates the
   ``.dwo`` file at ``obj/x-a.dwo``, instead of a file in the temporary
   directory (``/tmp`` on \*NIX systems, if none of the environment variables
   TMPDIR, TMP, and TEMP are specified).
 

clang/include/clang/Basic/DiagnosticParseKinds.td

def err_expected_member_name_or_semi_objcxx_keyword : Error<
   "%0 is a keyword in Objective-C++">;
 
 /// C++ parser diagnostics
 def err_invalid_operator_on_type : Error<
   "cannot use %select{dot|arrow}0 operator on a type">;
 def err_expected_unqualified_id : Error<
   "expected %select{identifier|unqualified-id}0">;
 def err_while_loop_outside_of_a_function : Error<
   "while loop outside of a function">;
 def err_brackets_go_after_unqualified_id : Error<
   "brackets are not allowed here; to declare an array, "
   "place the brackets after the %select{identifier|name}0">;
 def err_unexpected_unqualified_id : Error<"type-id cannot have a name">;
 def err_func_def_no_params : Error<
   "function definition does not declare parameters">;
 def err_expected_lparen_after_type : Error<
   "expected '(' for function-style cast or type construction">;
def ext_ns_enum_attribute : Extension<
   "a C++17 extension">, InGroup<CXX17>;
 def warn_cxx14_compat_ns_enum_attribute : Warning<
   "attributes on %select{a namespace|an enumerator}0 declaration are "
   "incompatible with C++ standards before C++17">,
   InGroup<CXXPre17CompatPedantic>, DefaultIgnore;
 def warn_cxx98_compat_alignas : Warning<"'alignas' is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def warn_cxx98_compat_attribute : Warning<
-  "C++11 attribute syntax is incompatible with C++98">,
+  "[[]] attributes are incompatible with C++ standards before C++11">,
   InGroup<CXX98Compat>, DefaultIgnore;
+def warn_ext_cxx11_attributes : Extension<
+  "[[]] attributes are a C++11 extension">,
+  InGroup<CXX11>;
+def warn_pre_c2x_compat_attributes : Warning<
+  "[[]] attributes are incompatible with C standards before C2x">,
+  DefaultIgnore, InGroup<CPre2xCompat>;
+def warn_ext_c2x_attributes : Extension<
+  "[[]] attributes are a C2x extension">,
+  InGroup<C2x>;
 def err_cxx11_attribute_forbids_arguments : Error<
   "attribute %0 cannot have an argument list">;
 def err_attribute_requires_arguments : Error<
   "parentheses must be omitted if %0 attribute's argument list is empty">;
 def err_cxx11_attribute_forbids_ellipsis : Error<
   "attribute %0 cannot be used as an attribute pack">;
 def warn_cxx14_compat_using_attribute_ns : Warning<
   "default scope specifier for attributes is incompatible with C++ standards "

clang/include/clang/Basic/Features.def

 // C11 features supported by other languages as extensions.
 EXTENSION(c_alignas, true)
 EXTENSION(c_alignof, true)
 EXTENSION(c_atomic, true)
 EXTENSION(c_generic_selections, true)
 EXTENSION(c_generic_selection_with_controlling_type, true)
 EXTENSION(c_static_assert, true)
 EXTENSION(c_thread_local, PP.getTargetInfo().isTLSSupported())
+// C2x features supported by other languages as extensions
+EXTENSION(c_attributes, true)
 // C++11 features supported by other languages as extensions.
 EXTENSION(cxx_atomic, LangOpts.CPlusPlus)
 EXTENSION(cxx_default_function_template_args, LangOpts.CPlusPlus)
 EXTENSION(cxx_defaulted_functions, LangOpts.CPlusPlus)
 EXTENSION(cxx_deleted_functions, LangOpts.CPlusPlus)
 EXTENSION(cxx_explicit_conversions, LangOpts.CPlusPlus)
 EXTENSION(cxx_inline_namespaces, LangOpts.CPlusPlus)
 EXTENSION(cxx_local_type_template_args, LangOpts.CPlusPlus)

clang/include/clang/Driver/Options.td

 
 def fassume_sane_operator_new : Flag<["-"], "fassume-sane-operator-new">, Group<f_Group>;
 def fastcp : Flag<["-"], "fastcp">, Group<f_Group>;
 def fastf : Flag<["-"], "fastf">, Group<f_Group>;
 def fast : Flag<["-"], "fast">, Group<f_Group>;
 def fasynchronous_unwind_tables : Flag<["-"], "fasynchronous-unwind-tables">, Group<f_Group>;
 
 defm double_square_bracket_attributes : BoolFOption<"double-square-bracket-attributes",
-  LangOpts<"DoubleSquareBracketAttributes">, Default<!strconcat(cpp11.KeyPath, "||", c2x.KeyPath)>,
-  PosFlag<SetTrue, [], "Enable">, NegFlag<SetFalse, [], "Disable">,
-  BothFlags<[NoXarchOption, CC1Option], " '[[]]' attributes in all C and C++ language modes">>;
+  LangOpts<"DoubleSquareBracketAttributes">, DefaultTrue, PosFlag<SetTrue>, NegFlag<SetFalse>>;
 
 defm autolink : BoolFOption<"autolink",
   CodeGenOpts<"Autolink">, DefaultTrue,
   NegFlag<SetFalse, [CC1Option], "Disable generation of linker directives for automatic library linking">,
   PosFlag<SetTrue>>;
 
 // In the future this option will be supported by other offloading
 // languages and accept other values such as CPU/GPU architectures,

 def mconsole : Joined<["-"], "mconsole">, Group<m_Group>;
 def mwindows : Joined<["-"], "mwindows">, Group<m_Group>;
 def mdll : Joined<["-"], "mdll">, Group<m_Group>;
 def municode : Joined<["-"], "municode">, Group<m_Group>;
 def mthreads : Joined<["-"], "mthreads">, Group<m_Group>;
 def mguard_EQ : Joined<["-"], "mguard=">, Group<m_Group>,
   HelpText<"Enable or disable Control Flow Guard checks and guard tables emission">,
   Values<"none,cf,cf-nochecks">;
 def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>,
   HelpText<"For a list of available CPUs for the target use '-mcpu=help'">;
 def mmcu_EQ : Joined<["-"], "mmcu=">, Group<m_Group>;
 def msim : Flag<["-"], "msim">, Group<m_Group>;
 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>;
 def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>;
 def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>;
 def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>;
 def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;

clang/include/clang/Parse/Parser.h

public:
   ParseTypeName(SourceRange *Range = nullptr,
                 DeclaratorContext Context = DeclaratorContext::TypeName,
                 AccessSpecifier AS = AS_none, Decl **OwnedType = nullptr,
                 ParsedAttributes *Attrs = nullptr);
 
 private:
   void ParseBlockId(SourceLocation CaretLoc);
 
-  /// Are [[]] attributes enabled?
-  bool standardAttributesAllowed() const {
-    const LangOptions &LO = getLangOpts();
-    return LO.DoubleSquareBracketAttributes;
-  }
-
   /// Return true if the next token should be treated as a [[]] attribute,
   /// or as a keyword that behaves like one.  The former is only true if
   /// [[]] attributes are enabled, whereas the latter is true whenever
   /// such a keyword appears.  The arguments are as for
   /// isCXX11AttributeSpecifier.
   bool isAllowedCXX11AttributeSpecifier(bool Disambiguate = false,
                                         bool OuterMightBeMessageSend = false) {
     return (Tok.isRegularKeywordAttribute() ||
-            (standardAttributesAllowed() &&
-             isCXX11AttributeSpecifier(Disambiguate, OuterMightBeMessageSend)));
+            isCXX11AttributeSpecifier(Disambiguate, OuterMightBeMessageSend));
   }
 
   // Check for the start of an attribute-specifier-seq in a context where an
   // attribute is not allowed.
   bool CheckProhibitedCXX11Attribute() {
     assert(Tok.is(tok::l_square));
-    if (!standardAttributesAllowed() || NextToken().isNot(tok::l_square))
+    if (NextToken().isNot(tok::l_square))
       return false;
     return DiagnoseProhibitedCXX11Attribute();
   }
 
   bool DiagnoseProhibitedCXX11Attribute();
   void CheckMisplacedCXX11Attribute(ParsedAttributes &Attrs,
                                     SourceLocation CorrectLocation) {
-    if (!Tok.isRegularKeywordAttribute()) {
-      if (!standardAttributesAllowed())
-        return;
-      if ((Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square)) &&
-          Tok.isNot(tok::kw_alignas))
-        return;
-    }
+    if (!Tok.isRegularKeywordAttribute() &&
+        (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square)) &&
     DiagnoseMisplacedCXX11Attribute(Attrs, CorrectLocation);
   }
   void DiagnoseMisplacedCXX11Attribute(ParsedAttributes &Attrs,
                                        SourceLocation CorrectLocation);
 
   void stripTypeAttributesOffDeclSpec(ParsedAttributes &Attrs, DeclSpec &DS,
                                       Sema::TagUseKind TUK);
 

clang/lib/Basic/Attributes.cpp

if (ScopeName == "__gnu__")
     ScopeName = "gnu";
   else if (ScopeName == "_Clang")
     ScopeName = "clang";
 
   // As a special case, look for the omp::sequence and omp::directive
   // attributes. We support those, but not through the typical attribute
   // machinery that goes through TableGen. We support this in all OpenMP modes
   // so long as double square brackets are enabled.
-  if (LangOpts.OpenMP && LangOpts.DoubleSquareBracketAttributes &&
-      ScopeName == "omp")
+  if (LangOpts.OpenMP && ScopeName == "omp")
     return (Name == "directive" || Name == "sequence") ? 1 : 0;
 
   int res = hasAttributeImpl(Syntax, Name, ScopeName, Target, LangOpts);
   if (res)
     return res;
 
   // Check if any plugin provides this attribute.
   for (auto &Ptr : getAttributePluginInstances())

clang/lib/Lex/Lexer.cpp

if (Char == '=') {
       Kind = tok::pipe;
     }
     break;
   case ':':
     Char = getCharAndSize(CurPtr, SizeTmp);
     if (LangOpts.Digraphs && Char == '>') {
       Kind = tok::r_square; // ':>' -> ']'
       CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
-    } else if ((LangOpts.CPlusPlus ||
-                LangOpts.DoubleSquareBracketAttributes) &&
-               Char == ':') {
+    } else if (Char == ':') {
       Kind = tok::coloncolon;
       CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
     } else {
       Kind = tok::colon;
     }
     break;
   case ';':
     Kind = tok::semi;
if (!isLexingRawMode()) {
         return PP->HandleIdentifier(Result);
     }
     return true;
   }
   if (Result.isLiteral()) {
     Result.setLiteralData(TokPtr);
     return true;
   }
-  if (Result.is(tok::colon) &&
-      (LangOpts.CPlusPlus || LangOpts.DoubleSquareBracketAttributes)) {
+  if (Result.is(tok::colon)) {
     // Convert consecutive colons to 'tok::coloncolon'.
     if (*BufferPtr == ':') {
       assert(DepDirectives.front().Tokens[NextDepDirectiveTokenIndex].is(
           tok::colon));
       ++NextDepDirectiveTokenIndex;
       Result.setKind(tok::coloncolon);
     }
     return true;

clang/lib/Parse/ParseDeclCXX.cpp

if (Tok.isRegularKeywordAttribute()) {
     ConsumeToken();
     return;
   }
 
   assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square) &&
          "Not a double square bracket attribute list");
 
   SourceLocation OpenLoc = Tok.getLocation();
-  Diag(OpenLoc, diag::warn_cxx98_compat_attribute);
+  if (getLangOpts().CPlusPlus) {
+    Diag(OpenLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_attribute
+                                            : diag::warn_ext_cxx11_attributes);
+  } else {
+    Diag(OpenLoc, getLangOpts().C2x ? diag::warn_pre_c2x_compat_attributes
+                                    : diag::warn_ext_c2x_attributes);
+  }
 
   ConsumeBracket();
   checkCompoundToken(OpenLoc, tok::l_square, CompoundToken::AttrBegin);
   ConsumeBracket();
 
   SourceLocation CommonScopeLoc;
   IdentifierInfo *CommonScopeName = nullptr;
   if (Tok.is(tok::kw_using)) {
if (ExpectAndConsume(tok::r_square))
     SkipUntil(tok::r_square);
 }
 
 /// ParseCXX11Attributes - Parse a C++11 or C2x attribute-specifier-seq.
 ///
 /// attribute-specifier-seq:
 ///       attribute-specifier-seq[opt] attribute-specifier
 void Parser::ParseCXX11Attributes(ParsedAttributes &Attrs) {
-  assert(standardAttributesAllowed() || Tok.isRegularKeywordAttribute());
-
   SourceLocation StartLoc = Tok.getLocation();
   SourceLocation EndLoc = StartLoc;
 
   do {
     ParseCXX11AttributeSpecifier(Attrs, &EndLoc);
   } while (isAllowedCXX11AttributeSpecifier());
 
   Attrs.Range = SourceRange(StartLoc, EndLoc);

clang/test/AST/ast-dump-attr.m

 // Test without serialization:
-// RUN: %clang_cc1 -fdouble-square-bracket-attributes -triple x86_64-apple-macosx10.10.0 \
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.10.0 \
 // RUN: -ast-dump -ast-dump-filter Test %s \
 // RUN: | FileCheck --strict-whitespace %s
 //
 // Test with serialization:
-// RUN: %clang_cc1 -fdouble-square-bracket-attributes -triple x86_64-apple-macosx10.10.0 \
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.10.0 \
 // RUN: -emit-pch -o %t %s
-// RUN: %clang_cc1 -x objective-c -fdouble-square-bracket-attributes -triple x86_64-apple-macosx10.10.0 \
+// RUN: %clang_cc1 -x objective-c -triple x86_64-apple-macosx10.10.0 \
 // RUN: -include-pch %t -ast-dump-all -ast-dump-filter Test /dev/null \
 // RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
 // RUN: | FileCheck --strict-whitespace %s
 
 @interface NSObject
 @end
 
 [[clang::objc_exception]]

clang/test/AST/ast-dump-c-attr.c

 // Test without serialization:
-// RUN: %clang_cc1 -triple x86_64-pc-linux -fdouble-square-bracket-attributes \
+// RUN: %clang_cc1 -triple x86_64-pc-linux \
 // RUN: -Wno-deprecated-declarations -ast-dump -ast-dump-filter Test %s \
 // RUN: | FileCheck --strict-whitespace %s
 //
 // Test with serialization:
-// RUN: %clang_cc1 -triple x86_64-pc-linux -fdouble-square-bracket-attributes \
+// RUN: %clang_cc1 -triple x86_64-pc-linux \
 // RUN: -Wno-deprecated-declarations -emit-pch -o %t %s
-// RUN: %clang_cc1 -x c -triple x86_64-pc-linux -fdouble-square-bracket-attributes \
+// RUN: %clang_cc1 -x c -triple x86_64-pc-linux \
 // RUN: -Wno-deprecated-declarations -include-pch %t -ast-dump-all -ast-dump-filter Test /dev/null \
 // RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
 // RUN: | FileCheck --strict-whitespace %s
 
 int Test1 [[deprecated]];
 // CHECK:      VarDecl{{.*}}Test1
 // CHECK-NEXT:   DeprecatedAttr 0x{{[^ ]*}} <col:13> "" ""
 

clang/test/AST/attr-annotate-type.c

-// RUN: %clang_cc1 %s -ast-dump -fdouble-square-bracket-attributes | FileCheck %s
+// RUN: %clang_cc1 %s -ast-dump | FileCheck %s
 
 // Verify that we print the [[clang::annotate_type]] attribute.
 // FIXME: The arguments are currently not printed -- see also comments in
 // TypePrinter.cpp.
 
 // Need to escape the `[[` as a regex to avoid it being interpreted as a
 // substitution block.
 // CHECK: VarDecl {{.*}} x1 'int {{\[\[}}clang::annotate_type(...){{]]}}':'int'
 int [[clang::annotate_type("bar")]] x1;
 // CHECK: VarDecl {{.*}} x2 'int * {{\[\[}}clang::annotate_type(...){{]]}}':'int *'
 int *[[clang::annotate_type("bar")]] x2;

clang/test/CodeGen/attr-btf_type_tag-func.c

 // RUN: %clang_cc1 -triple %itanium_abi_triple -debug-info-kind=limited -S -emit-llvm -o - %s | FileCheck %s
-// RUN: %clang_cc1 -triple %itanium_abi_triple -DDOUBLE_BRACKET_ATTRS=1 -fdouble-square-bracket-attributes -debug-info-kind=limited -S -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -DDOUBLE_BRACKET_ATTRS=1 -debug-info-kind=limited -S -emit-llvm -o - %s | FileCheck %s
 
 #if DOUBLE_BRACKET_ATTRS
 #define __tag1 [[clang::btf_type_tag("tag1")]]
 #define __tag2 [[clang::btf_type_tag("tag2")]]
 #define __tag3 [[clang::btf_type_tag("tag3")]]
 #define __tag4 [[clang::btf_type_tag("tag4")]]
 #else
 #define __tag1 __attribute__((btf_type_tag("tag1")))

clang/test/CodeGen/attr-btf_type_tag-var.c

 // RUN: %clang_cc1 -triple %itanium_abi_triple -debug-info-kind=limited -S -emit-llvm -o - %s | FileCheck %s
-// RUN: %clang_cc1 -triple %itanium_abi_triple -DDOUBLE_BRACKET_ATTRS=1 -fdouble-square-bracket-attributes -debug-info-kind=limited -S -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -DDOUBLE_BRACKET_ATTRS=1 -debug-info-kind=limited -S -emit-llvm -o - %s | FileCheck %s
 
 #if DOUBLE_BRACKET_ATTRS
 #define __tag1 [[clang::btf_type_tag("tag1")]]
 #define __tag2 [[clang::btf_type_tag("tag2")]]
 #define __tag3 [[clang::btf_type_tag("tag3")]]
 #define __tag4 [[clang::btf_type_tag("tag4")]]
 #define __tag5 [[clang::btf_type_tag("tag5")]]
 #define __tag6 [[clang::btf_type_tag("tag6")]]

clang/test/Frontend/noderef.c

-// RUN: %clang_cc1 -Wno-unused-value -fdouble-square-bracket-attributes -verify %s
+// RUN: %clang_cc1 -Wno-unused-value -verify %s
 
 #define NODEREF __attribute__((noderef))
 
 struct S {
   int a;
   int b;
 };
 

clang/test/OpenMP/assumes_messages_attr.c

-// RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp -std=c99 -fms-extensions -fdouble-square-bracket-attributes -Wno-pragma-pack %s
-// RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp-simd -std=c99 -fms-extensions -fdouble-square-bracket-attributes -Wno-pragma-pack %s
+// RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp -std=c99 -fms-extensions -Wno-pragma-pack %s
+// RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp-simd -std=c99 -fms-extensions -Wno-pragma-pack %s
 
 [[omp::directive(assumes)]]; // expected-error {{expected at least one 'ext_', 'absent', 'contains', 'holds', 'no_openmp', 'no_openmp_routines', 'no_parallelism' clause for '#pragma omp assumes'}}
 [[omp::directive(begin)]]; // expected-error {{expected an OpenMP directive}}
 [[omp::directive(begin assumes)]]; // expected-error {{expected at least one 'ext_', 'absent', 'contains', 'holds', 'no_openmp', 'no_openmp_routines', 'no_parallelism' clause for '#pragma omp begin assumes'}}
 [[omp::directive(end assumes)]];
 
 [[omp::directive(assumes foobar)]]; // expected-warning {{valid assumes clauses start with 'ext_', 'absent', 'contains', 'holds', 'no_openmp', 'no_openmp_routines', 'no_parallelism'; token will be ignored}}
 [[omp::directive(begin assumes foobar)]]; // expected-warning {{valid begin assumes clauses start with 'ext_', 'absent', 'contains', 'holds', 'no_openmp', 'no_openmp_routines', 'no_parallelism'; token will be ignored}}

 [[omp::directive(assumes ext_123(not allowed))]]; // expected-warning {{'ext_123' clause should not be followed by arguments; tokens will be ignored}} expected-note {{the ignored tokens spans until here}}
 [[omp::directive(begin assumes ext_123(not allowed))]]; // expected-warning {{'ext_123' clause should not be followed by arguments; tokens will be ignored}} expected-note {{the ignored tokens spans until here}}
 [[omp::directive(end assumes)]];
 
 [[omp::directive(end assumes)]]; // expected-error {{'#pragma omp end assumes' with no matching '#pragma omp begin assumes'}}
 
 // TODO: we should emit a warning at least.
 [[omp::directive(begin assumes ext_abc)]];
 

clang/test/OpenMP/openmp_attribute_compat.cpp

 // RUN: %clang_cc1 -fopenmp -fsyntax-only -verify=pre -Wpre-openmp-51-compat %s
 // RUN: %clang_cc1 -fopenmp -fsyntax-only -verify=off %s
 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fsyntax-only -verify=ext -Wopenmp %s
 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fsyntax-only -verify=ext -Wopenmp-51-extensions %s
 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fsyntax-only -verify=ext -Wall %s
 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fsyntax-only -verify=ext %s
 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fsyntax-only -verify=off -Wno-openmp %s
 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fsyntax-only -verify=off -Wno-openmp-51-extensions %s
 
-// RUN: %clang_cc1 -fopenmp -fsyntax-only -verify=pre -Wpre-openmp-51-compat -x c -fdouble-square-bracket-attributes %s
-// RUN: %clang_cc1 -fopenmp -fsyntax-only -verify=off -x c -std=c2x %s
-// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fsyntax-only -verify=ext -Wopenmp -x c -std=c2x %s
+// RUN: %clang_cc1 -fopenmp -fsyntax-only -verify=pre -Wpre-openmp-51-compat -x c -std=c2x %s
+// RUN-: %clang_cc1 -fopenmp -fsyntax-only -verify=off -x c -std=c2x %s
+// RUN-: %clang_cc1 -fopenmp -fopenmp-version=50 -fsyntax-only -verify=ext -Wopenmp -x c -std=c2x %s
 
 // off-no-diagnostics
 
 int x;
 [[omp::directive(threadprivate(x))]]; // pre-warning {{specifying OpenMP directives with [[]] is incompatible with OpenMP standards before OpenMP 5.1}} \
                                       // ext-warning {{specifying OpenMP directives with [[]] is an OpenMP 5.1 extension}}
-

clang/test/Parser/asm.c

-// RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -verify %s
+// RUN: %clang_cc1 -fsyntax-only -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'}} 
 
   [[]] asm("");
   [[gnu::deprecated]] asm(""); // expected-warning {{'deprecated' attribute ignored}}
 }
 
 void a(void) __asm__(""); // expected-error {{cannot use an empty string literal in 'asm'}}
 void a(void) {
   __asm__(""); // ok

clang/test/Parser/c2x-attributes.c

-// RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -verify=expected,notc2x -Wno-strict-prototypes %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,notc2x -Wno-strict-prototypes %s
 // RUN: %clang_cc1 -fsyntax-only -std=gnu2x -verify=expected,c2x %s
 
 enum [[]] E {
   One [[]],
   Two,
   Three [[]]
 };
 

clang/test/Parser/c2x-attributes.m

-// RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s
 // expected-no-diagnostics
 
 enum __attribute__((deprecated)) E1 : int; // ok
 enum [[deprecated]] E2 : int;
 
 @interface Base
 @end
 

clang/test/Parser/cxx-decl.cpp

void test (DIE die, DIE *Die, DIE INT, DIE *FLOAT) {
   FLOAT->foo();
 }
 
 namespace PR15017 {
   template<typename T = struct X { int i; }> struct S {}; // expected-error {{'PR15017::X' cannot be defined in a type specifier}}
 }
 
 // Ensure we produce at least some diagnostic for attributes in C++98.
-[[]] struct S;
-#if __cplusplus <= 199711L
-// expected-error@-2 {{expected expression}}
-// expected-error@-3 {{expected unqualified-id}}
-#else
-// expected-error@-5 {{misplaced attributes}}
+[[]] struct S; // expected-error {{misplaced attributes}}
+#if __cplusplus < 201103L
+// expected-error@-2 {{[[]] attributes are a C++11 extension}}
 #endif
 
 namespace test7 {
   struct Foo {
     void a();
     void b();
   };
 

 // expected-error@-2 {{expected ';' after top level declarator}}
 #else
 // expected-error@-4 {{expected expression}}
 // expected-note@-5 {{to match this}}
 #endif
 
   int test6b;
 #if __cplusplus >= 201103L
 // expected-error@+3 {{expected}}
 // expected-error@-3 {{expected ';' after top level declarator}}
 #endif
 

clang/test/Parser/objc-attr.m

-// RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -triple x86_64-apple-macosx10.10.0 -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.10.0 -verify %s
 // expected-no-diagnostics
 
 @interface NSObject
 @end
 
 [[clang::objc_exception]]
 @interface Foo {
   [[clang::iboutlet]] NSObject *h;
 }
 @property (readonly) [[clang::objc_returns_inner_pointer]] void *i, *j;
 @property (readonly) [[clang::iboutlet]] NSObject *k;
 @end
 
 [[clang::objc_runtime_name("name")]] @protocol Bar;
 
 [[clang::objc_protocol_requires_explicit_implementation]] 
 @protocol Baz
 @end
 
 @interface Quux
 -(void)g1 [[clang::ns_consumes_self]];
 -(void)g2 __attribute__((ns_consumes_self));
 -(void)h1: (int)x [[clang::ns_consumes_self]];
 -(void)h2: (int)x __attribute__((ns_consumes_self));
 -(void) [[clang::ns_consumes_self]] i1;
 -(void) __attribute__((ns_consumes_self)) i2;
 @end

clang/test/ParserHLSL/group_shared.hlsl

 // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - -fsyntax-only %s -verify
 extern groupshared float f;
 extern float groupshared f; // Ok, redeclaration?
 
 
 // NOTE:lambda is not enabled except for hlsl202x.
 // expected-error@+2 {{expected expression}}
 // expected-warning@+1 {{'auto' type specifier is a C++11 extension}}
 auto l = []() groupshared  {};
 
-
-// NOTE: remove this error once [[]] attribute is supported except for hlsl202x.
-// expected-error@+1 {{expected expression}}
 float groupshared [[]] i = 12;
 
 float groupshared const i2 = 12;

clang/test/Preprocessor/has_c_attribute.c

-// RUN: %clang_cc1 -fdouble-square-bracket-attributes -std=c11 -E -P %s -o - | FileCheck %s
+// RUN: %clang_cc1 -std=c11 -E -P %s -o - | FileCheck %s
 // RUN: %clang_cc1 -std=c2x -E -P %s -o - | FileCheck %s
 
 #define C2x(x) x: __has_c_attribute(x)
 
 // CHECK: fallthrough: 201910L
 C2x(fallthrough)
 
 // CHECK: __nodiscard__: 202003L

clang/test/Sema/annotate-type.c

-// RUN: %clang_cc1 %s -fsyntax-only -fdouble-square-bracket-attributes -verify
+// RUN: %clang_cc1 %s -fsyntax-only -verify
 
 const char *some_function();
 
 void foo(float *[[clang::annotate_type("foo")]] a) {
   int [[clang::annotate_type("bar")]] x1;
   int *[[clang::annotate_type("bar")]] x2;
   int *[[clang::annotate_type("bar", 1)]] x3;
   int *[[clang::annotate_type("bar", 1 + 2)]] x4;

clang/test/Sema/annotate.c

-// RUN: %clang_cc1 %s -fsyntax-only -fdouble-square-bracket-attributes -verify
+// RUN: %clang_cc1 %s -fsyntax-only -verify
 
 void __attribute__((annotate("foo"))) foo(float *a) {
   __attribute__((annotate("bar"))) int x;
   [[clang::annotate("bar")]] int x2;
   __attribute__((annotate(1))) int y; // expected-error {{'annotate' attribute requires a string}}
   [[clang::annotate(1)]] int y2; // expected-error {{'annotate' attribute requires a string}}
   __attribute__((annotate("bar", 1))) int z;
   [[clang::annotate("bar", 1)]] int z2;

clang/test/Sema/attr-availability-square-brackets.c

-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -fsyntax-only -fdouble-square-bracket-attributes -verify %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -fsyntax-only -verify %s
 
 [[clang::availability(macosx,introduced=10.4,deprecated=10.2)]] void f0(void); // expected-warning{{feature cannot be deprecated in macOS version 10.2 before it was introduced in version 10.4; attribute ignored}}
 [[clang::availability(ios,obsoleted=2.1,deprecated=3.0)]] void f1(void);  // expected-warning{{feature cannot be obsoleted in iOS version 2.1 before it was deprecated in version 3.0; attribute ignored}}
 [[clang::availability(ios,introduced=2.1,deprecated=2.1)]] void f2(void);
 
 [[clang::availability(macosx,introduced=8.0,deprecated=9.0, message="use CTFontCopyFullName")]]
 extern void
 ATSFontGetName(const char *oName); // expected-note {{'ATSFontGetName' has been explicitly marked deprecated here}}

clang/test/Sema/attr-external-source-symbol-cxx.cpp

-// RUN: %clang_cc1 -fsyntax-only -fblocks -verify -fdouble-square-bracket-attributes %s
+// RUN: %clang_cc1 -fsyntax-only -fblocks -verify %s
 
 template<class T>
 class Class {
 public:
     [[clang::external_source_symbol(language="Swift", defined_in="module", USR="test", generated_declaration)]]
     void testExternalSourceSymbol();
 
     // expected-error@+1 {{expected string literal for USR in 'external_source_symbol' attribute}}
     [[clang::external_source_symbol(language="Swift", defined_in="module", USR=T, generated_declaration)]]
     void testExternalSourceSymbol2();
 };
 
 template<class T>
 void Class<T>::testExternalSourceSymbol() {
 }

clang/test/Sema/attr-external-source-symbol.c

-// RUN: %clang_cc1 -fsyntax-only -fblocks -verify -fdouble-square-bracket-attributes %s
+// RUN: %clang_cc1 -fsyntax-only -fblocks -verify %s
 
 void threeClauses(void) __attribute__((external_source_symbol(language="Swift", defined_in="module", generated_declaration)));
 
 void twoClauses(void) __attribute__((external_source_symbol(language="Swift", defined_in="module")));
 
 void fourClauses(void) __attribute__((external_source_symbol(language="Swift", defined_in="module", generated_declaration, USR="test")));
 
 void fiveClauses(void) __attribute__((external_source_symbol(language="Swift", defined_in="module", generated_declaration, generated_declaration, USR="test"))); // expected-error {{duplicate 'generated_declaration' clause in an 'external_source_symbol' attribute}}

clang/test/Sema/attr-likelihood.c

-// RUN: %clang_cc1 %s -fsyntax-only -fdouble-square-bracket-attributes -verify
+// RUN: %clang_cc1 %s -fsyntax-only -verify
 
 void g(void) {
   if (1)
     [[clang::likely]] {}
 }
 void m(void) {
   [[clang::likely]] int x = 42; // expected-error {{'likely' attribute cannot be applied to a declaration}}
 

clang/test/Sema/attr-objc-bridge-related.m

-// RUN: %clang_cc1 -verify -fsyntax-only -fdouble-square-bracket-attributes %s
+// RUN: %clang_cc1 -verify -fsyntax-only %s
 
 struct [[clang::objc_bridge_related(NSParagraphStyle,,)]] TestBridgedRef;
 
 struct [[clang::objc_bridge_related(NSColor,colorWithCGColor:,CGColor)]] CGColorRefOk;
 struct [[clang::objc_bridge_related(,colorWithCGColor:,CGColor)]] CGColorRef1NotOk; // expected-error {{expected a related ObjectiveC class name, e.g., 'NSColor'}}
 struct [[clang::objc_bridge_related(NSColor,colorWithCGColor::,CGColor)]] CGColorRef3NotOk; // expected-error {{expected a class method selector with single argument, e.g., 'colorWithCGColor:'}}

clang/test/Sema/attr-regparm.c

-// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -fdouble-square-bracket-attributes -verify %s
+// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s
 
 __attribute((regparm(2))) int x0(void);
 __attribute((regparm(1.0))) int x1(void); // expected-error{{'regparm' attribute requires an integer constant}}
 __attribute((regparm(-1))) int x2(void); // expected-error{{'regparm' parameter must be between 0 and 3 inclusive}}
 __attribute((regparm(5))) int x3(void); // expected-error{{'regparm' parameter must be between 0 and 3 inclusive}}
 __attribute((regparm(5,3))) int x4(void); // expected-error{{'regparm' attribute takes one argument}}
 
 void __attribute__((regparm(3))) x5(int);
 void x5(int); // expected-note{{previous declaration is here}}
 void __attribute__((regparm(2))) x5(int); // expected-error{{function declared with regparm(2) attribute was previously declared with the regparm(3) attribute}}
 
 [[gnu::regparm(3)]] void x6(int); // expected-note{{previous declaration is here}}
 [[gnu::regparm(2)]] void x6(int); // expected-error{{function declared with regparm(2) attribute was previously declared with the regparm(3) attribute}}
 void x6 [[gnu::regparm(3)]] (int);
 void [[gnu::regparm(3)]] x6(int); // expected-warning{{'regparm' only applies to function types; type here is 'void'}}
 void x6(int) [[gnu::regparm(3)]]; // expected-warning{{GCC does not allow the 'regparm' attribute to be written on a type}}

clang/test/Sema/attr-type-safety.c

-// RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct A {};
 
 typedef struct A *MPI_Datatype;
 
 extern struct A datatype_wrong1 [[clang::type_tag_for_datatype]]; // expected-error {{'type_tag_for_datatype' attribute requires parameter 1 to be an identifier}}
 
 extern struct A datatype_wrong2 [[clang::type_tag_for_datatype(mpi,1,2)]]; // expected-error {{expected a type}}

 [[clang::pointer_with_type_tag(mpi,1,3)]] // expected-error {{attribute parameter 3 is out of bounds}}
 int wrong5(void *buf, MPI_Datatype datatype);
 
 [[clang::pointer_with_type_tag(mpi,0x8000000000000001ULL,1)]] // expected-error {{attribute parameter 2 is out of bounds}}
 int wrong6(void *buf, MPI_Datatype datatype);
 
 [[clang::pointer_with_type_tag(a,1,2)]] void A_func(void *ptr, void *tag);
 [[clang::pointer_with_type_tag(c,1,2)]] void C_func(void *ptr, int tag);
 

clang/test/Sema/c2x-attr.c

+// RUN: %clang_cc1 -fsyntax-only -std=c2x -Wpre-c2x-compat -verify=pre-c2x %s
+// RUN: %clang_cc1 -fsyntax-only -std=c17 -Wc2x-extensions -verify=c2x-ext %s
+
+[[]] void func(); // pre-c2x-warning {{[[]] attributes are incompatible with C standards before C2x}}
+                  // c2x-ext-warning@-1 {{[[]] attributes are a C2x extension}}

clang/test/Sema/c2x-noreturn.c

 // RUN: %clang_cc1 -verify=all,c2x -std=c2x -fsyntax-only %s
-// RUN: %clang_cc1 -verify=all -std=c17 -fdouble-square-bracket-attributes -fsyntax-only %s
+// RUN: %clang_cc1 -verify=all -std=c17 -fsyntax-only %s
 // RUN: %clang_cc1 -verify=none -Wno-deprecated-attributes -D_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS -std=c2x -fsyntax-only %s
-// RUN: %clang_cc1 -verify=none -Wno-deprecated-attributes -D_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS -std=c17 -fdouble-square-bracket-attributes -fsyntax-only %s
+// RUN: %clang_cc1 -verify=none -Wno-deprecated-attributes -D_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS -std=c17 -fsyntax-only %s
 // none-no-diagnostics
 
 // Test preprocessor functionality.
 #if !__has_c_attribute(noreturn)
 #error "No noreturn attribute support?"
 #endif
 
 #if !__has_c_attribute(_Noreturn)

clang/test/Sema/internal_linkage.c

-// RUN: %clang_cc1 -fsyntax-only -verify -fdouble-square-bracket-attributes %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s
 
 int var __attribute__((internal_linkage));
 int var2 __attribute__((internal_linkage,common)); // expected-error{{'common' and 'internal_linkage' attributes are not compatible}} \
                                                    // expected-note{{conflicting attribute is here}}
 int var3 __attribute__((common,internal_linkage)); // expected-error{{'internal_linkage' and 'common' attributes are not compatible}} \
                                                    // expected-note{{conflicting attribute is here}}
 
 int var4 __attribute__((common)); // expected-note{{previous declaration is here}} expected-note{{conflicting attribute is here}}

clang/test/Sema/matrix-type-builtins.c

-// RUN: %clang_cc1 %s -fenable-matrix -fdouble-square-bracket-attributes -pedantic -verify -triple=x86_64-apple-darwin9
+// RUN: %clang_cc1 %s -fenable-matrix -pedantic -verify -triple=x86_64-apple-darwin9
 
 typedef float sx5x10_t __attribute__((matrix_type(5, 10)));
 typedef int ix3x2_t __attribute__((matrix_type(3, 2)));
 typedef double dx3x3 __attribute__((matrix_type(3, 3)));
 typedef unsigned ix3x3 __attribute__((matrix_type(3, 3)));
 
 // Verify that we can use the [[]] spelling of the attribute.
 // We intentionally use the same type alias name to check that both versions
 // define the same type.
-typedef float [[clang::matrix_type(5, 10)]] sx5x10_t;
-typedef int [[clang::matrix_type(3, 2)]] ix3x2_t;
-[[clang::matrix_type(5, 10)]] typedef float sx5x10_t;
+typedef float [[clang::matrix_type(5, 10)]] sx5x10_t; // expected-warning {{[[]] attributes are a C2x extension}}
+typedef int [[clang::matrix_type(3, 2)]] ix3x2_t; // expected-warning {{[[]] attributes are a C2x extension}}
+[[clang::matrix_type(5, 10)]] typedef float sx5x10_t; // expected-warning {{[[]] attributes are a C2x extension}}
 // expected-warning@-1 {{applying attribute 'matrix_type' to a declaration is deprecated; apply it to the type instead}}
-[[clang::matrix_type(3, 2)]] typedef int ix3x2_t;
+[[clang::matrix_type(3, 2)]] typedef int ix3x2_t; // expected-warning {{[[]] attributes are a C2x extension}}
 // expected-warning@-1 {{applying attribute 'matrix_type' to a declaration is deprecated; apply it to the type instead}}
 
 // Attribute may not be used outside typedefs.
-[[clang::matrix_type(3, 2)]] int ix3x2_var;
+[[clang::matrix_type(3, 2)]] int ix3x2_var; // expected-warning {{[[]] attributes are a C2x extension}}
 // expected-error@-1 {{'matrix_type' attribute only applies to typedefs}}
-int [[clang::matrix_type(3, 2)]] ix3x2_var;
+int [[clang::matrix_type(3, 2)]] ix3x2_var; // expected-warning {{[[]] attributes are a C2x extension}}
 // expected-error@-1 {{'matrix_type' attribute only applies to typedefs}}
 
 void transpose(sx5x10_t a, ix3x2_t b, dx3x3 c, int *d, int e) {
   a = __builtin_matrix_transpose(b);
   // expected-error@-1 {{assigning to 'sx5x10_t' (aka 'float __attribute__((matrix_type(5, 10)))') from incompatible type 'int __attribute__((matrix_type(2, 3)))'}}
   b = __builtin_matrix_transpose(b);
   // expected-error@-1 {{assigning to 'ix3x2_t' (aka 'int __attribute__((matrix_type(3, 2)))') from incompatible type 'int __attribute__((matrix_type(2, 3)))'}}
   __builtin_matrix_transpose(d);

clang/test/Sema/neon-vector-types.c

-// RUN: %clang_cc1 %s -triple armv7 -target-feature +neon -fsyntax-only -fdouble-square-bracket-attributes -verify
-// RUN: %clang_cc1 %s -triple armv8 -target-feature +neon -fsyntax-only -fdouble-square-bracket-attributes -verify
+// RUN: %clang_cc1 %s -triple armv7 -target-feature +neon -fsyntax-only -verify
+// RUN: %clang_cc1 %s -triple armv8 -target-feature +neon -fsyntax-only -verify
 
 typedef float float32_t;
 typedef signed char poly8_t;
 typedef short poly16_t;
 typedef unsigned __INT64_TYPE__ uint64_t;
 
 // Define some valid Neon types.
 typedef __attribute__((neon_vector_type(2))) int int32x2_t;

clang/test/Sema/overload-arm-mve.c

-// RUN: %clang_cc1 -triple thumbv8.1m.main-none-none-eabi -target-feature +mve.fp -flax-vector-conversions=all -fdouble-square-bracket-attributes -Werror -emit-llvm -o - %s | FileCheck %s
-// RUN: %clang_cc1 -triple thumbv8.1m.main-none-none-eabi -target-feature +mve.fp -flax-vector-conversions=all -fdouble-square-bracket-attributes -verify -fsyntax-only -DERROR_CHECK %s
+// RUN: %clang_cc1 -triple thumbv8.1m.main-none-none-eabi -target-feature +mve.fp -flax-vector-conversions=all -Werror -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple thumbv8.1m.main-none-none-eabi -target-feature +mve.fp -flax-vector-conversions=all -verify -fsyntax-only -DERROR_CHECK %s
 
 typedef   signed short      int16_t;
 typedef   signed int        int32_t;
 typedef   signed long long  int64_t;
 typedef unsigned short     uint16_t;
 typedef unsigned int       uint32_t;
 typedef unsigned long long uint64_t;
 

clang/test/Sema/overloadable.c

-// RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -verify %s -Wincompatible-pointer-types -Wno-strict-prototypes
+// RUN: %clang_cc1 -fsyntax-only -verify %s -Wincompatible-pointer-types -Wno-strict-prototypes
 
 int var __attribute__((overloadable)); // expected-error{{'overloadable' attribute only applies to functions}}
 void bad_attr_target(int) [[clang::overloadable]]; // expected-error{{'overloadable' attribute cannot be applied to types}}
 void params(void) __attribute__((overloadable(12))); // expected-error {{'overloadable' attribute takes no arguments}}
 
 int *f(int) __attribute__((overloadable)); // expected-note{{previous overload of function is here}}
 float *f(float);
 int *f(int); // expected-error{{redeclaration of 'f' must have the 'overloadable' attribute}} \

 typedef int f1_type();
 f1_type __attribute__((overloadable)) f1; // expected-error{{'overloadable' function 'f1' must have a prototype}}
 
 void test() {
   f0();
   f1();
 }
 
 // Validate that the invalid function doesn't stay overloadable. 
 int __attribute__((overloadable)) invalid(); // expected-error{{'overloadable' function 'invalid' must have a prototype}}
 int __attribute__((overloadable)) invalid(int); // expected-error{{redeclaration of 'invalid' must not have the 'overloadable' attribute}}
                                                 // expected-note@-2{{previous unmarked overload of function is here}}
 void use_invalid(void) {
   invalid(); // expected-error{{too few arguments to function call, expected 1, have 0}}
              // expected-note@-4{{'invalid' declared here}}
   invalid(1);
 }

clang/test/Sema/vector-gcc-compat.c

-// RUN: %clang_cc1 %s -verify -fsyntax-only -fdouble-square-bracket-attributes -Weverything -Wno-unused-but-set-variable -triple x86_64-apple-darwin10
+// RUN: %clang_cc1 %s -verify -fsyntax-only -Weverything -Wno-unused-but-set-variable -triple x86_64-apple-darwin10
 
 // Test the compatibility of clang's vector extensions with gcc's vector
 // extensions for C. Notably &&, ||, ?: and ! are not available.
 typedef long long v2i64 __attribute__((vector_size(16)));
 typedef int v2i32 __attribute__((vector_size(8)));
 typedef short v2i16 __attribute__((vector_size(4)));
 typedef char v2i8 __attribute__((vector_size(2)));
 
 typedef unsigned long long v2u64 __attribute__((vector_size(16)));
 typedef unsigned int v2u32 __attribute__((vector_size(8)));
 typedef unsigned short v2u16 __attribute__((vector_size(4)));
 typedef unsigned char v2u8 __attribute__((vector_size(2)));
 
 typedef float v4f32 __attribute__((vector_size(16)));
 typedef double v2f64 __attribute__((vector_size(16)));
 typedef double v4f64 __attribute__((vector_size(32)));
 typedef int v4i32 __attribute((vector_size(16)));
 
 // Verify that we can use the [[]] spelling of the attribute.
 // We intentionally use the same type alias name to check that both versions
 // define the same type.
-// FIXME: Warnings are nuisance warnings due to the `-Weverything` flag, but
-// we shouldn't really be emitting them in C mode with the
-// `-fdouble-square-bracket-attributes` flag.
-typedef long long v2i64 [[gnu::vector_size(16)]]; // expected-warning{{C++11 attribute syntax is incompatible with C++98}}
-typedef int v2i32 [[gnu::vector_size(8)]]; // expected-warning{{C++11 attribute syntax is incompatible with C++98}}
+typedef long long v2i64 [[gnu::vector_size(16)]]; // expected-warning{{[[]] attributes are a C2x extension}}
+typedef int v2i32 [[gnu::vector_size(8)]]; // expected-warning{{[[]] attributes are a C2x extension}}
 
 // Check various positions where the [[]] spelling can or cannot be used.
-[[gnu::vector_size(16)]] typedef long long v2i64; // expected-warning{{C++11 attribute syntax is incompatible with C++98}}
+[[gnu::vector_size(16)]] typedef long long v2i64; // expected-warning{{[[]] attributes are a C2x extension}}
 typedef long long [[gnu::vector_size(16)]] v2i64_ignored;
   // expected-warning@-1{{'vector_size' attribute ignored}}
-  // expected-warning@-2{{C++11 attribute syntax is incompatible with C++98}}
+  // expected-warning@-2{{[[]] attributes are a C2x extension}}
 // FIXME: Contrary to the error message that we emit, GCC does actually allow
 // the attribute in the following position. Somewhat surprisingly, the attribute
 // is applied not to the pointer but to the base type, i.e. this declaration has
 // the same effect in GCC as the other declarations for `v2i64`.
 typedef long long *[[gnu::vector_size(16)]] v2i64_doesnt_work;
   // expected-error@-1{{invalid vector element type 'long long *'}}
   // expected-warning@-2{{GCC does not allow the 'vector_size' attribute to be written on a type}}
-  // expected-warning@-3{{C++11 attribute syntax is incompatible with C++98}}
+  // expected-warning@-3{{[[]] attributes are a C2x extension}}
 
 // Verify that we can use the attribute outside of a typedef.
-static int v2i32_var [[gnu::vector_size(8)]]; // expected-warning{{C++11 attribute syntax is incompatible with C++98}}
+static int v2i32_var [[gnu::vector_size(8)]]; // expected-warning{{[[]] attributes are a C2x extension}}
 
 void arithmeticTest(void);
 void logicTest(void);
 void comparisonTest(void);
 void floatTestSignedType(char a, short b, int c, long long d);
 void floatTestUnsignedType(unsigned char a, unsigned short b, unsigned int c,
                            unsigned long long d);
 void floatTestConstant(void);

clang/test/SemaCXX/attr-cxx-disabled.cpp

-// RUN: %clang_cc1 -fsyntax-only -fno-double-square-bracket-attributes -verify -pedantic -std=c++11 -DERRORS %s
-// RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -verify -pedantic -std=c++11 %s
-
-struct [[]] S {};
-
-#ifdef ERRORS
-// expected-error@-3 {{declaration of anonymous struct must be a definition}}
-// expected-warning@-4 {{declaration does not declare anything}}
-#else
-// expected-no-diagnostics
-#endif
-

clang/test/SemaCXX/cxx98-compat.cpp

 
 template<template<typename> class ...T>  // expected-warning {{variadic templates are incompatible with C++98}}
 class Variadic2 {};
 
 template<int ...I>  // expected-warning {{variadic templates are incompatible with C++98}}
 class Variadic3 {};
 
 alignas(8) int with_alignas; // expected-warning {{'alignas' is incompatible with C++98}}
-int with_attribute [[ ]]; // expected-warning {{C++11 attribute syntax is incompatible with C++98}}
+int with_attribute [[ ]]; // expected-warning {{[[]] attributes are incompatible with C++ standards before C++11}}
 
 void Literals() {
   (void)u8"str"; // expected-warning {{unicode literals are incompatible with C++98}}
   (void)u"str"; // expected-warning {{unicode literals are incompatible with C++98}}
   (void)U"str"; // expected-warning {{unicode literals are incompatible with C++98}}
   (void)u'x'; // expected-warning {{unicode literals are incompatible with C++98}}
   (void)U'x'; // expected-warning {{unicode literals are incompatible with C++98}}
 

 
 int &&RvalueReference = 0; // expected-warning {{rvalue references are incompatible with C++98}}
 struct RefQualifier {
   void f() &; // expected-warning {{reference qualifiers on functions are incompatible with C++98}}
 };
 
 auto f() -> int; // expected-warning {{trailing return types are incompatible with C++98}}
 #ifdef CXX14COMPAT
-auto ff() { return 5; } // expected-warning {{'auto' type specifier is incompatible with C++98}} 
+auto ff() { return 5; } // expected-warning {{'auto' type specifier is incompatible with C++98}}
 // expected-warning@-1 {{return type deduction is incompatible with C++ standards before C++14}}
 #endif
 
 void RangeFor() {
   int xs[] = {1, 2, 3};
   for (int &a : xs) { // expected-warning {{range-based for loop is incompatible with C++98}}
   }
   for (auto &b : {1, 2, 3}) {

clang/test/SemaCXX/warn-c++11-extensions.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wc++11-extensions -verify %s
 
 long long ll1 = // expected-warning {{'long long' is a C++11 extension}}
          -42LL; // expected-warning {{'long long' is a C++11 extension}}
 unsigned long long ull1 = // expected-warning {{'long long' is a C++11 extension}}
                    42ULL; // expected-warning {{'long long' is a C++11 extension}}
 
 enum struct E1 { A, B }; // expected-warning {{scoped enumerations are a C++11 extension}}
 enum class E2 { C, D }; // expected-warning {{scoped enumerations are a C++11 extension}}
+
+[[]] void func(); // expected-warning {{[[]] attributes are a C++11 extension}}

clang/test/SemaObjC/attr-objc-gc.m

-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -fdouble-square-bracket-attributes -verify %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s
 static id __attribute((objc_gc(weak))) a;
 static id __attribute((objc_gc(strong))) b;
 
 static id __attribute((objc_gc())) c; // expected-error{{'objc_gc' attribute requires a string}}
 static id __attribute((objc_gc(123))) d; // expected-error{{'objc_gc' attribute requires a string}}
 static id __attribute((objc_gc(foo, 456))) e; // expected-error{{'objc_gc' attribute takes one argument}}
 static id __attribute((objc_gc(hello))) f; // expected-warning{{'objc_gc' attribute argument not supported: 'hello'}}
 

clang/unittests/AST/AttrTest.cpp

)cpp");
     AssertAnnotatedAs(MemberPointerTL.getPointeeLoc(), "int", IntTL);
     EXPECT_EQ(IntTL.getType(), AST->getASTContext().IntTy);
   }
 
   // Test type annotation on an `__auto_type` type in C mode.
   AST = buildASTFromCodeWithArgs(R"c(
     __auto_type [[clang::annotate_type("auto")]] auto_var = 1;
   )c",
-                                 {"-fdouble-square-bracket-attributes"},
+                                 {},
                                  "input.c");
 
   {
     const VarDecl *Var = getVariableNode(AST.get(), "auto_var");
 
     AutoTypeLoc AutoTL;
     AssertAnnotatedAs(Var->getTypeSourceInfo()->getTypeLoc(), "auto", AutoTL);
   }

clang/utils/TableGen/ClangAttrEmitter.cpp

for (const auto *Attr : Attrs) {
     if (Attr->isSubClassOf("TargetSpecificAttr")) {
       const Record *R = Attr->getValueAsDef("Target");
       std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
       GenerateTargetSpecificAttrChecks(R, Arches, Test, nullptr);
 
       // If this is the C++11 variety, also add in the LangOpts test.
       if (Variety == "CXX11")
         Test += " && LangOpts.CPlusPlus11";
-      else if (Variety == "C2x")
-        Test += " && LangOpts.DoubleSquareBracketAttributes";
     } else if (Variety == "CXX11")
       // C++11 mode should be checked against LangOpts, which is presumed to be
       // present in the caller.
       Test = "LangOpts.CPlusPlus11";
-    else if (Variety == "C2x")
-      Test = "LangOpts.DoubleSquareBracketAttributes";
 
     std::string TestStr = !Test.empty()
                               ? Test + " ? " + llvm::itostr(Version) + " : 0"
                               : llvm::itostr(Version);
     for (const auto &S : Spellings)
       if (Variety.empty() || (Variety == S.variety() &&
                               (Scope.empty() || Scope == S.nameSpace())))
         OS << "    .Case(\"" << S.name() << "\", " << TestStr << ")\n";

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

if (clang_expr && clang_expr->DidImportCxxModules()) {
     // We use the @import statements, so we need this:
     // FIXME: We could use the modules-ts, but that currently doesn't work.
     lang_opts.ObjC = true;
 
     // Options we need to parse libc++ code successfully.
     // FIXME: We should ask the driver for the appropriate default flags.
     lang_opts.GNUMode = true;
     lang_opts.GNUKeywords = true;
-    lang_opts.DoubleSquareBracketAttributes = true;
     lang_opts.CPlusPlus11 = true;
 
     // The Darwin libc expects this macro to be set.
     lang_opts.GNUCVersion = 40201;
 
     SetupModuleHeaderPaths(m_compiler.get(), m_include_directories,
                            target_sp);
   }