Add diagnostic groups for attribute extensions

[aaron.ballman]

Summary

Some users have a need to control attribute extension diagnostics independent of other extension diagnostics. Consider something like use of [[nodiscard]] within C++11:

#if __has_cpp_attribute(nodiscard)
[[nodiscard]] 
#endif
int f();

If compiled with -Wc++17-extensions enabled, this will produce warning: use of the 'nodiscard' attribute is a C++17 extension. This diagnostic is correct -- using [[nodiscard]] in C++11 mode is a C++17 extension. And the behavior of __has_cpp_attribute(nodiscard) is also correct -- we support [[nodiscard]] in C++11 mode as a conforming extension. But this makes use of -Werror or -pedantic-errors` builds more onerous.

This patch adds diagnostic groups for attribute extensions so that users can selectively disable attribute extension diagnostics. I believe this is preferable to requiring users to specify additional flags because it means -Wc++17-extensions continues to be the way we enable all C++17-related extension diagnostics. It would be quite easy for someone to use that flag thinking they're protected from some portability issues without realizing it skipped attribute extensions if we went the other way.

This addresses PR33518.

[erichkeane]

I like the approach, and a pretty trivial implementation.

[aaron.ballman]

In D113115#3106360, @erichkeane wrote:

I like the approach, and a pretty trivial implementation.

Thanks for the review! I'm going to hold off on landing for a little bit in case @rsmith has opinions because he had other ideas on the bug report itself.

[aaron.ballman]

I've committed (with a release note) in a18632adc884397e0cd7f27bdb8ea3a822b63000

clang/include/clang/Basic/DiagnosticGroups.td

 def : DiagGroup<"unused-local-typedefs", [UnusedLocalTypedef]>;
                 // -Wunused-local-typedefs = -Wunused-local-typedef
 
 // A warning group for warnings that we want to have on by default in clang,
 // but which aren't on by default in GCC.
 def NonGCC : DiagGroup<"non-gcc",
     [SignCompare, Conversion, LiteralRange]>;
 
+def CXX14Attrs : DiagGroup<"c++14-attribute-extensions">;
+def CXX17Attrs : DiagGroup<"c++17-attribute-extensions">;
+def CXX20Attrs : DiagGroup<"c++20-attribute-extensions">;
+def FutureAttrs : DiagGroup<"future-attribute-extensions", [CXX14Attrs,
+                                                            CXX17Attrs,
+                                                            CXX20Attrs]>;
+
 // A warning group for warnings about using C++11 features as extensions in
 // earlier C++ versions.
 def CXX11 : DiagGroup<"c++11-extensions", [CXX11ExtraSemi, CXX11InlineNamespace,
                                            CXX11LongLong]>;
 
 // A warning group for warnings about using C++14 features as extensions in
 // earlier C++ versions.
-def CXX14 : DiagGroup<"c++14-extensions", [CXX14BinaryLiteral]>;
+def CXX14 : DiagGroup<"c++14-extensions", [CXX14BinaryLiteral, CXX14Attrs]>;
 
 // A warning group for warnings about using C++17 features as extensions in
 // earlier C++ versions.
-def CXX17 : DiagGroup<"c++17-extensions">;
+def CXX17 : DiagGroup<"c++17-extensions", [CXX17Attrs]>;
 
 // A warning group for warnings about using C++20 features as extensions in
 // earlier C++ versions.
-def CXX20 : DiagGroup<"c++20-extensions", [CXX20Designator]>;
+def CXX20 : DiagGroup<"c++20-extensions", [CXX20Designator, CXX20Attrs]>;
 
 // A warning group for warnings about using C++2b features as extensions in
 // earlier C++ versions.
 def CXX2b : DiagGroup<"c++2b-extensions">;
 
 def : DiagGroup<"c++0x-extensions", [CXX11]>;
 def : DiagGroup<"c++1y-extensions", [CXX14]>;
 def : DiagGroup<"c++1z-extensions", [CXX17]>;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def warn_unused_result_msg : Warning<
   "ignoring return value of function declared with %0 attribute: %1">,
   InGroup<UnusedResult>;
 def warn_unused_volatile : Warning<
   "expression result unused; assign into a variable to force a volatile load">,
   InGroup<DiagGroup<"unused-volatile-lvalue">>;
 
 def ext_cxx14_attr : Extension<
-  "use of the %0 attribute is a C++14 extension">, InGroup<CXX14>;
+  "use of the %0 attribute is a C++14 extension">, InGroup<CXX14Attrs>;
 def ext_cxx17_attr : Extension<
-  "use of the %0 attribute is a C++17 extension">, InGroup<CXX17>;
+  "use of the %0 attribute is a C++17 extension">, InGroup<CXX17Attrs>;
 def ext_cxx20_attr : Extension<
-  "use of the %0 attribute is a C++20 extension">, InGroup<CXX20>;
+  "use of the %0 attribute is a C++20 extension">, InGroup<CXX20Attrs>;
 
 def warn_unused_comparison : Warning<
   "%select{equality|inequality|relational|three-way}0 comparison result unused">,
   InGroup<UnusedComparison>;
 def note_inequality_comparison_to_or_assign : Note<
   "use '|=' to turn this inequality comparison into an or-assignment">;
 
 def err_incomplete_type_used_in_type_trait_expr : Error<

clang/test/SemaCXX/attr-extension-diags.cpp

+// RUN: %clang_cc1 -std=c++11 -verify=ext -fsyntax-only -Wfuture-attribute-extensions %s
+// RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-future-attribute-extensions %s
+// RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++14-attribute-extensions -Wno-c++17-attribute-extensions -Wno-c++20-attribute-extensions %s
+
+// expected-no-diagnostics
+
+[[deprecated]] int func1(); // ext-warning {{use of the 'deprecated' attribute is a C++14 extension}}
+[[deprecated("msg")]] int func2(); // ext-warning {{use of the 'deprecated' attribute is a C++14 extension}}
+
+[[nodiscard]] int func3(); // ext-warning {{use of the 'nodiscard' attribute is a C++17 extension}}
+[[nodiscard("msg")]] int func4(); // ext-warning {{use of the 'nodiscard' attribute is a C++20 extension}}
+
+void func5() {
+  if (true) [[likely]]; // ext-warning {{use of the 'likely' attribute is a C++20 extension}}  
+}