[C2x] Implement WG14 N2764 the [[noreturn]] attribute

[aaron.ballman]

Summary

This adds support for http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2764.pdf, which was adopted at the Feb 2022 WG14 meeting. That paper adds [[noreturn]] and [[_Noreturn]] to the list of supported attributes in C2x. These attributes have the same semantics as the [[noreturn]] attribute in C++.

The [[_Noreturn]] attribute was added as a deprecated feature so that translation units which include <stdnoreturn.h> do not get an error on use of [[noreturn]] because the macro expands to _Noreturn. Users can use -Wno-deprecated-attributes to silence the diagnostic.

Use of <stdnotreturn.h> or the noreturn macro were both deprecated. Users can define the _CLANG_DISABLE_CRT_DEPRECATION_WARNINGS macro to suppress the deprecation diagnostics coming from the header file.

[aaron.ballman]

Thanks for the quick review. I've landed in 5029dce492b3cf3ac191eda0b5bf268c3acac2e0, but if anyone has post commit review comments (I landed this pretty quickly after initial review), I'm happy to address them.

[jyknight]

clang/lib/Headers/stdnoreturn.h

19

Is this actually useful? Isn't it sufficient to have the include-time warning for this header?

22

Would be nice to mention the solution, as well. E.g.

"The '<stdnoreturn.h>' header has been deprecated in C2x: including it no longer necessary in order to use 'noreturn'. "

clang/test/Sema/c2x-noreturn.c

41–43

If you've written [[noreturn]] in your code, you're doing the right thing already. Why bother emitting a warning? The problem that should be corrected is at the point of inclusion of stdnoreturn.h, not the spelling here.

I'd suggest only warning about "[[_Noreturn]]" if the user actually wrote it like that, and not when it's expanded from the "noreturn" macro.

[aaron.ballman]

clang/lib/Headers/stdnoreturn.h

19

I think it gives a more precise diagnostic than the header inclusion one, and it will diagnose closer to where the use happens instead of at the include. Might not be the most useful, but it I think there's some utility.

22

I can add that, but it is necessary in order to use 'noreturn' as a function specifier, so that wording isn't quite right. e.g., noreturn void func(void); is valid C today if you #include <stdnoreturn.h>

clang/test/Sema/c2x-noreturn.c

41–43

I'd suggest only warning about "[[_Noreturn]]" if the user actually wrote it like that, and not when it's expanded from the "noreturn" macro.

I'm not keen on that design. The goal of this diagnostic is to let people know that they have a surprise in their code (that this macro is expanding to something they may not expect) at the location the surprise happens. Consider:

// TU.c
#include <stdnoreturn.h>
#include "my_header.h"

// my_header.h
[[noreturn]] void func(void);

my_header.h doesn't see the inclusion of stdnoreturn.h, so finding out about the macro may inform the developer to be more protective of using the attribute.

[jyknight]

clang/lib/Headers/stdnoreturn.h

22

Ah, I missed that subtlety. Maybe say:

"The '<stdnoreturn.h>' header has been deprecated in C2x; either use the _Noreturn keyword or the [[noreturn]] attribute."

clang/test/Sema/c2x-noreturn.c

41–43

But that's exactly my point. There _is_ no surprise in this code. It works exactly as expected.
The my_header.h code is using the new non-deprecated spelling, and is getting the correct and desired behavior -- even though someone else has included stdnoreturn.h. That it's working properly due to there existing a compatibility attribute "_Noreturn" is basically an irrelevant detail to any user.

Emitting any warnings for this line of code seems potentially even harmful. Consider: what should my_header.h be doing differently due to the warning? Nothing. Ideally, they should change nothing. Yet, if we do emit warnings for this usage, it'll likely cause some people to try to add push/undef/pop gunk to their headers to avoid the warning, which makes the code worse than if they did nothing.

[aaron.ballman]

clang/lib/Headers/stdnoreturn.h

19

Okay, I've convinced myself to remove this a well for the same reason we don't want to warn on [[noreturn]] which expands to [[_Noreturn]] -- the issue isn't with use of the attribute, it's with use of the header file. I don't want to risk a user writing [[noreturn]] and hearing that the noreturn macro is deprecated and they think that means that [[noreturn]] is deprecated.

22

Sure, I can go with that.

clang/test/Sema/c2x-noreturn.c

41–43

Okay, thank you for sticking with me, that logic makes sense to me. I'll remove the diagnostic in this case.

[aaron.ballman]

I've made the requested changes from @jyknight in a766545402d8569532294d097d026cf2e837b5c2 -- please let me know if there are more issues you'd like me to address. Thank you for the post-commit feedback!

clang/docs/ReleaseNotes.rst

- Add support for MSVC-compatible ``/JMC``/``/JMC-`` flag in clang-cl (supports
   X86/X64/ARM/ARM64). ``/JMC`` could only be used when ``/Zi`` or ``/Z7`` is
   turned on. With this addition, clang-cl can be used in Visual Studio for the
   JustMyCode feature. Note, you may need to manually add ``/JMC`` as additional
   compile options in the Visual Studio since it currently assumes clang-cl does not support ``/JMC``.
 
 C Language Changes in Clang
 ---------------------------
 
+C2x Feature Support
+-------------------
+
+- Implemented `WG14 N2674 The noreturn attribute <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2764.pdf>`_.
+
 C++ Language Changes in Clang
 -----------------------------
 
 - ...
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 

clang/include/clang/Basic/Attr.td

 def C11NoReturn : InheritableAttr {
   let Spellings = [Keyword<"_Noreturn">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let SemaHandler = 0;
   let Documentation = [C11NoReturnDocs];
 }
 
 def CXX11NoReturn : InheritableAttr {
-  let Spellings = [CXX11<"", "noreturn", 200809>];
+  let Spellings = [CXX11<"", "noreturn", 200809>,
+                   C2x<"", "noreturn", 202202>, C2x<"", "_Noreturn", 202202>];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [CXX11NoReturnDocs];
-  let SimpleHandler = 1;
 }
 
 // Similar to CUDA, OpenCL attributes do not receive a [[]] spelling because
 // the specification does not expose them with one currently.
 def OpenCLKernel : InheritableAttr {
   let Spellings = [Keyword<"__kernel">, Keyword<"kernel">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [Undocumented];

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_mode_not_primitive : Error<
   "mode attribute only supported for integer and floating-point types">;
 def err_mode_wrong_type : Error<
   "type of machine mode does not match type of base type">;
 def warn_vector_mode_deprecated : Warning<
   "specifying vector types with the 'mode' attribute is deprecated; "
   "use the 'vector_size' attribute instead">,
   InGroup<DeprecatedAttributes>;
+def warn_deprecated_noreturn_spelling : Warning<
+  "the '[[_Noreturn]]' attribute spelling is deprecated in C2x; use "
+  "'[[noreturn]]' instead">, InGroup<DeprecatedAttributes>;
 def err_complex_mode_vector_type : Error<
   "type of machine mode does not support base vector types">;
 def err_enum_mode_vector_type : Error<
   "mode %0 is not supported for enumeration types">;
 def warn_attribute_nonnull_no_pointers : Warning<
   "'nonnull' attribute applied to function with no pointer arguments">,
   InGroup<IgnoredAttributes>;
 def warn_attribute_nonnull_parm_no_args : Warning<

clang/lib/Headers/stdnoreturn.h

 /*===---- stdnoreturn.h - Standard header for noreturn macro ---------------===
  *
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===-----------------------------------------------------------------------===
  */
 
 #ifndef __STDNORETURN_H
 #define __STDNORETURN_H
 
 #define noreturn _Noreturn
 #define __noreturn_is_defined 1
 
+#if __STDC_VERSION__ > 201710L &&                                              \
+    !defined(_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS)
+/* The noreturn macro is deprecated in C2x. */
+#pragma clang deprecated(noreturn)
+
+/* Including the header file in C2x is also deprecated. */
+#warning "the '<stdnoreturn.h>' header is deprecated in C2x"
+#endif
+
 #endif /* __STDNORETURN_H */

clang/lib/Sema/SemaDeclAttr.cpp

     S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type)
         << Attrs << ExpectedFunctionOrMethod;
     return;
   }
 
   D->addAttr(::new (S.Context) NoReturnAttr(S.Context, Attrs));
 }
 
+static void handleStandardNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &A) {
+  // The [[_Noreturn]] spelling is deprecated in C2x, so if that was used,
+  // issue an appropriate diagnostic.
+  if (!S.getLangOpts().CPlusPlus &&
+      A.getSemanticSpelling() == CXX11NoReturnAttr::C2x_Noreturn)
+    S.Diag(A.getLoc(), diag::warn_deprecated_noreturn_spelling) << A.getRange();
+
+  D->addAttr(::new (S.Context) CXX11NoReturnAttr(S.Context, A));
+}
+
 static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
   if (!S.getLangOpts().CFProtectionBranch)
     S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored);
   else
     handleSimpleAttribute<AnyX86NoCfCheckAttr>(S, D, Attrs);
 }
 
 bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) {

     handleOwnershipAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Naked:
     handleNakedAttr(S, D, AL);
     break;
   case ParsedAttr::AT_NoReturn:
     handleNoReturnAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_CXX11NoReturn:
+    handleStandardNoReturnAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_AnyX86NoCfCheck:
     handleNoCfCheckAttr(S, D, AL);
     break;
   case ParsedAttr::AT_NoThrow:
     if (!AL.isUsedAsTypeAttr())
       handleSimpleAttribute<NoThrowAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_CUDAShared:

clang/test/AST/ast-dump-lambda.cpp

 // CHECK-NEXT:      | | |-DefaultConstructor defaulted_is_constexpr
 // CHECK-NEXT:      | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:      | | |-MoveConstructor exists simple trivial needs_implicit
 // CHECK-NEXT:      | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:      | | |-MoveAssignment
 // CHECK-NEXT:      | | `-Destructor simple irrelevant trivial needs_implicit
 // CHECK-NEXT:      | |-CXXMethodDecl {{.*}} <col:20, col:23> col:3{{( imported)?}} operator() 'auto () const' inline
 // CHECK-NEXT:      | | |-CompoundStmt {{.*}} <col:22, col:23>
-// CHECK-NEXT:      | | `-CXX11NoReturnAttr {{.*}} <col:8>
+// CHECK-NEXT:      | | `-CXX11NoReturnAttr {{.*}} <col:8> noreturn
 // CHECK-NEXT:      | |-CXXConversionDecl {{.*}} <col:3, col:23> col:3{{( imported)?}} implicit constexpr operator auto (*)() 'auto (*() const noexcept)()' inline
 // CHECK-NEXT:      | `-CXXMethodDecl {{.*}} <col:3, col:23> col:3{{( imported)?}} implicit __invoke 'auto ()' static inline
 // CHECK-NEXT:      `-CompoundStmt {{.*}} <col:22, col:23>

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=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
+// none-no-diagnostics
+
+// Test preprocessor functionality.
+#if !__has_c_attribute(noreturn)
+#error "No noreturn attribute support?"
+#endif
+
+#if !__has_c_attribute(_Noreturn)
+#error "No _Noreturn attribute support?"
+#endif
+
+#if __has_c_attribute(noreturn) != __has_c_attribute(_Noreturn) || \
+    __has_c_attribute(noreturn) != 202202L
+#error "Wrong value for __has_c_attribute(noreturn)"
+#endif
+
+// If we're testings with deprecations disabled, we don't care about testing
+// the scenarios that trigger errors because we're only interested in the
+// deprecation warning behaviors.
+#ifndef _CLANG_DISABLE_CRT_DEPRECATION_WARNINGS
+// Test that the attribute accepts no args, applies to the correct subject, etc.
+[[noreturn(12)]] void func4(void); // all-error {{attribute 'noreturn' cannot have an argument list}}
+[[noreturn]] int not_a_func; // all-error {{'noreturn' attribute only applies to functions}}
+void func5(void) [[noreturn]]; // all-error {{'noreturn' attribute cannot be applied to types}}
+#endif
+
+_Noreturn void func1(void); // ok, using the function specifier
+[[noreturn]] void func2(void);
+
+// This is deprecated because it's only for compatibility with inclusion of the
+// <stdnoreturn.h> header where the noreturn macro expands to _Noreturn.
+[[_Noreturn]] void func3(void); // all-warning {{the '[[_Noreturn]]' attribute spelling is deprecated in C2x; use '[[noreturn]]' instead}}
+
+// Test the behavior of including <stdnoreturn.h>
+#include <stdnoreturn.h> // c2x-warning@stdnoreturn.h:* {{the '<stdnoreturn.h>' header is deprecated in C2x}}
+
+[[noreturn]] void func6(void); // all-warning {{the '[[_Noreturn]]' attribute spelling is deprecated in C2x; use '[[noreturn]]' instead}} \
+                               // c2x-warning {{macro 'noreturn' has been marked as deprecated}} \
+                               // c2x-note@stdnoreturn.h:* {{macro marked 'deprecated' here}}
+
+void func7 [[noreturn]] (void); // all-warning {{the '[[_Noreturn]]' attribute spelling is deprecated in C2x; use '[[noreturn]]' instead}} \
+                                // c2x-warning {{macro 'noreturn' has been marked as deprecated}} \
+                                // c2x-note@stdnoreturn.h:* {{macro marked 'deprecated' here}}
+
+noreturn void func8(void); // c2x-warning {{macro 'noreturn' has been marked as deprecated}} \
+                           // c2x-note@stdnoreturn.h:* {{macro marked 'deprecated' here}}
+
+// Ensure the function specifier form still works
+void noreturn func9(void); // c2x-warning {{macro 'noreturn' has been marked as deprecated}} \
+                           // c2x-note@stdnoreturn.h:* {{macro marked 'deprecated' here}}
+
+// Test preprocessor functionality after including <stdnoreturn.h>.
+#if !__has_c_attribute(noreturn) // c2x-warning {{macro 'noreturn' has been marked as deprecated}} \
+                                 // c2x-note@stdnoreturn.h:* {{macro marked 'deprecated' here}}
+#error "No noreturn attribute support?"
+#endif
+
+#if !__has_c_attribute(_Noreturn)
+#error "No _Noreturn attribute support?"
+#endif