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

390–391

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

382

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

780

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

390–391

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

382

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

780

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

382

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

780

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

85

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

clang/lib/Basic/IdentifierTable.cpp

844

This comment block shouldn't be here at all.

855

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

866

This comment isn't helpful.

876

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

clang/include/clang/Basic/TokenKinds.def

88–89

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

90–91

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

847

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

clang/test/Parser/static_assert.c

18–24

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

256

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

844

It looks like you might have missed this comment.

855

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–2

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

23

[Codesbyusman]

clang/test/Parser/static_assert.c

1–2

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/docs/ReleaseNotes.rst

- ``-Wincompatible-function-pointer-types`` now defaults to an error in all C
   language modes. It may be downgraded to a warning with
   ``-Wno-error=incompatible-function-pointer-types`` or disabled entirely with
   ``-Wno-implicit-function-pointer-types``.
 - Clang will now print more information about failed static assertions. In
   particular, simple static assertion expressions are evaluated to their
   compile-time value and printed out if the assertion fails.
 - Diagnostics about uninitialized ``constexpr`` varaibles have been improved
   to mention the missing constant initializer.
+- Correctly diagnose a future keyword if it exist as a keyword in the higher
+  language version and specifies in which version it will be a keyword. This
+  supports both c and c++ language.
+
+ Non-comprehensive list of changes in this release
+ -------------------------------------------------
+
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
 New Compiler Flags
 ------------------
 
 Deprecated Compiler Flags

clang/include/clang/Basic/DiagnosticGroups.td

 def NullConversion : DiagGroup<"null-conversion">;
 def ImplicitConversionFloatingPointToBool :
   DiagGroup<"implicit-conversion-floating-point-to-bool">;
 def ObjCLiteralConversion : DiagGroup<"objc-literal-conversion">;
 def MacroRedefined : DiagGroup<"macro-redefined">;
 def BuiltinMacroRedefined : DiagGroup<"builtin-macro-redefined">;
 def BuiltinRequiresHeader : DiagGroup<"builtin-requires-header">;
 def C99Compat : DiagGroup<"c99-compat">;
+def C2xCompat : DiagGroup<"c2x-compat">;
 def CXXCompat: DiagGroup<"c++-compat">;
 def ExternCCompat : DiagGroup<"extern-c-compat">;
 def KeywordCompat : DiagGroup<"keyword-compat">;
 def GNUCaseRange : DiagGroup<"gnu-case-range">;
 def CastAlign : DiagGroup<"cast-align">;
 def CastQual : DiagGroup<"cast-qual">;
 def : DiagGroup<"char-align">;
 def Comment : DiagGroup<"comment">;

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_c2x_keyword : Warning<"'%0' is a keyword in C2x">,
+  InGroup<C2xCompat>, 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/IdentifierTable.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
 #define LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/TokenKinds.h"
+#include "clang/Lex/LexDiagnostic.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
public:
 
   /// Print some statistics to stderr that indicate how well the
   /// hashing is doing.
   void PrintStats() const;
 
   /// Populate the identifier table with info about the language keywords
   /// for the language specified by \p LangOpts.
   void AddKeywords(const LangOptions &LangOpts);
+
+  /// Returns the correct diagnostic to issue for a future-compat diagnostic
+  /// warning. Note, this function assumes the identifier passed has already
+  /// been determined to be a future compatible keyword.
+  diag::kind getFutureCompatDiagKind(const IdentifierInfo &II,
+                                     const LangOptions &LangOpts);
 };
 
 /// A family of Objective-C methods.
 ///
 /// These families have no inherent meaning in the language, but are
 /// nonetheless central enough in the existing implementations to
 /// merit direct AST support.  While, in theory, arbitrary methods can
 /// be considered to form families, we focus here on the methods

clang/include/clang/Basic/TokenKinds.def

 #define KEYWORD(X,Y) TOK(kw_ ## X)
 #endif
 #ifndef CXX11_KEYWORD
 #define CXX11_KEYWORD(X,Y) KEYWORD(X,KEYCXX11|(Y))
 #endif
 #ifndef CXX20_KEYWORD
 #define CXX20_KEYWORD(X,Y) KEYWORD(X,KEYCXX20|(Y))
 #endif
+#ifndef C99_KEYWORD
+#define C99_KEYWORD(X,Y) KEYWORD(X,KEYC99|(Y))
+#endif
 #ifndef COROUTINES_KEYWORD
 #define COROUTINES_KEYWORD(X) CXX20_KEYWORD(X,KEYCOROUTINES)
 #endif
 #ifndef MODULES_KEYWORD
 #define MODULES_KEYWORD(X) KEYWORD(X,KEYMODULES)
 #endif
 #ifndef TYPE_TRAIT
 #define TYPE_TRAIT(N,I,K) KEYWORD(I,K)

 #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
 
 //===----------------------------------------------------------------------===//
 // 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.
 PPKEYWORD(not_keyword)
 
 // C99 6.10.1 - Conditional Inclusion.
 PPKEYWORD(if)
 PPKEYWORD(ifdef)

 
 // 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
+//   KEYC2X   - This is a keyword introduced to C in C2x
 //   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(bool                        , KEYCXX|KEYOPENCLC|KEYOPENCLCXX|KEYC2X)
 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(false                       , KEYCXX|KEYOPENCLC|KEYOPENCLCXX|KEYC2X)
 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(true                        , KEYCXX|KEYOPENCLC|KEYOPENCLCXX|KEYC2X)
 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)
+
+
 // C++11 keywords
-CXX11_KEYWORD(alignas               , 0)
+CXX11_KEYWORD(alignas               , KEYC2X)
 // 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, KEYC2X)
 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|KEYC2X)
+CXX11_KEYWORD(thread_local          , KEYC2X)
 
 // 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|KEYC2X)
 
 // 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

clang/lib/Basic/IdentifierTable.cpp

 // Constants for TokenKinds.def
 namespace {
 
   enum TokenKey : unsigned {
     KEYC99        = 0x1,
     KEYCXX        = 0x2,
     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,
+    KEYALTIVEC    = 0x20,
+    KEYNOCXX      = 0x40,
+    KEYBORLAND    = 0x80,
+    KEYOPENCLC    = 0x100,
+    KEYC2X        = 0x200,
+    KEYNOMS18     = 0x400,
+    KEYNOOPENCL   = 0x800,
+    WCHARSUPPORT  = 0x1000,
+    HALFSUPPORT   = 0x2000,
+    CHAR8SUPPORT  = 0x4000,
+    KEYOBJC       = 0x8000,
+    KEYZVECTOR    = 0x10000,
+    KEYCOROUTINES = 0x20000,
+    KEYMODULES    = 0x40000,
+    KEYCXX20      = 0x80000,
+    KEYOPENCLCXX  = 0x100000,
+    KEYMSCOMPAT   = 0x200000,
+    KEYSYCL       = 0x400000,
+    KEYCUDA       = 0x800000,
     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;
-  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.C99)
+      return KS_Enabled;
+    return !LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
+  case KEYC2X:
+    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)
       return KS_Enabled;
     return LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
   case KEYGNU:
     return LangOpts.GNUKeywords ? KS_Extension : KS_Unknown;
   case KEYMS:
     return LangOpts.MicrosoftExt ? KS_Extension : KS_Unknown;
-  case BOOLSUPPORT:
-    return LangOpts.Bool ? KS_Enabled : KS_Unknown;
   case KEYALTIVEC:
     return LangOpts.AltiVec ? KS_Enabled : KS_Unknown;
   case KEYBORLAND:
     return LangOpts.Borland ? KS_Extension : KS_Unknown;
   case KEYOPENCLC:
     return LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus ? KS_Enabled
                                                         : KS_Unknown;
   case WCHARSUPPORT:
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.");
 }
+
+diag::kind
+IdentifierTable::getFutureCompatDiagKind(const IdentifierInfo &II,
+                                         const LangOptions &LangOpts) {
+  assert(II.isFutureCompatKeyword() && "diagnostic should not be needed");
+
+  unsigned Flags = llvm::StringSwitch<unsigned>(II.getName())
+#define KEYWORD(NAME, FLAGS) .Case(#NAME, FLAGS)
+#include "clang/Basic/TokenKinds.def"
+#undef KEYWORD
+      ;
+
+  if (LangOpts.CPlusPlus) {
+    if ((Flags & KEYCXX11) == KEYCXX11)
+      return diag::warn_cxx11_keyword;
+
+    // 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.)
+    if (((Flags & KEYCXX20) == KEYCXX20) ||
+        ((Flags & CHAR8SUPPORT) == CHAR8SUPPORT))
+      return diag::warn_cxx20_keyword;
+  } else {
+    if ((Flags & KEYC99) == KEYC99)
+      return diag::warn_c99_keyword;
+    if ((Flags & KEYC2X) == KEYC2X)
+      return diag::warn_c2x_keyword;
+  }
+
+  llvm_unreachable(
+      "Keyword not known to come from a newer Standard or proposed Standard");
+}

clang/lib/Lex/Preprocessor.cpp

void Preprocessor::HandlePoisonedIdentifier(Token & Identifier) {
   llvm::DenseMap<IdentifierInfo*,unsigned>::const_iterator it =
     PoisonReasons.find(Identifier.getIdentifierInfo());
   if(it == PoisonReasons.end())
     Diag(Identifier, diag::err_pp_used_poisoned_id);
   else
     Diag(Identifier,it->second) << Identifier.getIdentifierInfo();
 }
 
-/// Returns a diagnostic message kind for reporting a future keyword as
-/// appropriate for the identifier and specified language.
-static diag::kind getFutureCompatDiagKind(const IdentifierInfo &II,
-                                          const LangOptions &LangOpts) {
-  assert(II.isFutureCompatKeyword() && "diagnostic should not be needed");
-
-  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)
-        ;
-
-  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);
 }
 
 /// HandleIdentifier - This callback is invoked when the lexer reads an
 /// identifier.  This callback looks up the identifier in the map and/or
 /// potentially macro expands it or turns it into a named token (like 'for').
 ///
 /// Note that callers of this method are guarded by checking the
 /// IdentifierInfo's 'isHandleIdentifierCase' bit.  If this method changes, the
 /// IdentifierInfo methods that compute these properties will need to change to
 /// match.
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()))
+    Diag(Identifier, getIdentifierTable().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,

clang/lib/Parse/ParseDeclCXX.cpp

assert(Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert) &&
          "Not a static_assert declaration");
 
   // Save the token used for static assertion.
   Token SavedTok = Tok;
 
   if (Tok.is(tok::kw__Static_assert) && !getLangOpts().C11)
     Diag(Tok, diag::ext_c11_feature) << Tok.getName();
   if (Tok.is(tok::kw_static_assert)) {
-    if (!getLangOpts().CPlusPlus)
-      Diag(Tok, diag::ext_ms_static_assert)
-          << FixItHint::CreateReplacement(Tok.getLocation(), "_Static_assert");
-    else
+    if (!getLangOpts().CPlusPlus) {
+      if (!getLangOpts().C2x)
+        Diag(Tok, diag::ext_ms_static_assert) << FixItHint::CreateReplacement(
+            Tok.getLocation(), "_Static_assert");
+    } else
       Diag(Tok, diag::warn_cxx98_compat_static_assert);
   }
 
   SourceLocation StaticAssertLoc = ConsumeToken();
 
   BalancedDelimiterTracker T(*this, tok::l_paren);
   if (T.consumeOpen()) {
     Diag(Tok, diag::err_expected) << tok::l_paren;

clang/test/Lexer/keywords_test.c

 // RUN: %clang_cc1 -std=c99 -E %s -o - | FileCheck --check-prefix=CHECK-NONE %s
 
 // RUN: %clang_cc1 -std=gnu89 -E %s -o - \
 // RUN:     | FileCheck --check-prefix=CHECK-GNU-KEYWORDS %s
 // RUN: %clang_cc1 -std=c99 -fgnu-keywords -E %s -o - \
 // RUN:     | FileCheck --check-prefix=CHECK-GNU-KEYWORDS %s
 // RUN: %clang_cc1 -std=gnu89 -fno-gnu-keywords -E %s -o - \
 // RUN:     | FileCheck --check-prefix=CHECK-NONE %s
 
 // RUN: %clang_cc1 -std=c99 -fms-extensions -fms-compatibility -E %s -o - \
 // RUN:     | FileCheck --check-prefix=CHECK-MS-KEYWORDS %s
 // RUN: %clang_cc1 -std=c99 -fdeclspec -E %s -o - \
 // RUN:     | FileCheck --check-prefix=CHECK-DECLSPEC-KEYWORD %s
 // RUN: %clang_cc1 -std=c99 -fms-extensions -fno-declspec -E %s -o - \
 // RUN:     | FileCheck --check-prefix=CHECK-MS-KEYWORDS-WITHOUT-DECLSPEC %s
 
+// RUN: %clang_cc1 -std=c99 -DC99 -fsyntax-only %s
+// RUN: %clang_cc1 -std=c2x -DC99 -DC2x -fsyntax-only %s
+
+// RUN: %clang_cc1 -fsyntax-only -std=c89 -DFutureKeyword -Wc2x-compat -Wc99-compat -verify=c89 %s
+
+#define IS_KEYWORD(NAME) _Static_assert(!__is_identifier(NAME), #NAME)
+#define NOT_KEYWORD(NAME) _Static_assert(__is_identifier(NAME), #NAME)
+
+#if defined(C99)
+#define C99_KEYWORD(NAME)  IS_KEYWORD(NAME)
+#else
+#define C99_KEYWORD(NAME)  NOT_KEYWORD(NAME)
+#endif
+
+#if defined(C2x)
+#define C2x_KEYWORD(NAME)  IS_KEYWORD(NAME)
+#else
+#define C2x_KEYWORD(NAME)  NOT_KEYWORD(NAME)
+#endif
+
+// C99 Keywords.
+C99_KEYWORD(restrict);
+C99_KEYWORD(inline);
+
+// C2x Keywords.
+C2x_KEYWORD(bool);
+C2x_KEYWORD(true);
+C2x_KEYWORD(false);
+C2x_KEYWORD(static_assert);
+C2x_KEYWORD(typeof);
+C2x_KEYWORD(thread_local);
+C2x_KEYWORD(alignas);
+C2x_KEYWORD(alignof);
+
 void f() {
 // CHECK-NONE: int asm
 // CHECK-GNU-KEYWORDS: asm ("ret" : :)
 #if __is_identifier(asm)
   int asm;
 #else
   asm ("ret" : :);
 #endif

 // CHECK-GNU-KEYWORDS: no_static_assert
 // CHECK-MS-KEYWORDS: has_static_assert
 // CHECK-MS-KEYWORDS-WITHOUT-DECLSPEC: no_static_assert
 #if __is_identifier(static_assert)
 void no_static_assert();
 #else
 void has_static_assert();
 #endif
+
+#ifdef FutureKeyword
+
+  int restrict; // c89-warning {{'restrict' is a keyword in C99}}
+  int inline;  // c89-warning {{'inline' is a keyword in C99}}
+
+  int bool; // c89-warning {{'bool' is a keyword in C2x}}
+  char true; // c89-warning {{'true' is a keyword in C2x}}
+  char false; // c89-warning {{'false' is a keyword in C2x}}
+  float alignof; // c89-warning {{'alignof' is a keyword in C2x}}
+  int typeof; // c89-warning {{'typeof' is a keyword in C2x}}
+  int alignas; // c89-warning {{'alignas' is a keyword in C2x}}
+  int static_assert; // c89-warning {{'static_assert' is a keyword in C2x}}
+
+#endif

clang/test/Lexer/keywords_test.cpp

 // RUN: %clang_cc1 -std=c++03 -fdeclspec -fno-declspec -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fms-extensions -fno-declspec -fdeclspec -DDECLSPEC -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fms-extensions -fdeclspec -fno-declspec -fsyntax-only %s
 // RUN: %clang -std=c++03 -target i686-windows-msvc -DMS -DDECLSPEC -fsyntax-only %s
 // RUN: %clang -std=c++03 -target x86_64-scei-ps4 -DDECLSPEC -fsyntax-only %s
 // RUN: %clang -std=c++03 -target i686-windows-msvc -DMS -fno-declspec -fsyntax-only %s
 // RUN: %clang -std=c++03 -target x86_64-scei-ps4 -fno-declspec -fsyntax-only %s
 
+// RUN: %clang_cc1 -std=c++98 -DFutureKeyword -fsyntax-only -Wc++11-compat -Wc++20-compat -verify=cxx98 %s
+
 #define IS_KEYWORD(NAME) _Static_assert(!__is_identifier(NAME), #NAME)
 #define NOT_KEYWORD(NAME) _Static_assert(__is_identifier(NAME), #NAME)
 #define IS_TYPE(NAME) void is_##NAME##_type() { int f(NAME); }
 
 #if defined(CXX20)
 #define CXX20_KEYWORD(NAME)  IS_KEYWORD(NAME)
 #else
 #define CXX20_KEYWORD(NAME)  NOT_KEYWORD(NAME)

 CXX11_KEYWORD(alignof);
 CXX11_KEYWORD(alignas);
 CXX11_KEYWORD(char16_t);
 CXX11_TYPE(char16_t);
 CXX11_KEYWORD(char32_t);
 CXX11_TYPE(char32_t);
 CXX11_KEYWORD(constexpr);
 CXX11_KEYWORD(noexcept);
+
 #ifndef MS
 CXX11_KEYWORD(static_assert);
 #else
 // MS compiler recognizes static_assert in all modes. So should we.
 IS_KEYWORD(static_assert);
 #endif
+
 CXX11_KEYWORD(thread_local);
 
 // Concepts keywords
 CXX20_KEYWORD(concept);
 CXX20_KEYWORD(requires);
+CXX20_KEYWORD(consteval);
+CXX20_KEYWORD(constinit);
+CXX20_KEYWORD(co_await);
+CXX20_KEYWORD(co_return);
+CXX20_KEYWORD(co_yield);
 
 // __declspec extension
 DECLSPEC_KEYWORD(__declspec);
 
 // Clang extension
 IS_KEYWORD(__char16_t);
 IS_TYPE(__char16_t);
 IS_KEYWORD(__char32_t);
 IS_TYPE(__char32_t);
+
+#ifdef FutureKeyword
+
+int nullptr; // cxx98-warning {{'nullptr' is a keyword in C++11}}
+int decltype;  // cxx98-warning {{'decltype' is a keyword in C++11}}
+int alignof;  // cxx98-warning {{'alignof' is a keyword in C++11}}
+int alignas;  // cxx98-warning {{'alignas' is a keyword in C++11}}
+int char16_t;  // cxx98-warning {{'char16_t' is a keyword in C++11}}
+int char32_t;  // cxx98-warning {{'char32_t' is a keyword in C++11}}
+int constexpr;  // cxx98-warning {{'constexpr' is a keyword in C++11}}
+int noexcept;  // cxx98-warning {{'noexcept' is a keyword in C++11}}
+int static_assert; // cxx98-warning {{'static_assert' is a keyword in C++11}}
+char thread_local; // cxx98-warning {{'thread_local' is a keyword in C++11}}
+
+int co_await; // cxx98-warning {{'co_await' is a keyword in C++20}}
+char co_return; // cxx98-warning {{'co_return' is a keyword in C++20}}
+char co_yield; // cxx98-warning {{'co_yield' is a keyword in C++20}}
+int constinit; // cxx98-warning {{'constinit' is a keyword in C++20}}
+int consteval; // cxx98-warning {{'consteval' is a keyword in C++20}}
+int requires; // cxx98-warning {{'requires' is a keyword in C++20}}
+int concept; // cxx98-warning {{'concept' is a keyword in C++20}}
+
+#endif

clang/test/Parser/static_assert.c

-// RUN: %clang_cc1 -fsyntax-only -std=c2x -DTEST_SPELLING -verify=c2x %s
-// RUN: %clang_cc1 -fsyntax-only -std=c2x -DTEST_SPELLING -fms-compatibility -verify=c2x-ms %s
+// RUN: %clang_cc1 -fsyntax-only -std=c17 -DTEST_SPELLING -Wc2x-compat -verify=c17 %s
+// RUN: %clang_cc1 -fsyntax-only -std=c17 -DTEST_SPELLING -fms-compatibility -verify=c17-ms %s
 // RUN: %clang_cc1 -fsyntax-only -std=c2x -Wpre-c2x-compat -verify=c2x-compat %s
 // RUN: %clang_cc1 -fsyntax-only -std=c99 -verify=c99 %s
 // RUN: %clang_cc1 -fsyntax-only -std=c99 -pedantic -verify=c99-pedantic %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify=cxx17 -x c++ %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++17 -pedantic -verify=cxx17-pedantic -x c++ %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify=cxx98 -x c++ %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -pedantic -verify=cxx98-pedantic -x c++ %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++17 -Wpre-c++17-compat -verify=cxx17-compat -x c++ %s
 
 // cxx17-no-diagnostics
 
 #ifdef TEST_SPELLING
 // Only test the C++ spelling in C mode in some of the tests, to reduce the
 // amount of diagnostics to have to check. This spelling is allowed in MS-
 // compatibility mode in C, but otherwise produces errors.
-static_assert(1, ""); // c2x-error {{expected parameter declarator}} \
-                      // c2x-error {{expected ')'}} \
-                      // c2x-note {{to match this '('}} \
-                      // c2x-error {{a type specifier is required for all declarations}} \
-                      // c2x-ms-warning {{use of 'static_assert' without inclusion of <assert.h> is a Microsoft extension}}
+static_assert(1, ""); // c17-warning {{'static_assert' is a keyword in C2x}} \
+                      // c17-error {{expected parameter declarator}} \
+                      // c17-error {{expected ')'}} \
+                      // c17-note {{to match this '('}} \
+                      // c17-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+                      // c17-ms-warning {{use of 'static_assert' without inclusion of <assert.h> is a Microsoft extension}}
+
 #endif
 
 // We support _Static_assert as an extension in older C modes and in all C++
 // modes, but only as a pedantic warning.
 _Static_assert(1, ""); // c99-pedantic-warning {{'_Static_assert' is a C11 extension}} \
                        // cxx17-pedantic-warning {{'_Static_assert' is a C11 extension}} \
                        // cxx98-pedantic-warning {{'_Static_assert' is a C11 extension}}
 
 // _Static_assert without a message has more complex diagnostic logic:
 //   * In C++17 or C2x mode, it's supported by default.
 //   * But there is a special compat warning flag to warn about portability to
 //     older standards.
 //   * In older standard pedantic modes, warn about supporting without a
 //     message as an extension.
 _Static_assert(1); // c99-pedantic-warning {{'_Static_assert' with no message is a C2x extension}} \
                    // c99-warning {{'_Static_assert' with no message is a C2x extension}} \
                    // cxx98-pedantic-warning {{'static_assert' with no message is a C++17 extension}} \
                    // cxx98-warning {{'static_assert' with no message is a C++17 extension}} \
                    // c2x-compat-warning {{'_Static_assert' with no message is incompatible with C standards before C2x}} \
                    // cxx17-compat-warning {{'static_assert' with no message is incompatible with C++ standards before C++17}} \
                    // c99-pedantic-warning {{'_Static_assert' is a C11 extension}} \
                    // cxx17-pedantic-warning {{'_Static_assert' is a C11 extension}} \
-                   // cxx98-pedantic-warning {{'_Static_assert' is a C11 extension}}
+                   // cxx98-pedantic-warning {{'_Static_assert' is a C11 extension}} \
+                   // c17-warning {{'_Static_assert' with no message is a C2x extension}} \
+                   // c17-ms-warning {{'_Static_assert' with no message is a C2x extension}}