[clang] Adds the -std=c++2c compiler option.

[Mordante]

Summary

This is a preparation of the next version of the ISO C++ Standard.
WG21 will start working on C++26 at their next meeting in June. This
prepares Clang to implement features after they have been voted in. It
also allows other projects like libc++ to prepare their code before the
next meeting.

[h-vetinari]

clang/lib/Frontend/InitPreprocessor.cpp

441–443

This needs to go on line 457ff to C++, not C

[Mordante]

Rebased, updated and addresses review comments.

[Mordante]

clang/lib/Frontend/InitPreprocessor.cpp

441–443

Good catch, I fixed it.

[Mordante]

This patch has accidentally been duplicated in D150450. That version has a few more changes and @erichkeane has integrated the missing clang-cl part.

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``
+
+   ISO C++ Working draft for ISO C++ 2026
+
+  | ``gnu++2c``
+
+   ISO Working draft for ISO C++ 2026 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

 - Clang now ignores null directives outside of the include guard when deciding
   whether a file can be enabled for the multiple-include optimization.
 
 New Compiler Flags
 ------------------
 - The flag ``-std=c++23`` has been added. This behaves the same as the existing
   flag ``-std=c++2b``.
 
+- The flag ``-std=c++2c`` has been added. This compiles C++ code using the
+  Working Draft for ISO C++ 2026.
+
 Deprecated Compiler Flags
 -------------------------
 
 Modified Compiler Flags
 -----------------------
 
 Removed Compiler Flags
 -------------------------

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(CPlusPlus2c       , 1, 0, "C++2c")
 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)
+  CPlusPlus2c = (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; }
 
+  /// isCPlusPlus2c - Language is a post-C++23 variant (or later).
+  bool isCPlusPlus2c() const { return Flags & CPlusPlus2c; }
+
   /// 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; }

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(cxx2c, "c++2c",
+             CXX, "Working draft for ISO C++ 2026 DIS",
+             LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
+             CPlusPlus20 | CPlusPlus23 | CPlusPlus2c | Digraphs | HexFloat)
+
+LANGSTANDARD(gnucxx2c, "gnu++2c",
+             CXX, "Working draft for ISO C++ 2026 DIS with GNU extensions",
+             LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
+             CPlusPlus20 | CPlusPlus23 | CPlusPlus2c | Digraphs | HexFloat | GNUMode)
+
 // 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.CPlusPlus2c = Std.isCPlusPlus2c();
   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++latest"));
+       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))
       CXX20HeaderType = HeaderMode_Default;

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++latest"));
+       Std->containsValue("c++2c") || 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)) {
     bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
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")
+                             .Case("c++latest", "-std=c++2c")
                              .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

static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
   else
     Builder.defineMacro("__STDC_HOSTED__");
 
   //   -- __STDC_VERSION__
   //      [C++] Whether __STDC_VERSION__ is predefined and if so, what its
   //      value is, are implementation-defined.
   // (Removed in C++20.)
   if (!LangOpts.CPlusPlus) {
+    // FIXME: Use correct value for C++26.
+    if (LangOpts.CPlusPlus2c)
+      Builder.defineMacro("__cplusplus", "202401L");
     // FIXME: Use correct value for C23.
-    if (LangOpts.C2x)
+    else if (LangOpts.C2x)
       Builder.defineMacro("__STDC_VERSION__", "202000L");
     else if (LangOpts.C17)
       Builder.defineMacro("__STDC_VERSION__", "201710L");
     else if (LangOpts.C11)
       Builder.defineMacro("__STDC_VERSION__", "201112L");
     else if (LangOpts.C99)
       Builder.defineMacro("__STDC_VERSION__", "199901L");
     else if (!LangOpts.GNUMode && LangOpts.Digraphs)

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++2c
 
 // 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' for 'Working draft for ISO C++ 2026 DIS' standard
+// CHECK-NEXT: note: use 'gnu++2c' for 'Working draft for ISO C++ 2026 DIS 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++2c -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX2C %s
+//
+// CXX2C:#define __GNUG__ 4
+// CXX2C:#define __GXX_EXPERIMENTAL_CXX0X__ 1
+// CXX2C:#define __GXX_RTTI 1
+// CXX2C:#define __GXX_WEAK__ 1
+// CXX2C:#define __cplusplus 202401L
+// CXX2C:#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
 //
 // CXX2B:#define __GNUG__ 4
 // CXX2B:#define __GXX_EXPERIMENTAL_CXX0X__ 1
 // CXX2B:#define __GXX_RTTI 1
 // CXX2B:#define __GXX_WEAK__ 1
 // CXX2B:#define __cplusplus 202101L
 // 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++2c -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX2C %s
+//
+// GXX2C:#define __GNUG__ 4
+// GXX2C:#define __GXX_WEAK__ 1
+// GXX2C:#define __cplusplus 202401L
+// GXX2C:#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
 //
 // GXX2B:#define __GNUG__ 4
 // GXX2B:#define __GXX_WEAK__ 1
 // GXX2B:#define __cplusplus 202101L
 // GXX2B:#define __private_extern__ extern
 //
 // RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++20 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX2A %s