Warn if using `elifdef` & `elifndef` in not C2x & C++2b mode

[ken-matsui]

Summary

This patch resolves https://github.com/llvm/llvm-project/issues/55306.

[aaron.ballman]

Thank you for working on this!

clang/include/clang/Basic/DiagnosticLexKinds.td

700–702

I think we need two diagnostics, one for C2x and one for C++2b (https://wg21.link/p2334 was adopted for C++23). Each of these diagnostics should come in a pair:

def warn_cxx20_compat_pp_directive : Warning<
  "use of a '#%select{elifdef|elifndef}0' directive is incompatible with C++ standards before C++2b",
  InGroup<CXXPre2bCompat>, DefaultIgnore;
def ext_cxx20_pp_directive : ExtWarn<
  "use of a '#%select{elifdef|elifndef}0' directive is a C++2b extension",
  InGroup<CXX2b>;

and similar for C, except with wording about C standards and in the C warning groups.

clang/lib/Lex/PPDirectives.cpp

3277–3278

And then here, you would do something like:

unsigned DiagID;
if (getLangOpts().CPlusPlus)
  DiagID = getLangOpts().CPlusPlus2b ? diag::warn_cxx20_compat_pp_directive : diag::ext_cxx20_pp_directive;
else
  DiagID = getLangOpts().C2x ? diag::warn_c17_compat_pp_directive : diag::ext_c2b_pp_directive;

Diag(ElifToken, DiagID) << ...;

clang/test/Preprocessor/ext-c2x-pp-directive.c

14 ↗

(On Diff #427898)

Might as well add a declaration so that we don't have to expect the diagnostic.

Also, this will need tests for both forms of the diagnostics, C++ tests, and it'd probably be good to verify the behavior when the previous conditional is skipped. e.g.,

#if 0
#elifdef WHATEVER // We should still warn on this; we wouldn't if we didn't recognize it as a conditional
#endif

[ken-matsui]

Update the code as reviewed

[ken-matsui]

Thank you so much for your review!

clang/include/clang/Basic/DiagnosticLexKinds.td

700–702

I thought I had to use Extension here, but what is the difference between Warning, ExtWarn, and Extension?

[aaron.ballman]

It looks like precommit CI caught some related failures:

Failed Tests (7):
  Clang :: Lexer/deprecate-macro.c
  Clang :: Lexer/unsafe-macro.c
  Clang :: Preprocessor/elifdef.c
  Clang :: Preprocessor/if_warning.c
  Clang :: Preprocessor/ifdef-recover.c
  Clang :: Preprocessor/macro_misc.c
  Clang :: Preprocessor/macro_vaopt_check.cpp

clang/include/clang/Basic/DiagnosticLexKinds.td

700–702

Great question!

Extension diagnostics are warnings that are enabled via -pedantic but otherwise off by default.
ExtWarn diagnostics are warnings that are enabled via -pedantic but are also on by default.
Warning diagnostics are warnings. You can use things like DefaultIgnore or DefaultError to control the default behavior of the warning.
Error diagnostics are errors.

You'll typically use Extension or ExtWarn for things that are extensions of some sort, but which one you use depends on how important the warning is. We've traditionally handled "use of whatever is a C++NN extension" warnings as ExtWarn whereas the "use of whatever is incompatible with C++ standards before C++NN" warnings are usually Extension.

[ken-matsui]

In D125178#3503617, @aaron.ballman wrote:

It looks like precommit CI caught some related failures:

Failed Tests (7):
  Clang :: Lexer/deprecate-macro.c
  Clang :: Lexer/unsafe-macro.c
  Clang :: Preprocessor/elifdef.c
  Clang :: Preprocessor/if_warning.c
  Clang :: Preprocessor/ifdef-recover.c
  Clang :: Preprocessor/macro_misc.c
  Clang :: Preprocessor/macro_vaopt_check.cpp

Ahhh, my bad. Thank you for your heads up!

clang/include/clang/Basic/DiagnosticLexKinds.td

700–702

In this case, compat_pp_directive for C++2b & C2x uses Warning, but why did you choose it rather than Extension?

[aaron.ballman]

clang/include/clang/Basic/DiagnosticLexKinds.td

700–702

Oh shoot, I misspoke and said ExtWarn when I meant Warning that's default ignored. Sorry about that, and thank you for asking for clarification!

I picked that because it's the pattern used by many other diagnostic pairs:

def ext_inline_variable : ExtWarn<
  "inline variables are a C++17 extension">, InGroup<CXX17>;
def warn_cxx14_compat_inline_variable : Warning<
  "inline variables are incompatible with C++ standards before C++17">,
  DefaultIgnore, InGroup<CXXPre17Compat>;

def ext_for_range_begin_end_types_differ : ExtWarn<
  "'begin' and 'end' returning different types (%0 and %1) is a C++17 extension">,
  InGroup<CXX17>;
def warn_for_range_begin_end_types_differ : Warning<
  "'begin' and 'end' returning different types (%0 and %1) is incompatible "
  "with C++ standards before C++17">, InGroup<CXXPre17Compat>, DefaultIgnore;

def ext_constexpr_body_invalid_stmt : ExtWarn<
  "use of this statement in a constexpr %select{function|constructor}0 "
  "is a C++14 extension">, InGroup<CXX14>;
def warn_cxx11_compat_constexpr_body_invalid_stmt : Warning<
  "use of this statement in a constexpr %select{function|constructor}0 "
  "is incompatible with C++ standards before C++14">,
  InGroup<CXXPre14Compat>, DefaultIgnore;

def ext_constexpr_function_try_block_cxx20 : ExtWarn<
  "function try block in constexpr %select{function|constructor}0 is "
  "a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_constexpr_function_try_block : Warning<
  "function try block in constexpr %select{function|constructor}0 is "
  "incompatible with C++ standards before C++20">,
  InGroup<CXXPre20Compat>, DefaultIgnore;

[ken-matsui]

clang/include/clang/Basic/DiagnosticLexKinds.td

700–702

Oh, that makes sense. Thank you for your explanation!

[ken-matsui]

Fix failed tests

[aaron.ballman]

clang/include/clang/Basic/DiagnosticLexKinds.td

702

(You may also need to rewrap to 80 col limits.)

And do the same for the other three, so that you can use PPElifDiag for it.

clang/lib/Lex/PPDirectives.cpp

663

I like the way you're thinking about this, but I don't like how clever the code is. I'd rather update the comment on PPElifDiag to mention warn_*_compat_pp_directive and ext_*_pp_directive, and then update those diagnostics to have a bogus select slot for the PED_Elif that will never be used.

[ken-matsui]

Update the code as reviewed

[ken-matsui]

Thank you for your review! I updated the code.

[aaron.ballman]

LGTM aside from a super minor nit in a test file. Can you please add a release note for the new diagnostics as well?

I'm happy to land this for you when you're ready, but let me know which email address you'd like me to use this time around.

clang/test/Preprocessor/ifdef-recover.c

23–29

Just to keep comment styles the same.

[ken-matsui]

Updated the code as reviewed, added a release note, and merged ext-cpp2b-pp-directive.cpp & ext-c2x-pp-directive.c into ext-pp-directive.c.

[ken-matsui]

Thank you so much for your review!

My public email address is: [e-mail].

[aaron.ballman]

Oops, it looks like precommit CI found a relevant issue, can you fix it up?

Failed Tests (1):
  Clang :: Preprocessor/elifdef.c
 
Testing Time: 790.67s
  Skipped          :    56
  Unsupported      :  1997
  Passed           : 87720
  Expectedly Failed:   234
  Failed           :     1

[ken-matsui]

Fix the failed test

[ken-matsui]

I fixed it!

clang/docs/ReleaseNotes.rst

- ``-Wenum-conversion`` now warns on converting a signed enum of one type to an
   ``-Wsign-conversion``.
 - Added the ``-Wunreachable-code-generic-assoc`` diagnostic flag (grouped under
   the ``-Wunreachable-code`` flag) which is enabled by default and warns the
   user about ``_Generic`` selection associations which are unreachable because
   the type specified is an array type or a qualified type.
 - Added the ``-Wgnu-line-marker`` diagnostic flag (grouped under the ``-Wgnu``
   flag) which is a portability warning about use of GNU linemarker preprocessor
   directives. Fixes `Issue 55067 <https://github.com/llvm/llvm-project/issues/55067>`_.
+- Using ``#elifdef`` and ``#elifndef`` that are incompatible with C/C++
+  standards before C2x/C++2b are now warned via ``-pedantic``. Additionally,
+  on such language mode, ``-Wpre-c2x-compat`` and ``-Wpre-c++2b-compat``
+  diagnostic flags report a compatibility issue.
+  Fixes `Issue 55306 <https://github.com/llvm/llvm-project/issues/55306>`_.
+
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
 - Improve __builtin_dump_struct:
 
   - Support bitfields in struct and union.
   - Improve the dump format, dump both bitwidth(if its a bitfield) and field

clang/include/clang/Basic/DiagnosticLexKinds.td

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_cxx98_compat_pp_line_too_big : Warning<
   "#line number greater than 32767 is incompatible with C++98">,
   InGroup<CXX98CompatPedantic>, DefaultIgnore;
 
+def warn_c2x_compat_pp_directive : Warning<
+  "use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive "
+  "is incompatible with C standards before C2x">,
+  InGroup<CPre2xCompat>, DefaultIgnore;
+def ext_c2x_pp_directive : ExtWarn<
+  "use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive "
+  "is a C2x extension">,
+  InGroup<C2x>;
+def warn_cxx2b_compat_pp_directive : Warning<
+  "use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive "
+  "is incompatible with C++ standards before C++2b">,
+  InGroup<CXXPre2bCompat>, DefaultIgnore;
+def ext_cxx2b_pp_directive : ExtWarn<
+  "use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive "
+  "is a C++2b extension">,
+  InGroup<CXX2b>;
+
 def err_pp_visibility_non_macro : Error<"no macro named %0">;
 
 def err_pp_arc_cf_code_audited_syntax : Error<"expected 'begin' or 'end'">;
 def err_pp_double_begin_of_arc_cf_code_audited : Error<
   "already inside '#pragma clang arc_cf_code_audited'">;
 def err_pp_unmatched_end_of_arc_cf_code_audited : Error<
   "not currently inside '#pragma clang arc_cf_code_audited'">;
 def err_pp_include_in_arc_cf_code_audited : Error<

clang/lib/Lex/PPDirectives.cpp

if (Directive.startswith("if")) {
           }
         }
       } else if (Sub == "lifdef" ||  // "elifdef"
                  Sub == "lifndef") { // "elifndef"
         bool IsElifDef = Sub == "lifdef";
         PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
         Token DirectiveToken = Tok;
 
+        // Warn if using `#elifdef` & `#elifndef` in not C2x & C++2b mode even
+        // if this branch is in a skipping block.
+        unsigned DiagID;
+        if (LangOpts.CPlusPlus)
+          DiagID = LangOpts.CPlusPlus2b ? diag::warn_cxx2b_compat_pp_directive
+                                        : diag::ext_cxx2b_pp_directive;
+        else
+          DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive
+                                : diag::ext_c2x_pp_directive;
+        Diag(Tok, DiagID) << (IsElifDef ? PED_Elifdef : PED_Elifndef);
+
         // If this is a #elif with a #else before it, report the error.
         if (CondInfo.FoundElse)
           Diag(Tok, diag::pp_err_elif_after_else)
               << (IsElifDef ? PED_Elifdef : PED_Elifndef);
 
         // If this is in a skipping block or if we're already handled this #if
         // block, don't bother parsing the condition.
         if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {

 void Preprocessor::HandleElifFamilyDirective(Token &ElifToken,
                                              const Token &HashToken,
                                              tok::PPKeywordKind Kind) {
   PPElifDiag DirKind = Kind == tok::pp_elif      ? PED_Elif
                        : Kind == tok::pp_elifdef ? PED_Elifdef
                                                  : PED_Elifndef;
   ++NumElse;
 
+  // Warn if using `#elifdef` & `#elifndef` in not C2x & C++2b mode.
+  switch (DirKind) {
+  case PED_Elifdef:
+  case PED_Elifndef:
+    unsigned DiagID;
+    if (LangOpts.CPlusPlus)
+      DiagID = LangOpts.CPlusPlus2b ? diag::warn_cxx2b_compat_pp_directive
+                                    : diag::ext_cxx2b_pp_directive;
+    else
+      DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive
+                            : diag::ext_c2x_pp_directive;
+    Diag(ElifToken, DiagID) << DirKind;
+    break;
+  default:
+    break;
+  }
+
   // #elif directive in a non-skipping conditional... start skipping.
   // We don't care what the condition is, because we will always skip it (since
   // the block immediately before it was included).
   SourceRange ConditionRange = DiscardUntilEndOfDirective();
 
   PPConditionalInfo CI;
   if (CurPPLexer->popConditionalLevel(CI)) {
     Diag(ElifToken, diag::pp_err_elif_without_if) << DirKind;

clang/test/Lexer/Inputs/unsafe-macro-2.h

 // expected-warning@-1{{macro 'UNSAFE_MACRO' has been marked as unsafe for use in headers: Don't use this!}}
 #endif
 
 
 // Test that we diagnose on #elifdef.
 #ifdef baz
 #elifdef UNSAFE_MACRO
 // expected-warning@-1{{macro 'UNSAFE_MACRO' has been marked as unsafe for use in headers: Don't use this!}}
+// expected-warning@-2{{use of a '#elifdef' directive is a C2x extension}}
 #endif
 
 // Test that we diagnose on #elifndef.
 #ifdef baz
 #elifndef UNSAFE_MACRO
 #endif
 // expected-warning@-2{{macro 'UNSAFE_MACRO' has been marked as unsafe for use in headers: Don't use this!}}
+// expected-warning@-3{{use of a '#elifndef' directive is a C2x extension}}
 
 // FIXME: These cases are currently not handled because clang doesn't expand
 // conditions on skipped #elif* blocks. See the FIXME notes in
 // Preprocessor::SkipExcludedConditionalBlock.
 
 #define frobble
 
 #ifdef frobble
-// not-expected-warning@+1{{macro 'UNSAFE_MACRO' has been marked as unsafe for use in headers: Don't use this!}}
+// not-expected-warning@+2{{macro 'UNSAFE_MACRO' has been marked as unsafe for use in headers: Don't use this!}}
+// expected-warning@+1{{use of a '#elifndef' directive is a C2x extension}}
 #elifndef UNSAFE_MACRO
 #endif
 
 #ifdef frobble
-// not-expected-warning@+1{{macro 'UNSAFE_MACRO' has been marked as unsafe for use in headers: Don't use this!}}
+// not-expected-warning@+2{{macro 'UNSAFE_MACRO' has been marked as unsafe for use in headers: Don't use this!}}
+// expected-warning@+1{{use of a '#elifdef' directive is a C2x extension}}
 #elifdef UNSAFE_MACRO
 #endif
 
 #if 1
 // not-expected-warning@+1{{macro 'UNSAFE_MACRO' has been marked as unsafe for use in headers: Don't use this!}}
 #elif UNSAFE_MACRO
 #endif

clang/test/Lexer/deprecate-macro.c

 // expected-warning@-1{{macro 'foo' has been marked as deprecated}}
 #endif
 
 
 // Test that we diagnose on #elifdef.
 #ifdef baz
 #elifdef foo
 // expected-warning@-1{{macro 'foo' has been marked as deprecated}}
+// expected-warning@-2{{use of a '#elifdef' directive is a C2x extension}}
 #endif
 
 // Test that we diagnose on #elifndef.
 #ifdef baz
 #elifndef foo
 #endif
 // expected-warning@-2{{macro 'foo' has been marked as deprecated}}
+// expected-warning@-3{{use of a '#elifndef' directive is a C2x extension}}
 
 // FIXME: These cases are currently not handled because clang doesn't expand
 // conditions on skipped #elif* blocks. See the FIXME notes in
 // Preprocessor::SkipExcludedConditionalBlock.
 
 #ifdef frobble
-// not-expected-warning@+1{{macro 'foo' has been marked as deprecated}}
+// not-expected-warning@+2{{macro 'foo' has been marked as deprecated}}
+// expected-warning@+1{{use of a '#elifndef' directive is a C2x extension}}
 #elifndef foo
 #endif
 
 #ifdef frobble
-// not-expected-warning@+1{{macro 'foo' has been marked as deprecated}}
+// not-expected-warning@+2{{macro 'foo' has been marked as deprecated}}
+// expected-warning@+1{{use of a '#elifdef' directive is a C2x extension}}
 #elifdef foo
 #endif
 
 #if 1
 // not-expected-warning@+1{{macro 'foo' has been marked as deprecated}}
 #elif foo
 #endif

clang/test/Preprocessor/elifdef.c

 // RUN: %clang_cc1 %s -Eonly -verify
 
+/* expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #elifdef BAR
 #error "did not expect to get here"
 #endif
 
-/* expected-error@+4 {{"got it"}} */
+/* expected-error@+5 {{"got it"}} */
+/* expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #elifdef BAR
 #else
 #error "got it"
 #endif
 
-/* expected-error@+3 {{"got it"}} */
+/* expected-error@+4 {{"got it"}} */
+/* expected-warning@+2 {{use of a '#elifndef' directive is a C2x extension}} */
 #ifdef FOO
 #elifndef BAR
 #error "got it"
 #endif
 
-/* expected-error@+3 {{"got it"}} */
+/* expected-error@+4 {{"got it"}} */
+/* expected-warning@+2 {{use of a '#elifndef' directive is a C2x extension}} */
 #ifdef FOO
 #elifndef BAR
 #error "got it"
 #else
 #error "did not expect to get here"
 #endif
 
 #define BAR
-/* expected-error@+3 {{"got it"}} */
+/* expected-error@+4 {{"got it"}} */
+/* expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #elifdef BAR
 #error "got it"
 #endif
 #undef BAR
 
+/* expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #elifdef BAR // test that comments aren't an issue
 #error "did not expect to get here"
 #endif
 
-/* expected-error@+4 {{"got it"}} */
+/* expected-error@+5 {{"got it"}} */
+/* expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #elifdef BAR // test that comments aren't an issue
 #else
 #error "got it"
 #endif
 
-/* expected-error@+3 {{"got it"}} */
+/* expected-error@+4 {{"got it"}} */
+/* expected-warning@+2 {{use of a '#elifndef' directive is a C2x extension}} */
 #ifdef FOO
 #elifndef BAR // test that comments aren't an issue
 #error "got it"
 #endif
 
-/* expected-error@+3 {{"got it"}} */
+/* expected-error@+4 {{"got it"}} */
+/* expected-warning@+2 {{use of a '#elifndef' directive is a C2x extension}} */
 #ifdef FOO
 #elifndef BAR // test that comments aren't an issue
 #error "got it"
 #else
 #error "did not expect to get here"
 #endif
 
 #define BAR
-/* expected-error@+3 {{"got it"}} */
+/* expected-error@+4 {{"got it"}} */
+/* expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #elifdef BAR // test that comments aren't an issue
 #error "got it"
 #endif
 #undef BAR
 
 #define BAR
-/* expected-error@+6 {{"got it"}} */
+/* expected-error@+7 {{"got it"}} */
+/* expected-warning@+3 {{use of a '#elifndef' directive is a C2x extension}} */
 #ifdef FOO
 #error "did not expect to get here"
 #elifndef BAR
 #error "did not expect to get here"
 #else
 #error "got it"
 #endif
 #undef BAR
 
-/* expected-error@+3 {{#elifdef after #else}} */
+/* expected-error@+4 {{#elifdef after #else}} */
+/* expected-warning@+3 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #else
 #elifdef BAR
 #endif
 
-/* expected-error@+3 {{#elifndef after #else}} */
+/* expected-error@+4 {{#elifndef after #else}} */
+/* expected-warning@+3 {{use of a '#elifndef' directive is a C2x extension}} */
 #ifdef FOO
 #else
 #elifndef BAR
 #endif
 
+/* expected-warning@+1 {{use of a '#elifdef' directive is a C2x extension}} */
 #elifdef FOO /* expected-error {{#elifdef without #if}} */
 #endif       /* expected-error {{#endif without #if}} */
 
+/* expected-warning@+1 {{use of a '#elifndef' directive is a C2x extension}} */
 #elifndef FOO /* expected-error {{#elifndef without #if}} */
 #endif        /* expected-error {{#endif without #if}} */
 
 /* Note, we do not expect errors about the missing macro name in the skipped
    blocks. This is consistent with #elif behavior. */
-/* expected-error@+2 {{"got it"}} */
+/* expected-error@+4 {{"got it"}} */
+/* expected-warning@+4 {{use of a '#elifdef' directive is a C2x extension}} */
+/* expected-warning@+4 {{use of a '#elifndef' directive is a C2x extension}} */
 #ifndef FOO
 #error "got it"
 #elifdef
 #elifndef
 #endif
 
 /* expected-error@+3 {{#elif after #else}}*/
 #if 1
 #else
 #elif
 #endif

clang/test/Preprocessor/ext-pp-directive.c

+// For C
+// RUN: %clang_cc1 -std=c99 -fsyntax-only -verify=pre-c2x-pedantic -pedantic %s
+// RUN: %clang_cc1 -std=c2x -fsyntax-only -verify=pre-c2x-compat -Wpre-c2x-compat %s
+// RUN: not %clang_cc1 -std=c99 -fsyntax-only -verify %s
+// RUN: not %clang_cc1 -std=c2x -fsyntax-only -verify -pedantic %s
+// RUN: not %clang_cc1 -std=c2x -fsyntax-only -verify %s
+
+// For C++
+// RUN: %clang_cc1 -x c++ -fsyntax-only -verify=pre-cpp2b-pedantic -pedantic %s
+// RUN: %clang_cc1 -x c++ -std=c++2b -fsyntax-only -verify=pre-cpp2b-compat -Wpre-c++2b-compat %s
+// RUN: not %clang_cc1 -x c++ -fsyntax-only -verify %s
+// RUN: not %clang_cc1 -x c++ -std=c++2b -fsyntax-only -verify -pedantic %s
+// RUN: not %clang_cc1 -x c++ -std=c++2b -fsyntax-only -verify %s
+
+int x;
+
+#if 1
+#elifdef A // #1
+#endif
+// For C
+// pre-c2x-pedantic-warning@#1 {{use of a '#elifdef' directive is a C2x extension}}
+// pre-c2x-compat-warning@#1 {{use of a '#elifdef' directive is incompatible with C standards before C2x}}
+
+// For C++
+// pre-cpp2b-pedantic-warning@#1 {{use of a '#elifdef' directive is a C++2b extension}}
+// pre-cpp2b-compat-warning@#1 {{use of a '#elifdef' directive is incompatible with C++ standards before C++2b}}
+
+#if 1
+#elifndef B // #2
+#endif
+// For C
+// pre-c2x-pedantic-warning@#2 {{use of a '#elifndef' directive is a C2x extension}}
+// pre-c2x-compat-warning@#2 {{use of a '#elifndef' directive is incompatible with C standards before C2x}}
+
+// For C++
+// pre-cpp2b-pedantic-warning@#2 {{use of a '#elifndef' directive is a C++2b extension}}
+// pre-cpp2b-compat-warning@#2 {{use of a '#elifndef' directive is incompatible with C++ standards before C++2b}}
+
+#if 0
+#elifdef C
+#endif
+// For C
+// pre-c2x-pedantic-warning@-3 {{use of a '#elifdef' directive is a C2x extension}}
+// pre-c2x-compat-warning@-4 {{use of a '#elifdef' directive is incompatible with C standards before C2x}}
+
+// For C++
+// pre-cpp2b-pedantic-warning@-7 {{use of a '#elifdef' directive is a C++2b extension}}
+// pre-cpp2b-compat-warning@-8 {{use of a '#elifdef' directive is incompatible with C++ standards before C++2b}}
+
+#if 0
+#elifndef D
+#endif
+// For C
+// pre-c2x-pedantic-warning@-3 {{use of a '#elifndef' directive is a C2x extension}}
+// pre-c2x-compat-warning@-4 {{use of a '#elifndef' directive is incompatible with C standards before C2x}}
+
+// For C++
+// pre-cpp2b-pedantic-warning@-7 {{use of a '#elifndef' directive is a C++2b extension}}
+// pre-cpp2b-compat-warning@-8 {{use of a '#elifndef' directive is incompatible with C++ standards before C++2b}}

clang/test/Preprocessor/if_warning.c

 // RUN: %clang_cc1 %s -Eonly -Werror=undef -verify
 
 extern int x;
 
 #if foo   // expected-error {{'foo' is not defined, evaluates to 0}}
 #endif
 
+// expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}}
 #ifdef foo
 #elifdef foo
 #endif
 
 #if defined(foo)
 #endif
 
 
 // PR3938
+// expected-warning@+3 {{use of a '#elifdef' directive is a C2x extension}}
 #if 0
 #ifdef D
 #elifdef D
 #else 1       // Should not warn due to C99 6.10p4
 #endif
 #endif
 
 // rdar://9475098
 #if 0
 #else 1   // expected-warning {{extra tokens}}
 #endif
 
 // PR6852
 #if 'somesillylongthing'  // expected-warning {{character constant too long for its type}} \
                           // expected-warning {{multi-character character constant}}
 #endif

clang/test/Preprocessor/ifdef-recover.c

 #endif
 
 /* PR1936 */
 /* expected-error@+2 {{unterminated function-like macro invocation}} expected-error@+2 {{expected value in expression}} expected-note@+1 {{macro 'f' defined here}} */
 #define f(x) x
 #if f(2
 #endif
 
-/* expected-error@+2 {{macro name missing}} */
+/* expected-error@+3 {{macro name missing}} */
+/* expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #elifdef
 #endif
 
-/* expected-error@+2 {{macro name must be an identifier}} */
+/* expected-error@+3 {{macro name must be an identifier}} */
+/* expected-warning@+2 {{use of a '#elifdef' directive is a C2x extension}} */
 #ifdef FOO
 #elifdef !
 #endif
 
 int x;

clang/test/Preprocessor/macro_misc.c

 // RUN: %clang_cc1 %s -Eonly -verify
 
 // This should not be rejected.
 #ifdef defined
 #elifdef defined
 #endif
+// expected-warning@-2 {{use of a '#elifdef' directive is a C2x extension}}
 
 
 
 // PR3764
 
 // This should not produce a redefinition warning.
 #define FUNC_LIKE(a) (a)
 #define FUNC_LIKE(a)(a)

clang/test/Preprocessor/macro_vaopt_check.cpp

-// RUN: %clang_cc1 %s -Eonly -verify -Wno-all -pedantic -std=c++20
-// RUN: %clang_cc1 %s -Eonly -verify -Wno-all -pedantic -std=c++11
-// RUN: %clang_cc1 -x c %s -Eonly -verify -Wno-all -pedantic -std=c99
+// RUN: %clang_cc1 %s -Eonly -verify -Wno-all -Wno-c++2b-extensions -pedantic -std=c++20
+// RUN: %clang_cc1 %s -Eonly -verify -Wno-all -Wno-c++2b-extensions -pedantic -std=c++11
+// RUN: %clang_cc1 -x c %s -Eonly -verify -Wno-all -Wno-c2x-extensions -pedantic -std=c99
 
 //expected-error@+1{{missing '('}}
 #define V1(...) __VA_OPT__  
 #undef V1
 // OK
 #define V1(...) __VA_OPT__  ()
 #undef V1