[Clang] Permit static constexpr variables in constexpr functions

[cor3ntin]

Summary

This implement the C++23 paper P2647R1 (adopted in Kona)

[erichkeane]

Can you add some tests that do meaningful things with the static variable? Particularly during constexpr evaluation time?

[cor3ntin]

Add an evaluation test.

[shafik]

clang/test/SemaCXX/constant-expression-cxx2b.cpp

246

Can we also add the test from the proposal as well for completeness sake:

constexpr char test() {
   static const int x = 5;
   static constexpr char c[] = "Hello World";
   return *(c+x);
}
static_assert(' ' == test());

clang/docs/ReleaseNotes.rst

- Do not hide templated base members introduced via using-decl in derived class
   (useful specially for constrained members). Fixes `GH50886 <https://github.com/llvm/llvm-project/issues/50886>`_.
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Support label at end of compound statement (`P2324 <https://wg21.link/p2324r2>`_).
 - Implemented `P1169R4: static operator() <https://wg21.link/P1169R4>`_.
 - Implemented "char8_t Compatibility and Portability Fix" (`P2513R3 <https://wg21.link/P2513R3>`_).
-  This Change was applied to C++20 as a Defect Report.
+  This change was applied to C++20 as a Defect Report.
+- Implemented "Permitting static constexpr variables in constexpr functions" (`P2647R1 <https://wg21.link/P2647R1>_`).
 
 CUDA/HIP Language Changes in Clang
 ----------------------------------
 
  - Allow the use of ``__noinline__`` as a keyword (instead of ``__attribute__((noinline))``)
    in lambda declarations.
 
 Objective-C Language Changes in Clang

clang/lib/AST/ExprConstant.cpp

case ESR_CaseNotFound:
     return ESR_Failed;
   }
   llvm_unreachable("Invalid EvalStmtResult!");
 }
 
 static bool CheckLocalVariableDeclaration(EvalInfo &Info, const VarDecl *VD) {
   // An expression E is a core constant expression unless the evaluation of E
   // would evaluate one of the following: [C++2b] - a control flow that passes
-  // through a declaration of a variable with static or thread storage duration.
-  if (VD->isLocalVarDecl() && VD->isStaticLocal()) {
+  // through a declaration of a variable with static or thread storage duration
+  // unless that variable is usable in constant expressions.
+  if (VD->isLocalVarDecl() && VD->isStaticLocal() &&
+      !VD->isUsableInConstantExpressions(Info.Ctx)) {
     Info.CCEDiag(VD->getLocation(), diag::note_constexpr_static_local)
         << (VD->getTSCSpec() == TSCS_unspecified ? 0 : 1) << VD;
     return false;
   }
   return true;
 }
 
 // Evaluate a statement.

clang/lib/Frontend/InitPreprocessor.cpp

static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
 
   // C++11 features.
   if (LangOpts.CPlusPlus11) {
     Builder.defineMacro("__cpp_unicode_characters", "200704L");
     Builder.defineMacro("__cpp_raw_strings", "200710L");
     Builder.defineMacro("__cpp_unicode_literals", "200710L");
     Builder.defineMacro("__cpp_user_defined_literals", "200809L");
     Builder.defineMacro("__cpp_lambdas", "200907L");
-    Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus2b   ? "202110L"
+    Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus2b   ? "202211L"
                                            : LangOpts.CPlusPlus20 ? "201907L"
                                            : LangOpts.CPlusPlus17 ? "201603L"
                                            : LangOpts.CPlusPlus14 ? "201304L"
                                                                   : "200704");
     Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L");
     Builder.defineMacro("__cpp_range_based_for",
                         LangOpts.CPlusPlus17 ? "201603L" : "200907");
     Builder.defineMacro("__cpp_static_assert",

clang/test/Lexer/cxx-features.cpp

#if defined(NO_THREADSAFE_STATICS) ? check(threadsafe_static_init, 0, 0, 0, 0, 0, 0) : \
                                      check(threadsafe_static_init, 200806, 200806, 200806, 200806, 200806, 200806)
 #error "wrong value for __cpp_threadsafe_static_init"
 #endif
 
 #if check(lambdas, 0, 200907, 200907, 200907, 200907, 200907)
 #error "wrong value for __cpp_lambdas"
 #endif
 
-#if check(constexpr, 0, 200704, 201304, 201603, 201907, 202110)
+#if check(constexpr, 0, 200704, 201304, 201603, 201907, 202211)
 #error "wrong value for __cpp_constexpr"
 #endif
 
 #if check(range_based_for, 0, 200907, 200907, 201603, 201603, 201603)
 #error "wrong value for __cpp_range_based_for"
 #endif
 
 #if check(static_assert, 0, 200410, 200410, 201411, 201411, 201411)

clang/test/SemaCXX/constant-expression-cxx2b.cpp

 // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx2a %s -fcxx-exceptions -triple=x86_64-linux-gnu -Wno-c++2b-extensions
 // RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b %s -fcxx-exceptions -triple=x86_64-linux-gnu -Wpre-c++2b-compat
 
 struct NonLiteral { // cxx2a-note {{'NonLiteral' is not literal}} \
                     // cxx2b-note 2{{'NonLiteral' is not literal}}
   NonLiteral() {}
 };
 
+struct Constexpr{};
+
 #if __cplusplus > 202002L
 
 constexpr int f(int n) {  // expected-error {{constexpr function never produces a constant expression}}
   static const int m = n; // expected-note {{control flows through the definition of a static variable}} \
                           // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
   return m;
 }
 constexpr int g(int n) {        // expected-error {{constexpr function never produces a constant expression}}
thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \
                                 // cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}}
 
   return m;
 }
 
 constexpr int ke = k_evaluated(1); // expected-error {{constexpr variable 'ke' must be initialized by a constant expression}} \
                                    // expected-note {{in call}}
 
-constexpr int static_constexpr() { // expected-error {{constexpr function never produces a constant expression}}
-  static constexpr int m = 42;     // expected-note {{control flows through the definition of a static variable}} \
-                                   // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
+constexpr int static_constexpr() {
+  static constexpr int m = 42;     // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  static constexpr Constexpr foo; // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
   return m;
 }
 
-constexpr int thread_local_constexpr() { // expected-error {{constexpr function never produces a constant expression}}
-  thread_local constexpr int m = 42;     // expected-note {{control flows through the definition of a thread_local variable}} \
-                                         // cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}}
+constexpr int thread_local_constexpr() {
+  thread_local constexpr int m = 42; // cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  thread_local constexpr Constexpr foo; // cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}}
   return m;
 }
 
 constexpr int non_literal(bool b) {
   if (!b)
     return 0;
   NonLiteral n; // cxx2b-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++2b}}
 }

 
 } // namespace eval_goto
 
 #endif
 
 // Test that explicitly constexpr lambdas behave correctly,
 // This is to be contrasted with the test for implicitly constexpr lambdas below.
 int test_in_lambdas() {
-  auto a = []() constexpr {  // expected-error{{constexpr function never produces a constant expression}}
-    static const int m = 32; // expected-note {{control flows through the definition of a static variable}} \
-                             // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  auto a = []() constexpr {
+    static const int m = 32; // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
     return m;
   };
 
   auto b = [](int n) constexpr {
     if (!n)
       return 0;
     static const int m = n; // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
     return m;
if (!b)
       T t;
     return 0;
   };
 }
 
 constexpr auto non_literal_valid_in_cxx2b = dependent_var_def_lambda<NonLiteral>()(true); // \
     // cxx2a-error {{constexpr variable 'non_literal_valid_in_cxx2b' must be initialized by a constant expression}} \
     // cxx2a-note {{non-constexpr function}}
+
+
+constexpr double evaluate_static_constexpr() {
+  struct Constexpr{
+    constexpr double f() const {
+      return 42;
+    }
+  };
+  thread_local constexpr Constexpr t; // cxx2b-warning {{before C++2b}}
+  static constexpr Constexpr s; // cxx2b-warning {{before C++2b}}
+  return t.f() + s.f();
+}
+static_assert(evaluate_static_constexpr() == 84);

clang/www/cxx_status.html

</tr>
     <tr>
       <td>static <code>operator[]</code></td>
       <td><a href="https://wg21.link/P2589R1">P2589R1</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Permitting static constexpr variables in constexpr functions (DR)</td>
       <td><a href="https://wg21.link/P2647R1">P2647R1</a></td>
-      <td class="none" align="center">No</td>
+      <td class="unreleased" align="center">Clang 16</td>
     </tr>
     <tr>
       <td>consteval needs to propagate up (DR)</td>
       <td><a href="https://wg21.link/P2564R3">P2564R3</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Lifetime extension in range-based for loops</td>