Add C++26 compile flags.

[erichkeane]

Summary

Now that we've updated to C++23, we need to add C++26/C++2c command line
flags, as discussed in
https://discourse.llvm.org/t/rfc-lets-just-call-it-c-26-and-forget-about-the-c-2c-business-at-least-internally/70383

[erichkeane]

clang/include/clang/Basic/DiagnosticGroups.td

310

Aaron: note the names of the diag groups: would you prefer this to be c++2c?

clang/include/clang/Basic/LangOptions.def

101

It isn't clear to me what the string here is used to output, so not sure if this should be 2c.

clang/include/clang/Basic/LangStandards.def

170

Note I made the c++26/gnu++26 values an alias, when we come to update this for C++26's release, this will be added to the LANGSTANDARD, and c++2c/gnu++2c should become an ALIAS_DEPR

clang/lib/Frontend/InitPreprocessor.cpp

456

At the moment, I just chose '1 more than c++23', but that hasn't been set yet. Once we have the final value, we should make this 1 more than 23's official value.

clang/www/OpenProjects.html

126

Should this spot in the docs be C++2c?

[cor3ntin]

Similar PR here https://reviews.llvm.org/D149875

clang/docs/ReleaseNotes.rst

114

This should be 2c

clang/lib/Frontend/InitPreprocessor.cpp

456

A value lesser than 202401L seems super confusing to me

clang/www/OpenProjects.html

126

I think so

[cor3ntin]

clang/lib/Frontend/InitPreprocessor.cpp

456

In the DIS __cplusplus is 202302L

[erichkeane]

In D150450#4337858, @cor3ntin wrote:

Similar PR here https://reviews.llvm.org/D149875

Ah! I'd not noticed that one (or maybe someone mentioned it?). If @Mordante wants to take this over/change his to meet our RFC, I'm all for it.

[erichkeane]

Update based on @cor3ntin s feedback.

[Mordante]

In D150450#4337952, @erichkeane wrote:

In D150450#4337858, @cor3ntin wrote:

Similar PR here https://reviews.llvm.org/D149875

Ah! I'd not noticed that one (or maybe someone mentioned it?). If @Mordante wants to take this over/change his to meet our RFC, I'm all for it.

I've mentioned it in https://discourse.llvm.org/t/rfc-lets-just-call-it-c-26-and-forget-about-the-c-2c-business-at-least-internally/70383/3 to avoid duplicated effort.

It seems, as expected. the patches have a large overlap, but you added a bit more of the status page and I updated the clang-cl driver.

I just updated my patch before I saw this update in the mail.

clang/lib/Frontend/InitPreprocessor.cpp

461

Note this has been committed in the draft for N4950.
https://github.com/cplusplus/draft/commit/4e4de1df8ee941255b653b61d0a62050b34cf8c9#diff-1b14eeb3be43fba46b5d0ff51fe0695c9a856544d1f45b1d486f98f5e1b889bf

[erichkeane]

fix init-preprocessor, remove fixme.

[erichkeane]

In D150450#4338034, @Mordante wrote:

In D150450#4337952, @erichkeane wrote:

In D150450#4337858, @cor3ntin wrote:

Similar PR here https://reviews.llvm.org/D149875

Ah! I'd not noticed that one (or maybe someone mentioned it?). If @Mordante wants to take this over/change his to meet our RFC, I'm all for it.

I've mentioned it in https://discourse.llvm.org/t/rfc-lets-just-call-it-c-26-and-forget-about-the-c-2c-business-at-least-internally/70383/3 to avoid duplicated effort.

It seems, as expected. the patches have a large overlap, but you added a bit more of the status page and I updated the clang-cl driver.

I just updated my patch before I saw this update in the mail.

Woops, looks like that was long enough ago I completely forgot about it :)

Completely up to you if you want to just steal my stuff and we can go with your review, or you want to just help me fill in anything I missed here.

[erichkeane]

Added clang-cl versioning as stolen from @Mordante

[Mordante]

In D150450#4338065, @erichkeane wrote:

In D150450#4338034, @Mordante wrote:

In D150450#4337952, @erichkeane wrote:

In D150450#4337858, @cor3ntin wrote:

Similar PR here https://reviews.llvm.org/D149875

Ah! I'd not noticed that one (or maybe someone mentioned it?). If @Mordante wants to take this over/change his to meet our RFC, I'm all for it.

I've mentioned it in https://discourse.llvm.org/t/rfc-lets-just-call-it-c-26-and-forget-about-the-c-2c-business-at-least-internally/70383/3 to avoid duplicated effort.

It seems, as expected. the patches have a large overlap, but you added a bit more of the status page and I updated the clang-cl driver.

I just updated my patch before I saw this update in the mail.

Woops, looks like that was long enough ago I completely forgot about it :)

Completely up to you if you want to just steal my stuff and we can go with your review, or you want to just help me fill in anything I missed here.

No problem. I think it's easier to land this patch instead of me stealing your work.
I mainly care that Clang get C++2c support so I can prepare libc++ for C++2c.

LGTM after clang/test/Driver/cl-options.c is fixed.

clang/lib/Driver/ToolChains/Clang.cpp

6664–6665

The CI will fail in the test clang/test/Driver/cl-options.c
see https://reviews.llvm.org/D149875#change-s8WC0AhDg4dT

clang/test/Preprocessor/init.c

22

I had noticed I missed this too, this landed earlier today D150063.

[erichkeane]

Updated last few things @Mordante mentioned, did a rebase.

[cor3ntin]

LGTM. I'm looking forward to start implementing upcoming proposals

[MaskRay]

clang/docs/ReleaseNotes.rst

114

double backsticks.

[erichkeane]

Added double-backticks, updated the tests for the new __cplusplus entries I changed during review.

[h-vetinari]

clang/include/clang/Basic/LangStandard.h

131

Spuriously removed slash

clang/www/cxx_status.html

1568

The longer this page gets, the more I feel it should be sorted in reverse chronological order of the standard versions. It's bothersome IMO to keep scrolling past almost-fully implemented standards (currently the tables for C++17 & C++20) before getting to see the status of the latest & greatest.

https://en.cppreference.com/w/cpp/compiler_support is sorted in reverse order as well.

[shafik]

clang/lib/Driver/ToolChains/Clang.cpp

6663–6664

[cor3ntin]

clang/www/cxx_status.html

1568

This sounds like an excellent improvement.
Erich, would you rather do that in this pr, or i can submit a different patch afterwards?

[xbolva00]

clang/lib/Frontend/InitPreprocessor.cpp

462

Separate patch / commit?

[aaron.ballman]

clang/docs/CommandGuide/clang.rst

206–210

We shouldn't call it ISO C++ 2026 until it's published by ISO. (I don't have strong opinions about 2c vs 26 in there, but since we need to update it anyway when 26 is released, I figured it'd be easier to find again with 2c.)

clang/docs/ReleaseNotes.rst

114

clang/include/clang/Basic/DiagnosticGroups.td

310

Let's go ahead and add the alias so that either c++2c or c++26 works.

1122

Same here as above.

clang/include/clang/Basic/LangOptions.def

101

The only place this matters is when dumping information about a module file for debugging purposes, so I don't think it's critical this be named 2c.

clang/include/clang/Basic/LangStandard.h

131

clang/include/clang/Basic/LangStandards.def

167

We should probably drop ISO from this as we did above?

clang/lib/Frontend/InitPreprocessor.cpp

460

This value is fine by me, but we should probably coordinate with the GCC folks so we don't wind up with two different values between us.

462

Agreed, the change for C++23 should be done in a separate patch.

clang/www/OpenProjects.html

126

Agreed -- basically, if it's user-facing, it should be 2c, and if it's internal to the project, it should be 26.

clang/www/cxx_status.html

1568

I love the idea, and I think it should be done in a separate patch.

[erichkeane]

clang/docs/CommandGuide/clang.rst

206–210

Ah, I just copied from what we had for C++23 before the flip. But this makes sense, I chose 2c for the reason you mentioned.

clang/lib/Frontend/InitPreprocessor.cpp

460

Email sent to GCC maintainer (aaron copied!).

clang/www/cxx_status.html

1568

Corentin: you're welcome to do it in a different patch, but I like the idea as well!

[Mordante]

clang/docs/CommandGuide/clang.rst

206–210

Note that before D149553 similar wording was used for C++2b "Working draft for ISO C++ 2023".

[erichkeane]

Aarons comments, split 23 changes into a separate patch and rebased.

[erichkeane]

clang/lib/Frontend/InitPreprocessor.cpp

456

GCC is going to go with 202400L, so that is what we're going to do.

460

GCC is going to go with 202400L, so that is what we're going to do.

[erichkeane]

change __cplusplus to match GCC's plan.

[aaron.ballman]

LGTM, thank you Erich!

clang/docs/CommandGuide/clang.rst

Supported values for the C++ language are:
   | ``c++23``
 
    ISO C++ 2023 with amendments
 
   | ``gnu++23``
 
    ISO C++ 2023 with amendments and GNU extensions
 
+  | ``c++2c``
+
+   Working draft for C++2c
+
+  | ``gnu++2c``
+
+   Working draft for C++2c with GNU extensions
+
  The default C++ language standard is ``gnu++17``.
 
  Supported values for the OpenCL language are:
 
   | ``cl1.0``
 
    OpenCL 1.0
 

clang/docs/ReleaseNotes.rst

- Implemented `P2036R3: Change scope of lambda trailing-return-type <https://wg21.link/P2036R3>`_
   expressions and how their types are deduced therein, in all C++ language versions.
 - Implemented partial support for `P2448R2: Relaxing some constexpr restrictions <https://wg21.link/p2448r2>`_
   Explicitly defaulted functions no longer have to be constexpr-compatible but merely constexpr suitable.
   We do not support outside of defaulted special memeber functions the change that constexpr functions no
   longer have to be constexpr compatible but rather support a less restricted requirements for constexpr
   functions. Which include allowing non-literal types as return values and parameters, allow calling of
   non-constexpr functions and constructors.
 
+C++2c Feature Support
+^^^^^^^^^^^^^^^^^^^^^
+- Compiler flags ``-std=c++2c`` and ``-std=gnu++2c`` have been added for experimental C++2c implementation work.
+
 Resolutions to C++ Defect Reports
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Implemented `DR2397 <https://wg21.link/CWG2397>`_ which allows ``auto`` specifier for pointers
   and reference to arrays.
 
 C Language Changes
 ------------------
 - Support for outputs from asm goto statements along indirect edges has been

clang/include/clang/Basic/DiagnosticGroups.td

 def : DiagGroup<"c++98-c++11-c++14-c++17-compat", [CXXPre20Compat]>;
 def CXXPre20CompatPedantic : DiagGroup<"pre-c++20-compat-pedantic",
                                        [CXXPre20Compat]>;
 def : DiagGroup<"c++98-c++11-c++14-c++17-compat-pedantic",
                 [CXXPre20CompatPedantic]>;
 def CXXPre23Compat : DiagGroup<"pre-c++23-compat">;
 def CXXPre23CompatPedantic :
   DiagGroup<"pre-c++23-compat-pedantic", [CXXPre23Compat]>;
+def CXXPre26Compat : DiagGroup<"pre-c++26-compat">;
+def CXXPre26CompatPedantic :
+  DiagGroup<"pre-c++26-compat-pedantic", [CXXPre26Compat]>;
+def : DiagGroup<"pre-c++2c-compat", [CXXPre26Compat]>;
+def : DiagGroup<"pre-c++2c-compat-pedantic", [CXXPre26CompatPedantic]>;
 
 def CXX98CompatBindToTemporaryCopy :
   DiagGroup<"c++98-compat-bind-to-temporary-copy">;
 def CXX98CompatLocalTypeTemplateArgs :
   DiagGroup<"c++98-compat-local-type-template-args">;
 def CXX98CompatUnnamedTypeTemplateArgs :
   DiagGroup<"c++98-compat-unnamed-type-template-args">;
 

 // A warning group for warnings about using C++20 features as extensions in
 // earlier C++ versions.
 def CXX20 : DiagGroup<"c++20-extensions", [CXX20Designator, CXX20Attrs]>;
 
 // A warning group for warnings about using C++23 features as extensions in
 // earlier C++ versions.
 def CXX23 : DiagGroup<"c++23-extensions">;
 
+// A warning group for warnings about using C++26 features as extensions in
+// earlier C++ versions.
+def CXX26 : DiagGroup<"c++26-extensions">;
+
 def : DiagGroup<"c++0x-extensions", [CXX11]>;
 def : DiagGroup<"c++1y-extensions", [CXX14]>;
 def : DiagGroup<"c++1z-extensions", [CXX17]>;
 def : DiagGroup<"c++2a-extensions", [CXX20]>;
 def : DiagGroup<"c++2b-extensions", [CXX23]>;
+def : DiagGroup<"c++2c-extensions", [CXX26]>;
 
 def DelegatingCtorCycles :
   DiagGroup<"delegating-ctor-cycles">;
 
 // A warning group for warnings about using C11 features as extensions.
 def C11 : DiagGroup<"c11-extensions">;
 
 // A warning group for warnings about using C99 features as extensions.

clang/include/clang/Basic/LangOptions.def

 LANGOPT(AsmBlocks         , 1, 0, "Microsoft inline asm blocks")
 LANGOPT(Borland           , 1, 0, "Borland extensions")
 LANGOPT(CPlusPlus         , 1, 0, "C++")
 LANGOPT(CPlusPlus11       , 1, 0, "C++11")
 LANGOPT(CPlusPlus14       , 1, 0, "C++14")
 LANGOPT(CPlusPlus17       , 1, 0, "C++17")
 LANGOPT(CPlusPlus20       , 1, 0, "C++20")
 LANGOPT(CPlusPlus23       , 1, 0, "C++23")
+LANGOPT(CPlusPlus26       , 1, 0, "C++26")
 LANGOPT(ObjC              , 1, 0, "Objective-C")
 BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0,
                "Objective-C auto-synthesized properties")
 BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0,
                "Encoding extended block type signature")
 BENIGN_LANGOPT(EncodeCXXClassTemplateSpec , 1, 0,
                "Fully encode c++ class template specialization")
 BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1,

clang/include/clang/Basic/LangStandard.h

enum LangFeatures {
   C17 = (1 << 3),
   C2x = (1 << 4),
   CPlusPlus = (1 << 5),
   CPlusPlus11 = (1 << 6),
   CPlusPlus14 = (1 << 7),
   CPlusPlus17 = (1 << 8),
   CPlusPlus20 = (1 << 9),
   CPlusPlus23 = (1 << 10),
-  Digraphs = (1 << 11),
-  GNUMode = (1 << 12),
-  HexFloat = (1 << 13),
-  OpenCL = (1 << 14),
-  HLSL = (1 << 15)
+  CPlusPlus26 = (1 << 11),
+  Digraphs = (1 << 12),
+  GNUMode = (1 << 13),
+  HexFloat = (1 << 14),
+  OpenCL = (1 << 15),
+  HLSL = (1 << 16)
 };
 
 /// LangStandard - Information about the properties of a particular language
 /// standard.
 struct LangStandard {
   enum Kind {
 #define LANGSTANDARD(id, name, lang, desc, features) \
     lang_##id,
public:
   bool isCPlusPlus17() const { return Flags & CPlusPlus17; }
 
   /// isCPlusPlus20 - Language is a C++20 variant (or later).
   bool isCPlusPlus20() const { return Flags & CPlusPlus20; }
 
   /// isCPlusPlus23 - Language is a post-C++23 variant (or later).
   bool isCPlusPlus23() const { return Flags & CPlusPlus23; }
 
+  /// isCPlusPlus26 - Language is a post-C++26 variant (or later).
+  bool isCPlusPlus26() const { return Flags & CPlusPlus26; }
+
   /// hasDigraphs - Language supports digraphs.
   bool hasDigraphs() const { return Flags & Digraphs; }
 
   /// isGNUMode - Language includes GNU extensions.
   bool isGNUMode() const { return Flags & GNUMode; }
 
   /// hasHexFloats - Language supports hexadecimal float constants.
   bool hasHexFloats() const { return Flags & HexFloat; }
 
   /// isOpenCL - Language is a OpenCL variant.
   bool isOpenCL() const { return Flags & OpenCL; }
 

clang/include/clang/Basic/LangStandards.def

 LANGSTANDARD_ALIAS_DEPR(cxx23, "c++2b")
 
 LANGSTANDARD(gnucxx23, "gnu++23",
              CXX, "ISO C++ 2023 DIS with GNU extensions",
              LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
              CPlusPlus20 | CPlusPlus23 | Digraphs | HexFloat | GNUMode)
 LANGSTANDARD_ALIAS_DEPR(gnucxx23, "gnu++2b")
 
+LANGSTANDARD(cxx26, "c++2c",
+             CXX, "Working draft for C++2c",
+             LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
+             CPlusPlus20 | CPlusPlus23 | CPlusPlus26 | Digraphs | HexFloat)
+LANGSTANDARD_ALIAS(cxx26, "c++26")
+
+LANGSTANDARD(gnucxx26, "gnu++2c",
+             CXX, "Working draft for C++2c with GNU extensions",
+             LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
+             CPlusPlus20 | CPlusPlus23 | CPlusPlus26 | Digraphs | HexFloat | GNUMode)
+LANGSTANDARD_ALIAS(gnucxx26, "gnu++26")
+
 // OpenCL
 LANGSTANDARD(opencl10, "cl1.0",
              OpenCL, "OpenCL 1.0",
              LineComment | C99 | Digraphs | HexFloat | OpenCL)
 LANGSTANDARD_ALIAS_DEPR(opencl10, "cl")
 
 LANGSTANDARD(opencl11, "cl1.1",
              OpenCL, "OpenCL 1.1",

clang/lib/Basic/LangOptions.cpp

void LangOptions::setLangDefaults(LangOptions &Opts, Language Lang,
   Opts.C17 = Std.isC17();
   Opts.C2x = Std.isC2x();
   Opts.CPlusPlus = Std.isCPlusPlus();
   Opts.CPlusPlus11 = Std.isCPlusPlus11();
   Opts.CPlusPlus14 = Std.isCPlusPlus14();
   Opts.CPlusPlus17 = Std.isCPlusPlus17();
   Opts.CPlusPlus20 = Std.isCPlusPlus20();
   Opts.CPlusPlus23 = Std.isCPlusPlus23();
+  Opts.CPlusPlus26 = Std.isCPlusPlus26();
   Opts.GNUMode = Std.isGNUMode();
   Opts.GNUCVersion = 0;
   Opts.HexFloats = Std.hasHexFloats();
   Opts.WChar = Std.isCPlusPlus();
   Opts.Digraphs = Std.hasDigraphs();
 
   Opts.HLSL = Lang == Language::HLSL;
   if (Opts.HLSL && Opts.IncludeDefaultHeader)

clang/lib/Driver/Driver.cpp

Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
   // treating them as PCH, implicit modules or C++20 ones.
   // TODO: inferring the mode like this seems fragile (it meets the objective
   // of not requiring anything new for operation, however).
   const Arg *Std = Args.getLastArg(options::OPT_std_EQ);
   ModulesModeCXX20 =
       !Args.hasArg(options::OPT_fmodules) && Std &&
       (Std->containsValue("c++20") || Std->containsValue("c++2a") ||
        Std->containsValue("c++23") || Std->containsValue("c++2b") ||
+       Std->containsValue("c++26") || Std->containsValue("c++2c") ||
        Std->containsValue("c++latest"));
 
   // Process -fmodule-header{=} flags.
   if (Arg *A = Args.getLastArg(options::OPT_fmodule_header_EQ,
                                options::OPT_fmodule_header)) {
     // These flags force C++20 handling of headers.
     ModulesModeCXX20 = true;
     if (A->getOption().matches(options::OPT_fmodule_header))

clang/lib/Driver/ToolChains/Clang.cpp

static bool RenderModulesOptions(Compilation &C, const Driver &D,
                                  ArgStringList &CmdArgs) {
   bool IsCXX = types::isCXX(Input.getType());
   // FIXME: Find a better way to determine whether the input has standard c++
   // modules support by default.
   bool HaveStdCXXModules =
       IsCXX && Std &&
       (Std->containsValue("c++2a") || Std->containsValue("c++20") ||
        Std->containsValue("c++2b") || Std->containsValue("c++23") ||
+       Std->containsValue("c++2c") || Std->containsValue("c++26") ||
        Std->containsValue("c++latest"));
   bool HaveModules = HaveStdCXXModules;
 
   // -fmodules enables the use of precompiled modules (off by default).
   // Users can pass -fno-cxx-modules to turn off modules support for
   // C++/Objective-C++ programs.
   bool HaveClangModules = false;
   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {

   }
   if (ImplyVCPPCXXVer) {
     StringRef LanguageStandard;
     if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
       Std = StdArg;
       LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
                              .Case("c++14", "-std=c++14")
                              .Case("c++17", "-std=c++17")
                              .Case("c++20", "-std=c++20")
-                             // TODO add c++23 when MSVC supports it.
-                             .Case("c++latest", "-std=c++23")
+                             // TODO add c++23 and c++26 when MSVC supports it.
+                             .Case("c++latest", "-std=c++26")
                              .Default("");
       if (LanguageStandard.empty())
         D.Diag(clang::diag::warn_drv_unused_argument)
             << StdArg->getAsString(Args);
     }
 
     if (LanguageStandard.empty()) {
       if (IsMSVC2015Compatible)

clang/lib/Frontend/InitPreprocessor.cpp

if (!LangOpts.CPlusPlus) {
     else if (LangOpts.C11)
       Builder.defineMacro("__STDC_VERSION__", "201112L");
     else if (LangOpts.C99)
       Builder.defineMacro("__STDC_VERSION__", "199901L");
     else if (!LangOpts.GNUMode && LangOpts.Digraphs)
       Builder.defineMacro("__STDC_VERSION__", "199409L");
   } else {
     //   -- __cplusplus
-    if (LangOpts.CPlusPlus23)
+    if (LangOpts.CPlusPlus26)
+      // FIXME: Use correct value for C++26.
+      Builder.defineMacro("__cplusplus", "202400L");
+    else if (LangOpts.CPlusPlus23)
       Builder.defineMacro("__cplusplus", "202302L");
     //      [C++20] The integer literal 202002L.
     else if (LangOpts.CPlusPlus20)
       Builder.defineMacro("__cplusplus", "202002L");
     //      [C++17] The integer literal 201703L.
     else if (LangOpts.CPlusPlus17)
       Builder.defineMacro("__cplusplus", "201703L");
     //      [C++14] The name __cplusplus is defined to the value 201402L when
     //      compiling a C++ translation unit.
     else if (LangOpts.CPlusPlus14)
       Builder.defineMacro("__cplusplus", "201402L");
     //      [C++11] The name __cplusplus is defined to the value 201103L when
     //      compiling a C++ translation unit.

clang/test/Driver/cl-options.c

 
 // RUN: %clang_cl -fmsc-version=1900 -TP -std:c++17 -### -- %s 2>&1 | FileCheck -check-prefix=STDCXX17 %s
 // STDCXX17: -std=c++17
 
 // RUN: %clang_cl -fmsc-version=1900 -TP -std:c++20 -### -- %s 2>&1 | FileCheck -check-prefix=STDCXX20 %s
 // STDCXX20: -std=c++20
 
 // RUN: %clang_cl -fmsc-version=1900 -TP -std:c++latest -### -- %s 2>&1 | FileCheck -check-prefix=STDCXXLATEST %s
-// STDCXXLATEST: -std=c++23
+// STDCXXLATEST: -std=c++26
 
 // RUN: env CL="/Gy" %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=ENV-CL %s
 // ENV-CL: "-ffunction-sections"
 
 // RUN: env CL="/Gy" _CL_="/Gy- -- %s" %clang_cl -### 2>&1 | FileCheck -check-prefix=ENV-_CL_ %s
 // ENV-_CL_-NOT: "-ffunction-sections"
 
 // RUN: env CL="%s" _CL_="%s" not %clang --rsp-quoting=windows -c

clang/test/Driver/unknown-std.cpp

 // CHECK-NEXT: note: use 'c++14' for 'ISO C++ 2014 with amendments' standard
 // CHECK-NEXT: note: use 'gnu++14' for 'ISO C++ 2014 with amendments and GNU extensions' standard
 // CHECK-NEXT: note: use 'c++17' for 'ISO C++ 2017 with amendments' standard
 // CHECK-NEXT: note: use 'gnu++17' for 'ISO C++ 2017 with amendments and GNU extensions' standard
 // CHECK-NEXT: note: use 'c++20' for 'ISO C++ 2020 DIS' standard
 // CHECK-NEXT: note: use 'gnu++20' for 'ISO C++ 2020 DIS with GNU extensions' standard
 // CHECK-NEXT: note: use 'c++23' for 'ISO C++ 2023 DIS' standard
 // CHECK-NEXT: note: use 'gnu++23' for 'ISO C++ 2023 DIS with GNU extensions' standard
+// CHECK-NEXT: note: use 'c++2c' or 'c++26' for 'Working draft for C++2c' standard
+// CHECK-NEXT: note: use 'gnu++2c' or 'gnu++26' for 'Working draft for C++2c with GNU extensions' standard
 // CUDA-NEXT: note: use 'cuda' for 'NVIDIA CUDA(tm)' standard
 
 // Make sure that no other output is present.
 // CHECK-NOT: {{^.+$}}
 

clang/test/Preprocessor/init.c

 // RUN: %clang_cc1 -E -dM -x assembler-with-cpp < /dev/null | FileCheck -match-full-lines -check-prefix ASM %s
 //
 // ASM:#define __ASSEMBLER__ 1
 //
 //
 // RUN: %clang_cc1 -fblocks -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix BLOCKS %s
 //
 // BLOCKS:#define __BLOCKS__ 1
 // BLOCKS:#define __block __attribute__((__blocks__(byref)))
 //
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++26 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX26 %s
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++2c -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX26 %s
+//
+// CXX26:#define __GNUG__ 4
+// CXX26:#define __GXX_EXPERIMENTAL_CXX0X__ 1
+// CXX26:#define __GXX_RTTI 1
+// CXX26:#define __GXX_WEAK__ 1
+// CXX26:#define __cplusplus 202402L
+// CXX26:#define __private_extern__ extern
 //
 // RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++23 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX2B %s
 // RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++2b -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX2B %s
 //
 // CXX2B:#define __GNUG__ 4
 // CXX2B:#define __GXX_EXPERIMENTAL_CXX0X__ 1
 // CXX2B:#define __GXX_RTTI 1
 // CXX2B:#define __GXX_WEAK__ 1
 // CXX2B:#define __cplusplus 202302L
 // CXX2B:#define __private_extern__ extern
 //

 // RUN: %clang_cc1 -E -dM -triple=x86_64-apple-darwin < /dev/null | FileCheck -match-full-lines -check-prefix C-DEFAULT %s
 // RUN: %clang_cc1 -E -dM -triple=armv7a-apple-darwin < /dev/null | FileCheck -match-full-lines -check-prefix C-DEFAULT %s
 //
 // C-DEFAULT:#define __STDC_VERSION__ 201710L
 //
 // RUN: %clang_cc1 -ffreestanding -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix FREESTANDING %s
 // FREESTANDING:#define __STDC_HOSTED__ 0
 //
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++26 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX26 %s
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++2c -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX26 %s
+//
+// GXX26:#define __GNUG__ 4
+// GXX26:#define __GXX_WEAK__ 1
+// GXX26:#define __cplusplus 202402L
+// GXX26:#define __private_extern__ extern
+//
 // RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++23 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX2B %s
 // RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++2b -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX2B %s
 //
 // GXX2B:#define __GNUG__ 4
 // GXX2B:#define __GXX_WEAK__ 1
 // GXX2B:#define __cplusplus 202302L
 // GXX2B:#define __private_extern__ extern
 //

clang/www/OpenProjects.html

<ul>
   <li>Improve parser reliability and error generation by automatically
   or randomly changing the input checking that clang doesn't crash and
   that it doesn't generate excessive errors for small input
   changes. Manipulating the input at both the text and token levels is
   likely to produce interesting test cases.
 </ul>
 </li>
 
-<li><b>Continue work on C++20, C++23, and C2x support</b>:
+<li><b>Continue work on C++20, C++23, C++2c, and C2x support</b>:
   There are still several C++20 features to complete, and work has begun on
   supporting the latest language standards. Please see the
   <a href="cxx_status.html">C++ status report page</a> to find out what is
   missing.</li>
 
 <li><b>StringRef'ize APIs</b>: A thankless but incredibly useful project is
 StringRef'izing (converting to use <tt>llvm::StringRef</tt> instead of <tt>const
 char *</tt> or <tt>std::string</tt>) various clang interfaces. This generally

clang/www/cxx_status.html

  <td><tt>-std=c++20</tt></td>
  <td class="partial" align="center">Partial</td>
 </tr>
 <tr>
  <td><a href="#cxx23">C++23</a></td>
  <td><tt>-std=c++23</tt></td>
  <td class="partial" align="center">Partial</td>
 </tr>
+<tr>
+ <td><a href="#cxx26">C++2c</a></td>
+ <td><tt>-std=c++2c</tt></td>
+ <td class="partial" align="center">Partial</td>
+</tr>
 </table>
 
 <p>The Clang community is continually striving to improve C++ standards
 compliance between releases by submitting and tracking <a
 href="cxx_dr_status.html">C++ Defect Reports</a> and implementing resolutions
 as they become available.</p>
 
 <p>Experimental work is also under way to implement <a href="#ts">C++ Technical
</tr>
     <tr>
       <td>Referencing The Unicode Standard</td>
       <td><a href="https://wg21.link/P2736R2">P2736R2</a></td>
       <td class="full" align="center">Yes</td>
     </tr>
 </table>
 </details>
 
+<h2 id="cxx26">C++2c implementation status</h2>
+
+<!-- TODO add link to the ISO Standard after it's published. -->
+<p>Clang has support for some of the features of the C++ standard following
+C++23, informally referred to as C++26.</p>
+
+<p>You can use Clang in C++2c mode with the <code>-std=c++2c</code> option.</p>
+
+<details open>
+<summary>List of features and minimum Clang version with support</summary>
+<table width="689" border="1" cellspacing="0">
+ <tr>
+    <th>Language Feature</th>
+    <th>C++26 Proposal</th>
+    <th>Available in Clang?</th>
+ </tr>
+ </table>
+ </details>
+
 <h2 id="dr">Defect reports</h2>
 
 <p>Clang generally aims to implement resolutions to Defect Reports (bug fixes
 against prior standards) retroactively, in all prior standard versions where
 the fix is meaningful. Significant Defect Report changes to language features
 after the publication of the relevant standard are marked (DR) in the above
 table.</p>