Diagnosing the Future Keywords

[Codesbyusman]

Summary

The patch diagnoses a Keyword as a future keyword if it exist in the upcoming language mode. such that

int restrict;

in the c modes earlier than C99 then will give a warning to the user that is a future keyword in C99. Now it handles keywords from C as well as C++

[xbolva00]

clang/include/clang/Basic/TokenKinds.def

395

nullptr is now in C23, right?

[erichkeane]

I believe you need tests here desperately. I also believe the define logic that you have here isn't going to be sufficient for the C future flags thanks to it getting some C keywords.

clang/include/clang/Basic/TokenKinds.def

387

Hmm... this looks like it is going to be troublesome for the 'future' feature. Can you make sure you have tests for all of these?

clang/lib/Lex/Preprocessor.cpp

799

This isn't right at all. We should be looking through the list of flags instead of trying to assume that cxx11 keywords here are all 'future' C keywords. First, this isn't true. Second, even if it was, it is really fragile.

[aaron.ballman]

clang/include/clang/Basic/TokenKinds.def

395

It is, but that's separate from the rest of these changes (it would need testing and other work).

[Codesbyusman]

clang/include/clang/Basic/TokenKinds.def

387

Hmm... this looks like it is going to be troublesome for the 'future' feature. Can you make sure you have tests for all of these?

Yes working for the test cases

clang/lib/Lex/Preprocessor.cpp

799

This isn't right at all. We should be looking through the list of flags instead of trying to assume that cxx11 keywords here are all 'future' C keywords. First, this isn't true. Second, even if it was, it is really fragile

Yes I was looking to it, But not getting how to deal this.
Will need to make the different Case to access some of the keywords that are define in CXX11_KEYWORD.
Any suggestions?

[erichkeane]

clang/include/clang/Basic/TokenKinds.def

387

I meant, for tests you haven't written yet. You need to write tests to validate that the future diagnostics are emitted properly.

clang/lib/Lex/Preprocessor.cpp

799

I suspect this pattern of using the define over the C99_KEYWORD/etc is not going to be sufficient. You'll likely have to just define KEYWORD, use it to 'extract' the entire list of flags, then check to see which language flag is 'set' vs the current LangOpts. You might be able to replace the C++ part of this that way to unify the implementations.

So something like:

unsigned Flags = llvm::StringSwitch<unsigned>(II.getName())
#define KEYWORD(NAME, FLAGS) .Case(#NAME, FLAGS)
#include "clang/Basic/TokenKinds.def
;
// Then, do a bunch of checks of the current 'lang' version vs the 'set' flag of the keyword.

[Codesbyusman]

updated.

[erichkeane]

I didn't have time to dig into the correctness of the TokenKinds or test changes (hopefully @aaron.ballman can take some time on that), but implementation overall looks correct, just with some style/formatting issues.

clang/include/clang/Basic/TokenKinds.def

82

NiT: Would be nice to put these next to the OTHER language standards

clang/lib/Basic/IdentifierTable.cpp

852

This comment block shouldn't be here at all.

863

This comment doesn't really make any sense here. I dont understand what you're trying to say.

874

This comment isn't helpful.

884

just make this an 'else'.

[aaron.ballman]

Precommit CI is failing with a failure that looks like it's relevant:

******************** TEST 'Clang :: Parser/static_assert.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c2x -DTEST_SPELLING -verify=c2x C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 2';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c2x -DTEST_SPELLING -fms-compatibility -verify=c2x-ms C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 3';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c2x -Wpre-c2x-compat -verify=c2x-compat C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 4';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c99 -verify=c99 C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 5';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c99 -pedantic -verify=c99-pedantic C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 6';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c++17 -verify=cxx17 -x c++ C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 7';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c++17 -pedantic -verify=cxx17-pedantic -x c++ C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 8';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c++98 -verify=cxx98 -x c++ C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 9';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c++98 -pedantic -verify=cxx98-pedantic -x c++ C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
: 'RUN: at line 10';   c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fsyntax-only -std=c++17 -Wpre-c++17-compat -verify=cxx17-compat -x c++ C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "c:\ws\w9\llvm-project\premerge-checks\build\bin\clang.exe" "-cc1" "-internal-isystem" "c:\ws\w9\llvm-project\premerge-checks\build\lib\clang\16.0.0\include" "-nostdsysteminc" "-fsyntax-only" "-std=c2x" "-DTEST_SPELLING" "-verify=c2x" "C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c"
# command stderr:
error: 'error' diagnostics expected but not seen: 
  File C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c Line 18: expected parameter declarator
  File C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c Line 18: expected ')'
  File C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c Line 18: a type specifier is required for all declarations
error: 'warning' diagnostics seen but not expected: 
  File C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c Line 18: use of 'static_assert' without inclusion of <assert.h> is a Microsoft extension
error: 'note' diagnostics expected but not seen: 
  File C:\ws\w9\llvm-project\premerge-checks\clang\test\Parser\static_assert.c Line 18: to match this '('
5 errors generated.

error: command failed with exit status: 1

--

********************

I think this is coming from the fact that you're marking a bunch of keywords as being C2x keywords. That's correct insomuch as they are C2x keywords. But it's incorrect because we haven't actually implemented those features yet in the rest of the compiler. I think we should continue to treat the C2x keywords as we did previously. For the C2x keywords in the test file, you can put a FIXME comment above the ones that should get a warning whenever we finish the support for that keyword. WDYT @erichkeane?

clang/include/clang/Basic/DiagnosticLexKinds.td

86

I think the diagnostic group here is incorrect -- this grouping is used for things which are not compatible with standards before C2x. I think you need to add a new group for C2xCompat to DiagnosticGroups.td and use it here.

clang/include/clang/Basic/IdentifierTable.h

672–674 ↗

(On Diff #453110)

clang/include/clang/Basic/TokenKinds.def

85–86

I think this should be C2X_KEYWORD and KEYC2X for the moment (C23 isn't published yet so we're sticking with its placeholder name elsewhere in the code base).

384

This should be KEYC23.

clang/lib/Basic/IdentifierTable.cpp

96

It's worth noting that there are no C11 keywords that we handle only in C11+ mode, so we could probably repurpose this value for a different language mode.

[Codesbyusman]

updated with suggestios

[erichkeane]

Looks about right, please see if you can do more work on the static-assert test to make sure we don't lose other testing behavior, AND see the other comment.

clang/lib/Lex/Preprocessor.cpp

878

Don't create a new one, do getIdentifierTable() to get the active identifier table.

clang/test/Parser/static_assert.c

16 ↗

(On Diff #454612)

So we want to make sure we still get the ms-warnings, so this also needs to be validated in C++17 mode as well, which should ALSO give us a 'future keyword' diagnostic.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticLexKinds.td

85

clang/include/clang/Basic/TokenKinds.def

259

384

This is technically correct, but I think we should remove it until we go to implement that paper instead of introducing the keyword out of thin air here.

Btw, I think that should be , 0 instead of , KEYC2X given the use of C2X_KEYWORD, right?

clang/lib/Lex/Preprocessor.cpp

789–791

You should be sure to add this comment to the new code so we don't lose the useful information.

[Codesbyusman]

updated with suggestions and test cases.

[Codesbyusman]

updated test cases and suggestions.

[Codesbyusman]

clang/include/clang/Basic/TokenKinds.def

384

This is technically correct, but I think we should remove it until we go to implement that paper instead of introducing the keyword out of thin air here.

Btw, I think that should be , 0 instead of , KEYC2X given the use of C2X_KEYWORD, right?

Don't know much but what I understand that this is a keyword but not published officially by language but will be in future. so I think will be good to remove it or can add Fixme?

[aaron.ballman]

clang/include/clang/Basic/TokenKinds.def

384

Don't know much but what I understand that this is a keyword but not published officially by language but will be in future. so I think will be good to remove it or can add Fixme?

Close -- the issue is more that we have no support for remove_quals in the compiler and it's easier for someone to add the keyword when implementing that feature. So you should remove the line entirely -- someone else will add it in the future.

clang/lib/Basic/IdentifierTable.cpp

852

It looks like you might have missed this comment.

863

It looks like you might have missed this comment (it's about Checking the Language mode and then for the diagnostics.)

clang/test/Parser/static_assert.c

1 ↗

(On Diff #455147)

Why did you add -Weverything here? That seems odd.

23 ↗

(On Diff #455147)

[Codesbyusman]

clang/test/Parser/static_assert.c

1 ↗

(On Diff #455147)

Why did you add -Weverything here? That seems odd.

Totally unintentional. I was initially exploring something. will fix this. Thank you for pointing out.

[Codesbyusman]

updated

[aaron.ballman]

I spotted one last (hopefully) concern, but otherwise this LG for functionality. Can you also add a release note for the improved diagnostic behavior?

clang/include/clang/Basic/TokenKinds.def

381–383

I'm very sorry for not noticing this until the last minute, but I think all three of these should be using KEYWORD instead of C2X_KEYWORD. We set the value for BOOLSUPPORT properly for C2x: https://github.com/llvm/llvm-project/blob/main/clang/lib/Basic/LangOptions.cpp#L196 so that should be a no-op change.

(Otherwise, it looks like these are C2x keywords but not C++ keywords, which seems rather strange)

[Codesbyusman]

updated.

[aaron.ballman]

LGTM! There's a minor thing left to be fixed, but I'll handle it on commit. I wanted to drop the |KEYC2X for the Boolean keywords so it relies solely on BOOLSUPPORT, but then I realized we could just use the correct flags instead of using BOOLSUPPORT at all.

clang/include/clang/Basic/DiagnosticLexKinds.td

 
 def ext_token_used : Extension<"extension used">,
   InGroup<DiagGroup<"language-extension-token">>;
 
 def warn_cxx11_keyword : Warning<"'%0' is a keyword in C++11">,
   InGroup<CXX11Compat>, DefaultIgnore;
 def warn_cxx20_keyword : Warning<"'%0' is a keyword in C++20">,
   InGroup<CXX20Compat>, DefaultIgnore;
+def warn_c99_keyword : Warning<"'%0' is a keyword in C99">,
+  InGroup<C99Compat>, DefaultIgnore;
+def warn_c23_keyword : Warning<"'%0' is a keyword in C23">,
+  InGroup<CPre2xCompat>, DefaultIgnore;
 
 def ext_unterminated_char_or_string : ExtWarn<
   "missing terminating %select{'|'\"'}0 character">, InGroup<InvalidPPToken>;
 def ext_empty_character : ExtWarn<"empty character constant">,
   InGroup<InvalidPPToken>;
 def err_unterminated_block_comment : Error<"unterminated /* comment">;
 def err_invalid_character_to_charify : Error<
   "invalid argument to convert to character">;

clang/include/clang/Basic/TokenKinds.def

 #define TESTING_KEYWORD(X, L) KEYWORD(X, L)
 #endif
 #ifndef ANNOTATION
 #define ANNOTATION(X) TOK(annot_ ## X)
 #endif
 #ifndef PRAGMA_ANNOTATION
 #define PRAGMA_ANNOTATION(X) ANNOTATION(X)
 #endif
+#ifndef C99_KEYWORD
+#define C99_KEYWORD(X,Y) KEYWORD(X,KEYC99|(Y))
+#endif
+#ifndef C23_KEYWORD
+#define C23_KEYWORD(X,Y) KEYWORD(X,KEYC23|(Y))
+#endif
 
 //===----------------------------------------------------------------------===//
 // Preprocessor keywords.
 //===----------------------------------------------------------------------===//
 
 // These have meaning after a '#' at the start of a line. These define enums in
 // the tok::pp_* namespace.  Note that IdentifierInfo::getPPKeywordID must be
 // manually updated if something is added here.

 
 // C99 6.4.1: Keywords.  These turn into kw_* tokens.
 // Flags allowed:
 //   KEYALL   - This is a keyword in all variants of C and C++, or it
 //              is a keyword in the implementation namespace that should
 //              always be treated as a keyword
 //   KEYC99   - This is a keyword introduced to C in C99
 //   KEYC11   - This is a keyword introduced to C in C11
+//   KEYC23   - This is a keyword introduced to C in C23
 //   KEYCXX   - This is a C++ keyword, or a C++-specific keyword in the
 //              implementation namespace
 //   KEYNOCXX - This is a keyword in every non-C++ dialect.
 //   KEYCXX11 - This is a C++ keyword introduced to C++ in C++11
 //   KEYCXX20 - This is a C++ keyword introduced to C++ in C++20
 //   KEYMODULES - This is a keyword if the C++ extensions for modules
 //                are enabled.
 //   KEYGNU   - This is a keyword if GNU extensions are enabled

 KEYWORD(double                      , KEYALL)
 KEYWORD(else                        , KEYALL)
 KEYWORD(enum                        , KEYALL)
 KEYWORD(extern                      , KEYALL)
 KEYWORD(float                       , KEYALL)
 KEYWORD(for                         , KEYALL)
 KEYWORD(goto                        , KEYALL)
 KEYWORD(if                          , KEYALL)
-KEYWORD(inline                      , KEYC99|KEYCXX|KEYGNU)
 KEYWORD(int                         , KEYALL)
 KEYWORD(_ExtInt                     , KEYALL)
 KEYWORD(_BitInt                     , KEYALL)
 KEYWORD(long                        , KEYALL)
 KEYWORD(register                    , KEYALL)
-KEYWORD(restrict                    , KEYC99)
 KEYWORD(return                      , KEYALL)
 KEYWORD(short                       , KEYALL)
 KEYWORD(signed                      , KEYALL)
 UNARY_EXPR_OR_TYPE_TRAIT(sizeof, SizeOf, KEYALL)
 KEYWORD(static                      , KEYALL)
 KEYWORD(struct                      , KEYALL)
 KEYWORD(switch                      , KEYALL)
 KEYWORD(typedef                     , KEYALL)

 KEYWORD(_Thread_local               , KEYALL)
 KEYWORD(__func__                    , KEYALL)
 KEYWORD(__objc_yes                  , KEYALL)
 KEYWORD(__objc_no                   , KEYALL)
 
 
 // C++ 2.11p1: Keywords.
 KEYWORD(asm                         , KEYCXX|KEYGNU)
-KEYWORD(bool                        , BOOLSUPPORT)
 KEYWORD(catch                       , KEYCXX)
 KEYWORD(class                       , KEYCXX)
 KEYWORD(const_cast                  , KEYCXX)
 KEYWORD(delete                      , KEYCXX)
 KEYWORD(dynamic_cast                , KEYCXX)
 KEYWORD(explicit                    , KEYCXX)
 KEYWORD(export                      , KEYCXX)
-KEYWORD(false                       , BOOLSUPPORT)
 KEYWORD(friend                      , KEYCXX)
 KEYWORD(mutable                     , KEYCXX)
 KEYWORD(namespace                   , KEYCXX)
 KEYWORD(new                         , KEYCXX)
 KEYWORD(operator                    , KEYCXX)
 KEYWORD(private                     , KEYCXX)
 KEYWORD(protected                   , KEYCXX)
 KEYWORD(public                      , KEYCXX)
 KEYWORD(reinterpret_cast            , KEYCXX)
 KEYWORD(static_cast                 , KEYCXX)
 KEYWORD(template                    , KEYCXX)
 KEYWORD(this                        , KEYCXX)
 KEYWORD(throw                       , KEYCXX)
-KEYWORD(true                        , BOOLSUPPORT)
 KEYWORD(try                         , KEYCXX)
 KEYWORD(typename                    , KEYCXX)
 KEYWORD(typeid                      , KEYCXX)
 KEYWORD(using                       , KEYCXX)
 KEYWORD(virtual                     , KEYCXX)
 KEYWORD(wchar_t                     , WCHARSUPPORT)
 
 // C++ 2.5p2: Alternative Representations.
 CXX_KEYWORD_OPERATOR(and     , ampamp)
 CXX_KEYWORD_OPERATOR(and_eq  , ampequal)
 CXX_KEYWORD_OPERATOR(bitand  , amp)
 CXX_KEYWORD_OPERATOR(bitor   , pipe)
 CXX_KEYWORD_OPERATOR(compl   , tilde)
 CXX_KEYWORD_OPERATOR(not     , exclaim)
 CXX_KEYWORD_OPERATOR(not_eq  , exclaimequal)
 CXX_KEYWORD_OPERATOR(or      , pipepipe)
 CXX_KEYWORD_OPERATOR(or_eq   , pipeequal)
 CXX_KEYWORD_OPERATOR(xor     , caret)
 CXX_KEYWORD_OPERATOR(xor_eq  , caretequal)
 
+// C99 Keywords.
+C99_KEYWORD(restrict                    , 0)
+C99_KEYWORD(inline                      , KEYCXX|KEYGNU)
+
+// C23 Keywords.
+C23_KEYWORD(bool                        , BOOLSUPPORT)
+C23_KEYWORD(false                       , BOOLSUPPORT)
+C23_KEYWORD(true                        , BOOLSUPPORT)
+C23_KEYWORD(remove_quals                , 0)
+
 // C++11 keywords
-CXX11_KEYWORD(alignas               , 0)
+CXX11_KEYWORD(alignas               , KEYC23)
 // alignof and _Alignof return the required ABI alignment
-CXX11_UNARY_EXPR_OR_TYPE_TRAIT(alignof, AlignOf, 0)
+CXX11_UNARY_EXPR_OR_TYPE_TRAIT(alignof, AlignOf, KEYC23)
 CXX11_KEYWORD(char16_t              , KEYNOMS18)
 CXX11_KEYWORD(char32_t              , KEYNOMS18)
 CXX11_KEYWORD(constexpr             , 0)
 CXX11_KEYWORD(decltype              , 0)
 CXX11_KEYWORD(noexcept              , 0)
 CXX11_KEYWORD(nullptr               , 0)
-CXX11_KEYWORD(static_assert         , KEYMSCOMPAT)
-CXX11_KEYWORD(thread_local          , 0)
+CXX11_KEYWORD(static_assert         , KEYMSCOMPAT|KEYC23)
+CXX11_KEYWORD(thread_local          , KEYC23)
 
 // C++20 / coroutines TS keywords
 COROUTINES_KEYWORD(co_await)
 COROUTINES_KEYWORD(co_return)
 COROUTINES_KEYWORD(co_yield)
 
 // C++ modules TS keywords
 MODULES_KEYWORD(module)

 KEYWORD(__label__                   , KEYALL)
 KEYWORD(__real                      , KEYALL)
 KEYWORD(__thread                    , KEYALL)
 KEYWORD(__FUNCTION__                , KEYALL)
 KEYWORD(__PRETTY_FUNCTION__         , KEYALL)
 KEYWORD(__auto_type                 , KEYALL)
 
 // GNU Extensions (outside impl-reserved namespace)
-KEYWORD(typeof                      , KEYGNU)
+KEYWORD(typeof                      , KEYGNU|KEYC23)
 
 // MS Extensions
 KEYWORD(__FUNCDNAME__               , KEYMS)
 KEYWORD(__FUNCSIG__                 , KEYMS)
 KEYWORD(L__FUNCTION__               , KEYMS)
 KEYWORD(L__FUNCSIG__                , KEYMS)
 TYPE_TRAIT_1(__is_interface_class, IsInterfaceClass, KEYMS)
 TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS)

 #undef TYPE_TRAIT_2
 #undef TYPE_TRAIT_1
 #undef TYPE_TRAIT
 #undef CXX20_KEYWORD
 #undef CXX11_KEYWORD
 #undef KEYWORD
 #undef PUNCTUATOR
 #undef TOK
+#undef C99_KEYWORD
+#undef C23_KEYWORD

clang/lib/Basic/IdentifierTable.cpp

enum TokenKey : unsigned {
     KEYCXX11      = 0x4,
     KEYGNU        = 0x8,
     KEYMS         = 0x10,
     BOOLSUPPORT   = 0x20,
     KEYALTIVEC    = 0x40,
     KEYNOCXX      = 0x80,
     KEYBORLAND    = 0x100,
     KEYOPENCLC    = 0x200,
     KEYC11        = 0x400,
     KEYNOMS18     = 0x800,
     KEYNOOPENCL   = 0x1000,
     WCHARSUPPORT  = 0x2000,
     HALFSUPPORT   = 0x4000,
     CHAR8SUPPORT  = 0x8000,
     KEYOBJC       = 0x10000,
     KEYZVECTOR    = 0x20000,
     KEYCOROUTINES = 0x40000,
     KEYMODULES    = 0x80000,
     KEYCXX20      = 0x100000,
     KEYOPENCLCXX  = 0x200000,
     KEYMSCOMPAT   = 0x400000,
     KEYSYCL       = 0x800000,
-    KEYCUDA       = 0x1000000,
+    KEYC23        = 0x1000000,
+    KEYCUDA       = 0x2000000,
     KEYMAX        = KEYCUDA, // The maximum key
     KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX20,
     KEYALL = (KEYMAX | (KEYMAX-1)) & ~KEYNOMS18 &
              ~KEYNOOPENCL // KEYNOMS18 and KEYNOOPENCL are used to exclude.
   };
 
   /// How a keyword is treated in the selected standard. This enum is ordered
   /// intentionally so that the value that 'wins' is the most 'permissive'.

 static KeywordStatus getKeywordStatusHelper(const LangOptions &LangOpts,
                                             TokenKey Flag) {
   // Flag is a single bit version of TokenKey (that is, not
   // KEYALL/KEYALLCXX/etc), so we can check with == throughout this function.
   assert((Flag & ~(Flag - 1)) == Flag && "Multiple bits set?");
 
   switch (Flag) {
   case KEYC99:
-    // FIXME: This should have KS_Future logic here, but that can only happen if
-    // getFutureCompatDiagKind ALSO gets updated. This is safe, since C mode is
-    // ALWAYS implied.
-    return LangOpts.C99 ? KS_Enabled : KS_Unknown;
+    if(LangOpts.C99)
+      return KS_Enabled;
+    return !LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
   case KEYC11:
-    // FIXME: This should have KS_Future logic here, but that can only happen if
-    // getFutureCompatDiagKind ALSO gets updated. This is safe, since C mode is
-    // ALWAYS implied.
-    return LangOpts.C11 ? KS_Enabled : KS_Unknown;
+    if(LangOpts.C11)
+      return KS_Enabled;
+    return !LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
+  case KEYC23:
+    if (LangOpts.C2x)
+      return KS_Enabled;
+    return !LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
   case KEYCXX:
     return LangOpts.CPlusPlus ? KS_Enabled : KS_Unknown;
   case KEYCXX11:
     if (LangOpts.CPlusPlus11)
       return KS_Enabled;
     return LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
   case KEYCXX20:
     if (LangOpts.CPlusPlus20)
case NullabilityKind::NullableResult:
     assert(!isContextSensitive &&
            "_Nullable_result isn't supported as context-sensitive keyword");
     return "_Nullable_result";
 
   case NullabilityKind::Unspecified:
     return isContextSensitive ? "null_unspecified" : "_Null_unspecified";
   }
   llvm_unreachable("Unknown nullability kind.");
 }

clang/lib/Lex/Preprocessor.cpp

static diag::kind getFutureCompatDiagKind(const IdentifierInfo &II,
 
   if (LangOpts.CPlusPlus)
     return llvm::StringSwitch<diag::kind>(II.getName())
 #define CXX11_KEYWORD(NAME, FLAGS)                                             \
         .Case(#NAME, diag::warn_cxx11_keyword)
 #define CXX20_KEYWORD(NAME, FLAGS)                                             \
         .Case(#NAME, diag::warn_cxx20_keyword)
 #include "clang/Basic/TokenKinds.def"
         // char8_t is not modeled as a CXX20_KEYWORD because it's not
         // unconditionally enabled in C++20 mode. (It can be disabled
         // by -fno-char8_t.)
         .Case("char8_t", diag::warn_cxx20_keyword)
         ;
 
+  if (!LangOpts.CPlusPlus)
+    return llvm::StringSwitch<diag::kind>(II.getName())
+#define C99_KEYWORD(NAME, FLAGS) .Case(#NAME, diag::warn_c99_keyword)
+#define C23_KEYWORD(NAME, FLAGS) .Case(#NAME, diag::warn_c23_keyword)
+#define CXX11_KEYWORD(NAME, FLAGS) .Case(#NAME, diag::warn_c23_keyword)
+#include "clang/Basic/TokenKinds.def"
+        .Case("typeof", diag::warn_c23_keyword);
+
   llvm_unreachable(
       "Keyword not known to come from a newer Standard or proposed Standard");
 }
 
 void Preprocessor::updateOutOfDateIdentifier(IdentifierInfo &II) const {
   assert(II.isOutOfDate() && "not out of date");
   getExternalSource()->updateOutOfDateIdentifier(II);
 }
bool Preprocessor::HandleIdentifier(Token &Identifier) {
   }
 
   // If this identifier is a keyword in a newer Standard or proposed Standard,
   // produce a warning. Don't warn if we're not considering macro expansion,
   // since this identifier might be the name of a macro.
   // FIXME: This warning is disabled in cases where it shouldn't be, like
   //   "#define constexpr constexpr", "int constexpr;"
   if (II.isFutureCompatKeyword() && !DisableMacroExpansion) {
     Diag(Identifier, getFutureCompatDiagKind(II, getLangOpts()))
         << II.getName();
     // Don't diagnose this keyword again in this translation unit.
     II.setIsFutureCompatKeyword(false);
   }
 
   // If this is an extension token, diagnose its use.
   // We avoid diagnosing tokens that originate from macro definitions.
   // FIXME: This warning is disabled in cases where it shouldn't be,