Reapply [Clang] Implement P2843R3 - Preprocessing is never undefined

[yronglin]

This PR reapply #192073, and make most -pedantic warnings default on.

---

This PR marks P2843R3 - Preprocessing is never undefined as implemented and add tests.

Fixes #145658

[llvmorg-github-actions]

@llvm/pr-subscribers-clang

Author: Yihan Wang (yronglin)

Changes

This PR reapply #192073, and make most -pedantic warnings default on.

---

This PR marks P2843R3 - Preprocessing is never undefined as implemented and add tests.

Fixes #145658

---

Patch is 40.59 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/196989.diff

33 Files Affected:

• (modified) clang/docs/ReleaseNotes.rst (+6)
• (modified) clang/include/clang/Basic/DiagnosticLexKinds.td (+13-12)
• (modified) clang/lib/Lex/PPDirectives.cpp (+25-16)
• (modified) clang/lib/Lex/PPExpressions.cpp (+1-9)
• (modified) clang/test/C/drs/dr1xx.c (+1-1)
• (modified) clang/test/C/drs/dr2xx.c (+1-1)
• (added) clang/test/CXX/cpp/cpp.concat/p3.cpp (+7)
• (added) clang/test/CXX/cpp/cpp.cond/Inputs/WinBase.h (+12)
• (added) clang/test/CXX/cpp/cpp.cond/p9.cpp (+21)
• (added) clang/test/CXX/cpp/cpp.line/p3.cpp (+7)
• (added) clang/test/CXX/cpp/cpp.line/p5.cpp (+5)
• (added) clang/test/CXX/cpp/cpp.predefined/p4.cpp (+7)
• (added) clang/test/CXX/cpp/cpp.replace.general/p14.cpp (+10)
• (added) clang/test/CXX/cpp/cpp.replace.general/p9.cpp (+29)
• (modified) clang/test/Lexer/cxx-features.cpp (+12-8)
• (modified) clang/test/Lexer/gnu-flags.c (+5-12)
• (modified) clang/test/Misc/warning-flags.c (+1-1)
• (modified) clang/test/Preprocessor/annotate_in_macro_arg.c (+1)
• (modified) clang/test/Preprocessor/expr_define_expansion.c (+2-6)
• (modified) clang/test/Preprocessor/macro-reserved-attrs-cxx11.cpp (+14-14)
• (modified) clang/test/Preprocessor/macro-reserved-ms.c (+1-2)
• (modified) clang/test/Preprocessor/macro-reserved.c (+15-15)
• (modified) clang/test/Preprocessor/macro-reserved.cpp (+14-14)
• (modified) clang/test/Preprocessor/macro_arg_directive.c (+2-2)
• (modified) clang/test/Preprocessor/warn-macro-undef-true.c (+4-8)
• (modified) clang/test/Sema/c++-keyword-in-c.c (+4-4)
• (modified) clang/test/Sema/static-assert.c (+1-1)
• (modified) clang/test/SemaCUDA/noinline.cu (+2-3)
• (modified) clang/test/SemaCXX/abstract.cpp (+1)
• (modified) clang/test/SemaCXX/consteval-builtin.cpp (+1-1)
• (modified) clang/test/SemaCXX/cxx98-compat-pedantic.cpp (+1-1)
• (modified) clang/test/SemaTemplate/instantiate-array.cpp (+1-1)
• (modified) clang/www/cxx_status.html (+1-1)

diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index bd91b8723a5c6..0190cc08d1d96 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -152,6 +152,12 @@ C++ Language Changes
 C++2c Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
+- Implemented `P2843R3 <https://wg21.link/P2843R3>`_ Preprocessing is never
+  undefined. Clang now diagnoses a macro expansion producing ``defined`` in a
+  conditional expression, an embedded directive within macro arguments, macro
+  names reserved for keywords, special identifiers, or standard attribute
+  tokens, and nonconforming ``#line`` directive line numbers by default.
+
 C++23 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/clang/include/clang/Basic/DiagnosticLexKinds.td b/clang/include/clang/Basic/DiagnosticLexKinds.td
index 85fa290de6fd9..2693370886df6 100644
--- a/clang/include/clang/Basic/DiagnosticLexKinds.td
+++ b/clang/include/clang/Basic/DiagnosticLexKinds.td
@@ -421,13 +421,16 @@ def note_pp_ambiguous_macro_chosen : Note<
   "expanding this definition of %0">;
 def note_pp_ambiguous_macro_other : Note<
   "other definition of %0">;
-def warn_pp_macro_hides_keyword : Extension<
+def warn_pp_macro_hides_keyword : Warning<
   "keyword is hidden by macro definition">, InGroup<KeywordAsMacro>;
+def warn_pp_macro_name_is_keyword : Warning<
+  "keyword or identifier with special meaning is used as a macro name">,
+  InGroup<KeywordAsMacro>;
 def warn_pp_macro_is_reserved_id : Warning<
   "macro name is a reserved identifier">, DefaultIgnore,
   InGroup<ReservedIdAsMacro>;
 def warn_pp_macro_is_reserved_attribute_id : Warning<
-  "%0 is a reserved attribute identifier">, DefaultIgnore,
+  "%0 is a reserved attribute identifier">,
   InGroup<ReservedAttributeIdentifier>;
 def warn_pp_objc_macro_redef_ignored : Warning<
   "ignoring redefinition of Objective-C qualifier macro">,
@@ -506,10 +509,10 @@ def warn_cxx98_compat_variadic_macro : Warning<
   InGroup<CXX98CompatPedantic>, DefaultIgnore;
 def ext_named_variadic_macro : Extension<
   "named variadic macros are a GNU extension">, InGroup<VariadicMacros>;
-def err_embedded_directive : Error<"embedding a %select{|#}0%1 directive "
+def err_embedded_directive : Error<"embedding a %0 directive "
                                    "within macro arguments is not supported">;
-def ext_embedded_directive : Extension<
-  "embedding a directive within macro arguments has undefined behavior">,
+def warn_embedded_directive : Warning<
+  "embedding a%select{| }0%1 directive within macro arguments has undefined behavior">,
   InGroup<DiagGroup<"embedded-directive">>;
 def ext_c_missing_varargs_arg : Extension<
   "passing no argument for the '...' parameter of a variadic macro is "
@@ -799,7 +802,7 @@ def err_pp_illegal_floating_literal : Error<
   "floating point literal in preprocessor expression">;
 def err_pp_line_requires_integer : Error<
   "#line directive requires a positive integer argument">;
-def ext_pp_line_zero : Extension<
+def warn_pp_line_zero : Warning<
   "#line directive with zero argument is a GNU extension">,
   InGroup<GNUZeroLineDirective>;
 def err_pp_line_invalid_filename : Error<
@@ -816,8 +819,9 @@ def err_pp_linemarker_invalid_flag : Error<
   "invalid flag line marker directive">;
 def err_pp_linemarker_invalid_pop : Error<
   "invalid line marker flag '2': cannot pop empty include stack">;
-def ext_pp_line_too_big : Extension<
-  "C requires #line number to be less than %0, allowed as extension">;
+def warn_pp_line_too_big : Warning<
+  "C requires #line number to be less than %0, allowed as extension">,
+  InGroup<GNUZeroLineDirective>;
 def warn_cxx98_compat_pp_line_too_big : Warning<
   "#line number greater than 32767 is incompatible with C++98">,
   InGroup<CXX98CompatPedantic>, DefaultIgnore;
@@ -1056,10 +1060,7 @@ def warn_header_guard : Warning<
 def note_header_guard : Note<
   "%0 is defined here; did you mean %1?">;
 
-def warn_defined_in_object_type_macro : Warning<
-  "macro expansion producing 'defined' has undefined behavior">,
-  InGroup<ExpansionToDefined>;
-def warn_defined_in_function_type_macro : Extension<
+def warn_defined_in_macro : Warning<
   "macro expansion producing 'defined' has undefined behavior">,
   InGroup<ExpansionToDefined>;
 
diff --git a/clang/lib/Lex/PPDirectives.cpp b/clang/lib/Lex/PPDirectives.cpp
index 6e90f20572f1f..bde17c1651b33 100644
--- a/clang/lib/Lex/PPDirectives.cpp
+++ b/clang/lib/Lex/PPDirectives.cpp
@@ -186,13 +186,9 @@ static bool isReservedCXXAttributeName(Preprocessor &PP, IdentifierInfo *II) {
   if (Lang.CPlusPlus &&
       hasAttribute(AttributeCommonInfo::AS_CXX11, /* Scope*/ nullptr, II,
                    PP.getTargetInfo(), Lang, /*CheckPlugins*/ false) > 0) {
-    AttributeCommonInfo::AttrArgsInfo AttrArgsInfo =
-        AttributeCommonInfo::getCXX11AttrArgsInfo(II);
-    if (AttrArgsInfo == AttributeCommonInfo::AttrArgsInfo::Required)
-      return PP.isNextPPTokenOneOf(tok::l_paren);
-
+    StringRef Name = II->getName();
     return !PP.isNextPPTokenOneOf(tok::l_paren) ||
-           AttrArgsInfo == AttributeCommonInfo::AttrArgsInfo::Optional;
+           (Name != "likely" && Name != "unlikely");
   }
   return false;
 }
@@ -213,7 +209,11 @@ static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {
 
 static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {
   const LangOptions &Lang = PP.getLangOpts();
-  // Do not warn on keyword undef.  It is generally harmless and widely used.
+  StringRef Text = II->getName();
+  if (II->isKeyword(Lang))
+    return MD_KeywordDef;
+  if (Lang.CPlusPlus11 && (Text == "override" || Text == "final"))
+    return MD_KeywordDef;
   if (isReservedInAllContexts(II->isReserved(Lang)))
     return MD_ReservedMacro;
   if (isReservedCXXAttributeName(PP, II))
@@ -410,8 +410,10 @@ bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
       // We do not want to warn on some patterns widely used in configuration
       // scripts.  This requires analyzing next tokens, so do not issue warnings
       // now, only inform caller.
-      if (ShadowFlag)
+      if (isDefineUndef == MU_Define && ShadowFlag)
         *ShadowFlag = true;
+      else
+        Diag(MacroNameTok, diag::warn_pp_macro_name_is_keyword);
     }
     if (D == MD_ReservedMacro)
       Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);
@@ -1351,7 +1353,13 @@ void Preprocessor::HandleDirective(Token &Result) {
   // not support this for #include-like directives, since that can result in
   // terrible diagnostics, and does not work in GCC.
   if (InMacroArgs) {
+    SmallString<16> DirectiveSpelling;
+    if (Introducer.is(tok::hash))
+      DirectiveSpelling.push_back('#');
+    else if (Introducer.is(tok::at))
+      DirectiveSpelling.push_back('@');
     if (IdentifierInfo *II = Result.getIdentifierInfo()) {
+      DirectiveSpelling.append(II->getName());
       switch (II->getPPKeywordID()) {
       case tok::pp_include:
       case tok::pp_import:
@@ -1361,18 +1369,20 @@ void Preprocessor::HandleDirective(Token &Result) {
       case tok::pp_embed:
       case tok::pp_module:
       case tok::pp___preprocessed_module:
-      case tok::pp___preprocessed_import:
-        Diag(Result, diag::err_embedded_directive)
-            << Introducer.is(tok::hash) << II->getName();
+      case tok::pp___preprocessed_import: {
+        Diag(Result, diag::err_embedded_directive) << DirectiveSpelling;
         Diag(*ArgMacro, diag::note_macro_expansion_here)
             << ArgMacro->getIdentifierInfo();
         DiscardUntilEndOfDirective();
         return;
+      }
       default:
         break;
       }
     }
-    Diag(Result, diag::ext_embedded_directive);
+    bool IsKnownDirective = DirectiveSpelling.size() > 1;
+    Diag(Result, diag::warn_embedded_directive)
+        << IsKnownDirective << DirectiveSpelling;
   }
 
   // Temporarily enable macro expansion if set so
@@ -1620,7 +1630,7 @@ void Preprocessor::HandleLineDirective() {
     return;
 
   if (LineNo == 0)
-    Diag(DigitTok, diag::ext_pp_line_zero);
+    Diag(DigitTok, diag::warn_pp_line_zero);
 
   // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a
   // number greater than 2147483647".  C90 requires that the line # be <= 32767.
@@ -1628,7 +1638,7 @@ void Preprocessor::HandleLineDirective() {
   if (LangOpts.C99 || LangOpts.CPlusPlus11)
     LineLimit = 2147483648U;
   if (LineNo >= LineLimit)
-    Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit;
+    Diag(DigitTok, diag::warn_pp_line_too_big) << LineLimit;
   else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)
     Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);
 
@@ -3329,9 +3339,8 @@ void Preprocessor::HandleDefineDirective(
   if (!MI) return;
 
   if (MacroShadowsKeyword &&
-      !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) {
+      !isConfigurationPattern(MacroNameTok, MI, getLangOpts()))
     Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword);
-  }
   // Check that there is no paste (##) operator at the beginning or end of the
   // replacement list.
   unsigned NumTokens = MI->getNumTokens();
diff --git a/clang/lib/Lex/PPExpressions.cpp b/clang/lib/Lex/PPExpressions.cpp
index 887fd25ac318d..ed6d8fe9ddf5f 100644
--- a/clang/lib/Lex/PPExpressions.cpp
+++ b/clang/lib/Lex/PPExpressions.cpp
@@ -184,11 +184,6 @@ static bool EvaluateDefined(PPValue &Result, Token &PeekTok, DefinedTracker &DT,
   // clang and gcc will pick the #if branch while Visual Studio will take the
   // #else branch.  Emit a warning about this undefined behavior.
   if (beginLoc.isMacroID()) {
-    bool IsFunctionTypeMacro =
-        PP.getSourceManager()
-            .getSLocEntry(PP.getSourceManager().getFileID(beginLoc))
-            .getExpansion()
-            .isFunctionMacroExpansion();
     // For object-type macros, it's easy to replace
     //   #define FOO defined(BAR)
     // with
@@ -204,10 +199,7 @@ static bool EvaluateDefined(PPValue &Result, Token &PeekTok, DefinedTracker &DT,
     // in a different way, and compilers seem to agree on how to behave here.
     // So warn by default on object-type macros, but only warn in -pedantic
     // mode on function-type macros.
-    if (IsFunctionTypeMacro)
-      PP.Diag(beginLoc, diag::warn_defined_in_function_type_macro);
-    else
-      PP.Diag(beginLoc, diag::warn_defined_in_object_type_macro);
+    PP.Diag(beginLoc, diag::warn_defined_in_macro);
   }
 
   // Invoke the 'defined' callback.
diff --git a/clang/test/C/drs/dr1xx.c b/clang/test/C/drs/dr1xx.c
index 055a30cc9c4b8..1704aa0a361d3 100644
--- a/clang/test/C/drs/dr1xx.c
+++ b/clang/test/C/drs/dr1xx.c
@@ -160,7 +160,7 @@ void dr106(void *p, int i) {
 void dr108(void) {
 #define const
   const int i = 12;
-#undef const
+#undef const /* expected-warning {{keyword or identifier with special meaning is used as a macro name}} */
   const int j = 12; /* expected-note {{variable 'j' declared const here}} */
 
   i = 100; /* Okay, the keyword was hidden by the macro. */
diff --git a/clang/test/C/drs/dr2xx.c b/clang/test/C/drs/dr2xx.c
index 7567d485d4324..9dcc3886ac57f 100644
--- a/clang/test/C/drs/dr2xx.c
+++ b/clang/test/C/drs/dr2xx.c
@@ -216,7 +216,7 @@ void dr250(void) {
 
   dr250_nothing(
 #nondirective    /* expected-error {{invalid preprocessing directive}}
-                    expected-warning {{embedding a directive within macro arguments has undefined behavior}}
+                    expected-warning {{embedding a #nondirective directive within macro arguments has undefined behavior}}
                   */
   )
 
diff --git a/clang/test/CXX/cpp/cpp.concat/p3.cpp b/clang/test/CXX/cpp/cpp.concat/p3.cpp
new file mode 100644
index 0000000000000..ddeb2f78a606c
--- /dev/null
+++ b/clang/test/CXX/cpp/cpp.concat/p3.cpp
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -std=c++26 -Wno-invalid-pp-token %s -fsyntax-only -verify
+
+// [cpp.concat]/p3: If the result is not a valid
+// preprocessing token, the program is ill-formed.
+#define CONCAT(A, B) A ## B
+CONCAT(=, >) // expected-error {{pasting formed '=>', an invalid preprocessing token}}
+// expected-error@-1 {{expected unqualified-id}}
diff --git a/clang/test/CXX/cpp/cpp.cond/Inputs/WinBase.h b/clang/test/CXX/cpp/cpp.cond/Inputs/WinBase.h
new file mode 100644
index 0000000000000..b26e538028e4b
--- /dev/null
+++ b/clang/test/CXX/cpp/cpp.cond/Inputs/WinBase.h
@@ -0,0 +1,12 @@
+#ifndef WINBASE_H
+#define WINBASE_H
+
+#pragma clang system_header
+
+#define MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS    \
+  (_WIN32_WINNT >= 0x0502 || !defined(_WINBASE_))
+
+#if MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS /* { */
+#endif /* } */
+
+#endif // WINBASE_H
diff --git a/clang/test/CXX/cpp/cpp.cond/p9.cpp b/clang/test/CXX/cpp/cpp.cond/p9.cpp
new file mode 100644
index 0000000000000..c4f1c3c0dbc06
--- /dev/null
+++ b/clang/test/CXX/cpp/cpp.cond/p9.cpp
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -std=c++26 %s -fsyntax-only -verify
+
+// [cpp.cond]/p9: If the preprocessing token defined is generated as a result
+// of this replacement process, the program is ill-formed, no diagnostic
+// required.
+#define DEFINED defined
+#if DEFINED(bar) // expected-warning {{macro expansion producing 'defined' has undefined behavior}}
+#endif
+
+// Check that a real-world system header pattern remains accepted.
+#include "Inputs/WinBase.h"
+
+// [cpp.cond]/p9: If use of the defined unary operator does not match one of
+// the two specified forms prior to macro replacement, the program is
+// ill-formed, no diagnostic required.
+#if defined() // expected-error {{macro name must be an identifier}}
+#endif
+#if defined(a b) // expected-error {{missing ')' after 'defined'}} expected-note {{to match this '('}}
+#endif
+#if defined(a, b) // expected-error {{missing ')' after 'defined'}} expected-note {{to match this '('}}
+#endif
diff --git a/clang/test/CXX/cpp/cpp.line/p3.cpp b/clang/test/CXX/cpp/cpp.line/p3.cpp
new file mode 100644
index 0000000000000..caf9537d4b88d
--- /dev/null
+++ b/clang/test/CXX/cpp/cpp.line/p3.cpp
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -std=c++26 %s -fsyntax-only -verify
+
+// [cpp.line]/p3: Digit sequences representing a number outside of the range
+// [1, 2147483647] are conditionally supported.
+#line 0 // expected-warning {{#line directive with zero argument is a GNU extension}}
+#line 2147483647 // ok, largest value required to be accepted
+#line 2147483648 // expected-warning {{C requires #line number to be less than 2147483648, allowed as extension}}
diff --git a/clang/test/CXX/cpp/cpp.line/p5.cpp b/clang/test/CXX/cpp/cpp.line/p5.cpp
new file mode 100644
index 0000000000000..8115ff761d1db
--- /dev/null
+++ b/clang/test/CXX/cpp/cpp.line/p5.cpp
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -std=c++26 %s -fsyntax-only -verify
+
+// [cpp.line]/p5: If the directive resulting after all replacements does not
+// match one of the two previous forms, the program is ill-formed.
+#line -1 // expected-error {{#line directive requires a positive integer argument}}
diff --git a/clang/test/CXX/cpp/cpp.predefined/p4.cpp b/clang/test/CXX/cpp/cpp.predefined/p4.cpp
new file mode 100644
index 0000000000000..3883719149f38
--- /dev/null
+++ b/clang/test/CXX/cpp/cpp.predefined/p4.cpp
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -std=c++26 %s -fsyntax-only -verify
+
+// [cpp.predefined]/p4: If any of the pre-defined macro names in this
+// subclause, or the identifier defined, is the subject of a #define or a
+// #undef preprocessing directive, the program is ill-formed.
+#undef defined  // expected-error {{'defined' cannot be used as a macro name}}
+#undef __DATE__ // expected-warning {{undefining builtin macro}}
diff --git a/clang/test/CXX/cpp/cpp.replace.general/p14.cpp b/clang/test/CXX/cpp/cpp.replace.general/p14.cpp
new file mode 100644
index 0000000000000..1572f08f0a31b
--- /dev/null
+++ b/clang/test/CXX/cpp/cpp.replace.general/p14.cpp
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -std=c++26 %s -fsyntax-only -verify
+
+// [cpp.replace.general]/p14: If there are sequences of preprocessing tokens
+// within the list of arguments that would otherwise act as preprocessing
+// directives, the program is ill-formed.
+#define FUNCTION_MACRO(...)
+FUNCTION_MACRO(
+    #if 0 // expected-warning {{embedding a #if directive within macro arguments has undefined behavior}}
+    #endif
+)
diff --git a/clang/test/CXX/cpp/cpp.replace.general/p9.cpp b/clang/test/CXX/cpp/cpp.replace.general/p9.cpp
new file mode 100644
index 0000000000000..2439a9f86d240
--- /dev/null
+++ b/clang/test/CXX/cpp/cpp.replace.general/p9.cpp
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -std=c++26 %s -fsyntax-only -verify
+
+// [cpp.replace.general]/p9: A translation unit shall not #define or #undef
+// macro names lexically identical to keywords ([lex.key]), to the identifiers
+// listed in Table 4, or to the attribute-tokens described in [dcl.attr], except
+// that the macro names likely and unlikely may be defined as function-like
+// macros and may be undefined.
+#define for 0    // expected-warning {{keyword is hidden by macro definition}}
+#undef for       // expected-warning {{keyword or identifier with special meaning is used as a macro name}}
+#define final 1  // expected-warning {{keyword is hidden by macro definition}}
+#undef final     // expected-warning {{keyword or identifier with special meaning is used as a macro name}}
+#define override // expected-warning {{keyword is hidden by macro definition}}
+#undef override  // expected-warning {{keyword or identifier with special meaning is used as a macro name}}
+#define const
+#undef const     // expected-warning {{keyword or identifier with special meaning is used as a macro name}}
+
+#define assume     // expected-warning {{assume is a reserved attribute identifier}}
+#undef assume      // expected-warning {{assume is a reserved attribute identifier}}
+#define nodiscard  // expected-warning {{nodiscard is a reserved attribute identifier}}
+#undef nodiscard   // expected-warning {{nodiscard is a reserved attribute identifier}}
+#define deprecated // expected-warning {{deprecated is a reserved attribute identifier}}
+#undef deprecated  // expected-warning {{deprecated is a reserved attribute identifier}}
+#define likely     // expected-warning {{likely is a reserved attribute identifier}}
+#undef likely      // expected-warning {{likely is a reserved attribute identifier}}
+#define unlikely   // expected-warning {{unlikely is a reserved attribute identifier}}
+#undef unlikely    // expected-warning {{unlikely is a reserved attribute identifier}}
+
+#define likely(x) (x)
+#define unlikely(x) (x)
diff --git a/clang/test/Lexer/cxx-features.cpp b/clang/test/Lexer/cxx-features.cpp
index 171ef99cee5b7..72e9c36546f68 100644
--- a/clang/test/Lexer/cxx-features.cpp
+++ b/clang/test/Lexer/cxx-features.cpp
@@ -19,21 +19,25 @@
 
 // expected-no-diagnostics
 
-// FIXME using `defined` in a macro has undefined behavior.
+// An undefined feature-test macro evaluates to 0 in an #if expression, so
+// `__cpp_##macro != N` tests the feature is defined with the exact value N
+// when N is nonzero, and tests the feature is not defined (or is defined to 0,
+// which feature-test macros never are) when N is 0. Avoiding `defined` inside
+// a macro expansion is required for conformance with [cpp.cond].
 #if __cplusplus < 201103L
-#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98)
+#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (__cpp_##macro != cxx98)
 #elif __cplusplus < 201402L
-#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (cxx11 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx11)
+#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (__cpp_##macro != cxx11)
 #elif __cplusplus < 201703L
-#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (cxx14 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx14)
+#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (__cpp_##macro != cxx14)
 #elif __cplusplus < 202002L
-#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (cxx17 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx17)
+#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (__cpp_##macro != cxx17)
 #elif __cplusplus < 202302L
...
[truncated]

[efriedma-quic]

You probably want ExtWarn for these warnings so they interact correctly with -pedantic-errors.

[yronglin]

Agree, Extension -> ExtWarn more make sense. I also added test for -pedantic-errors.

[github-actions]

✅ With the latest revision this PR passed the C/C++ code formatter.

[cor3ntin]

I think you should revert all the changes made to #line -
See https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4136r2.pdf (26 paper approved as a DR after I realized P2843R3 was needlessly disruptive

[cor3ntin]

There isn't any reason to change that

[cor3ntin]

ditto

[yronglin]

I think you should revert all the changes made to #line - See https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4136r2.pdf (26 paper approved as a DR after I realized P2843R3 was needlessly disruptive

Thanks for the reminder; I hadn't noticed P4136R2. I have reverted the changes related to #line in this PR. IIUC, we also need mark the P4136R2 page as supported? Perhaps I could do that in a separate PR.

[cor3ntin]

Thanks

[petrhosek]

This change broke the LLVM libc build with the following error:

/b/s/w/ir/x/w/llvm-llvm-project/libc/include/__llvm-libc-common.h:28:8: error: keyword or identifier with special meaning is used as a macro name [-Werror,-Wkeyword-macro]
   28 | #undef _Noreturn
      |        ^
/b/s/w/ir/x/w/llvm-llvm-project/libc/include/__llvm-libc-common.h:31:8: error: keyword or identifier with special meaning is used as a macro name [-Werror,-Wkeyword-macro]
   31 | #undef _Alignas
      |        ^
/b/s/w/ir/x/w/llvm-llvm-project/libc/include/__llvm-libc-common.h:34:8: error: keyword or identifier with special meaning is used as a macro name [-Werror,-Wkeyword-macro]
   34 | #undef _Static_assert
      |        ^
/b/s/w/ir/x/w/llvm-llvm-project/libc/include/__llvm-libc-common.h:37:8: error: keyword or identifier with special meaning is used as a macro name [-Werror,-Wkeyword-macro]
   37 | #undef _Alignof
      |        ^

To fix this, the libc code should be updated to avoid undefining these keywords, or the warning should be explicitly suppressed in that file using #pragma clang diagnostic.

cc @michaelrj-google @kaladron

[petrhosek]

@yronglin The source files that include https://github.com/llvm/llvm-project/blob/main/libc/include/__llvm-libc-common.h are built in C++17 mode so I'm surprised to see these warnings since P2843R3 only applies to C++26. Is this a bug in the implementation? If so, would it be possible to revert the change?