[Clang][C++2b] P2242R3: Non-literal variables [...] in constexpr

[cor3ntin]

Summary

Allow goto, labelled statements as well as static, thread_local, and
non-literal variables in constexpr functions.

As specified. for all of the above (except labelled statements) constant
evaluation of the construct still fails.

For constexpr bodies, the proposal is implemented with diagnostics as
a language extension in older language modes. For determination of
whether a lambda body satisfies the requirements for a constexpr
function, the proposal is implemented only in C++2b mode to retain the
semantics of older modes for programs conforming to them.

[hubert.reinterpretcast]

@aaron.ballman, I haven't had a chance to look at the code in detail yet, but I would like to get on the same page about the error/warning behaviour.

In the older modes, we stay conforming either

• by producing the warning (when we know the user said they wanted the function to be constexpr) and letting the code through or
• by doing what the older document says because a warning is inappropriate at the point of the check and we have no mechanism developed (including for other similar cases) for producing the warning only when semantically significant later.

In C++2b, the -Wc++20-compat warning is produced for the places where we warn above and is not produced for the places where we don't warn above.

Considering that the warning would be something like "this function is not implicitly constexpr in C++20 but is so in C++23", and we probably will have a lot of such cases for other reasons, I can buy that people are not interested in such a warning.

clang/test/CXX/basic/basic.types/p10.cpp

23 ↗

(On Diff #400325)

Seems like the only change in this file is drive-by NFC. Can this be pulled out of this patch?

[hubert.reinterpretcast]

In D111400#3376070, @hubert.reinterpretcast wrote:

In C++2b, the -Wc++20-compat warning is produced for the places where we warn above and is not produced for the places where we don't warn above.

I'm not seeing any tests looking for these "incompatible with" messages.

[cor3ntin]

• Rebase
• Update cxx_status as we are now targeting clang 15
• Test the pre-C++2b warnings

[hubert.reinterpretcast]

Noting for myself:
Clang's status quo already has behaviours that are similar to P2242R3 in its C++20 mode despite those behaviours being non-conforming and contributing to binary compat breakage with GCC.
This patch is not responsible for those behaviours, and fixing that status quo is not within the scope of this patch.

Shorter test:

struct NonLit {
  NonLit();
};
template <typename T>
constexpr int foo() {
  return 42;
  T t;
}
int (*f())() {
  const int x = foo<NonLit>();
  auto ff = [] { return x; }; // C++20 should error here; x is odr-used and not captured
  return ff;
}

[hubert.reinterpretcast]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

17

Add a NonLiteral case and a case with a labelled statement and no goto?

38–39

I'm mildly confused over why the error case for the constexpr evaluation appears in this file (which is about the structure of the body) and not in constant-expression-cxx2b.cpp (which is about constant expression evaluation).

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

196–203

The return statement needs to happen before the declaration of the static variable.

354

The abbreviated message snippet might be easy to understand if someone was looking at the diff from this patch, but it would likely be less so if they were just looking at the code later.

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

4–8

Same comment as the thread_local case below. Also, the expected error is missing even if the function is called in a context requiring constant evaluation.

9–13

The implementation generates an error because the return is m and not something like &m - &m.

The wording has:

• a control flow that passes through a declaration of a variable with static or thread storage duration

as one of the things that cannot be evaluated for a constant expression.

The patch does not generate an error on the &m - &m version of the test.

clang/test/SemaCXX/cxx1z-constexpr-lambdas.cpp

118–122 ↗

(On Diff #414880)

Patch does not change the behaviour of this test anymore (and this file does not have a C++2b RUN line). Should keep the test.

[cor3ntin]

Address Hubert's feedback

• Add a diagnostic during constant evaluation when evaluating the declaration of a variable with non-automatic storage duration
• Add more tests
• Restore incorrect removed test (not sure what happened there!)
• Fix some tests
• Reorganize some tests to be in the correct file

[cor3ntin]

clamg-format

[cor3ntin]

Fix test messed up by automatic formatting.

[aaron.ballman]

clang/lib/AST/ExprConstant.cpp

5128–5130

5173–5176

clang/lib/Sema/SemaDeclCXX.cpp

2130

2132–2136

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/dtor.cpp

1

I think we want to keep testing the C++20 behavior and want new tests for the C++2b behavior. We still need to be sure we're correct in C++20 mode given the differences (even in extensions because -pedantic-errors is a thing). So I'd recommend splitting this test into two or using an additional RUN line.

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

47

I think we should keep this test coverage by adding -Werror=c++2b-extensions to the RUN line for C++2b.

71

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

9–10

61–62

This error seems suspect to me. If we made flowing through a thread_local into an extension (line 54), then this code should be accepted. However, I think we're getting the error because the constant expression evaluator produces the note on line 55 and that usually will cause the evaluator to claim it wasn't a constant expression.

78

[cor3ntin]

Address formatting and style issues

clang/lib/Sema/SemaDeclCXX.cpp

2132–2136

This is consistent with the same code above. Should I be inconsistent?

[aaron.ballman]

clang/lib/Sema/SemaDeclCXX.cpp

2132–2136

I don't have strong opinions, either way is defensible. I just have a hard time reading the code with nesting the substatements like this.

[cor3ntin]

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

61–62

We can not evaluate at compile time a thread_local or static, even if we allow them to appear in a constexpr function. So this is the behavior I'd expect

[cor3ntin]

clang/lib/Sema/SemaDeclCXX.cpp

2132–2136

Would you be happy if i fix all of them later as a nfc?

[aaron.ballman]

clang/lib/Sema/SemaDeclCXX.cpp

2132–2136

Absolutely! Or if you want to land an NFC fix now and rebase your patch on top of that, that'd also be fine.

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

61–62

Yes, you're right, I lost that context before. Sorry for the noise, I think the error here is correct. But I also worry that users may get confused in the same way I just did. That said, I can't think of a better diagnostic wording and I think the behavior in situ will be fine because the note will be "attached" to the error in the diagnostic output, which makes the error more clear than reading the code statically in the review.

[cor3ntin]

Restore the C++14 tests

[cor3ntin]

Fix test

[hubert.reinterpretcast]

@aaron.ballman @cor3ntin, are we confident that testing the non-lambda cases is sufficient to cover the lambda cases as well?

I suggest using a pattern such as:

int (*test_cxx2b_constexpr_label_in_body())() {
  auto qq = []() {
    label: return 42;
  };
  const int x = qq();
  auto ff = [] { return x; }; // passes in C++2b; error in C++20
  return ff;
}

For each of the cases.

clang/lib/AST/ExprConstant.cpp

5010

I don't see anything in the wording exempting constexpr static (although I suppose it makes sense to, but GCC does not make such an exemption in its C++2b mode). @cor3ntin, can you open a discussion on the reflector?

[aaron.ballman]

In D111400#3383006, @hubert.reinterpretcast wrote:

@aaron.ballman @cor3ntin, are we confident that testing the non-lambda cases is sufficient to cover the lambda cases as well?

I think lambdas are just odd enough that they'd be worth testing independently.

I suggest using a pattern such as:

int (*test_cxx2b_constexpr_label_in_body())() {
  auto qq = []() {
    label: return 42;
  };
  const int x = qq();
  auto ff = [] { return x; }; // passes in C++2b; error in C++20
  return ff;
}

For each of the cases.

Not a bad way to test that!

[cor3ntin]

• Add tests in lambdas
• Do not allow static constexpr:

I can't think of a scenario in which that would
be problematic *today*, but I agree it would be
non-conforming and should be discussed.
For example it would affect https://wg21.link/p0596.

I removed that, and added tests to check it is correctly
ill-formed.

[cor3ntin]

Formatting

[hubert.reinterpretcast]

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

102

I think a lambda marked constexpr and one that isn't has fundamental differences in behaviour in relation to this patch. As noted in previous comments, the constexpr case warns and then allows the lambda to be called in constant evaluation. The other case produces no message for the lambda definition itself and does not allow the lambda to be called in a constexpr context (even if the control flow is accepted by C++2b).

[cor3ntin]

Add more tests for implicitely constexpr lambdas

[cor3ntin]

Formatting

[cor3ntin]

@hubert.reinterpretcast I added the tests, please let me know what you think. Thanks!

[hubert.reinterpretcast]

clang/lib/Sema/SemaDeclCXX.cpp

1904–1906

This seems to unconditionally error in pre-C++2b modes. For consistency, this should be a -Wc++2b-extensions warning.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/dtor.cpp

1

@cor3ntin, I don't think Aaron's comment has been addressed. I think keeping -std=c++2a and adding -Wc++2b-extensions would be appropriate. I know there are tests elsewhere that also focus on paragraph 3, but this test has coverage specifically for destructors.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

39

For consistency, this should warn (under -Wpre-c++2b-compat).

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

The use -Werror hides potential issues where the error is categorically produced (instead of under the warning group).

Considering that there is a relevant design consistency issue of exactly that sort right now that this test could have highlighted (but didn't), a change to stop using -Werror may be prudent.

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

47

@aaron.ballman, the tests have been restored; however, they test the extension behaviour now. The -Werror=c++2b-extensions version of the tests are covered by the tests elsewhere that focus on [dcl.constexpr] paragraph 3.

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

4–14

Suggest to remove the return m; versions of the tests. They are redundant for the purpose of verifying that "control flows through [ ... ]" is enough for the function to never produce a constant expression.

31

Call j. Just make it go though the early return.

39

Same comment as for j above (but for k).

[cor3ntin]

clang/lib/Sema/SemaDeclCXX.cpp

1904–1906

We agreed not have this an extension in earlier modes because a valid c++20 program can sfinea on that. Is it not a direction you agree with anymore>

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

39

I though we decided *not* to do that

[cor3ntin]

• Test dcl.constexpr/dtor.cpp in both C++20 and C++23 modes
• Make sure j/k are actually called in constant-expression-cxx2b.cpp

[cor3ntin]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/dtor.cpp

1

Yes, I missed that, thanks

[cor3ntin]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

This seems inconsistent with how that file is currently structured though

[hubert.reinterpretcast]

I think labels can be left as is.

Yes, the static, thread_local, label, and goto cases would all categorically contribute to a IFNDR program in the older modes (and we currently reliably diagnose them in the definition context).

clang/lib/Sema/SemaDeclCXX.cpp

1904–1906

I think, now that we have the lambda cases all working, we can be confident that return false; in older modes is what this code is responsible for in the SFINAE case.

For handling SFINAE-related cases, there may (eventually) be some restructuring to allow focus on only the template-dependent cases, but C++23 might end up needing to do the checking even for non-dependent cases during constant expression evaluation (because the template definition becomes well-formed due to pending removal of IFNDR).

I've also found indications that Clang generally fails to perform strict constant expression evaluation in relation to instantiations that fail to satisfy the requirements for a constexpr function:

template <typename T>
struct A {
  constexpr int f() {
    T t;  // cannot be trivial default initialization until P1331
          // (not DR out of Cologne 2019)
    t = T();
    return 42 + t;
  }
};

template <const int &N>
short g(int, char (*)[N] = 0);

template <const int &N>
long g(void *);

struct Z {
  constexpr Z() {}
  constexpr operator int() { return 0; }
};
const int x = A<int>().f();

extern decltype(g<x>(0)) q;
short q;

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

I meant to change the entire file to check for warnings instead of errors. I guess that really should be a separate patch.

[hubert.reinterpretcast]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

18–23

Still trying to make the choice of tests consistent between the different cases (static local variable, goto statement, etc.) and consistent within files...

The test that is here (function will unconditionally evaluate) seems to belong in constant-expression-cxx2b.cpp... or at least that is where the equivalent tests for the static local variable case, etc. is (and correctly, I think).

The test that should be here is the "conditionally will evaluate" case where the function is not called. That is, this file has tests that check that the warnings are produced purely from the definition being present.

33–35

For the reason above, I think this should be in constant-expression-cxx2b.cpp instead.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

I guess the change will cause the "never produces a constant expression" warning unless if that is suppressed with -Wno-invalid-constexpr.

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

96

I see no tests in the entire patch where a labelled statement is evaluated successfully in a constant expression evaluation. This file will be where such a test should be.

97–124

I think it would be more meaningful to have the explicitly constexpr lambda tests in the file (see comment on the later code below) that also runs under C++20 mode. The tests should be structured to demonstrate that the explicitly constexpr lambdas are usable in constant expression evaluation even in older modes.

126–155

It is quite important that all of the cases (label, goto, static, thread_local, and non-literal) is tested in lambdas not explicitly constexpr and run in C++20 mode too. The focus should be that:

• the cases that are implicitly constexpr only in C++2b are not usable in constant expression evaluation in C++20 mode, and
• they are usable in constant expression evaluation in C++2b mode.

I suggest a separate file for this.

[hubert.reinterpretcast]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/dtor.cpp

26–28

s/becaus/because/;

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

37–40

There should be a version of this in constant-expression-cxx2b.cpp where the function is called successfully during constant expression evaluation.

[cor3ntin]

• fix typos
• add tests for non-literals in lambdas
• run lambda tests in c++20 mode

[cor3ntin]

Add a test for evaluated labels

[cor3ntin]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

17

These tests exist in that same file

18–23

I'm not sure I understand. No call is made in that file.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

Yes, we could cleanup this entire file to get rid of the #ifdef, then change how warnings are diagnosed.

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

97–124

That would just test the extension warnings which we already tests a bunch of time. I'm willing to add more tests but I question whether it would had any value

[hubert.reinterpretcast]

clang/lib/Sema/SemaDeclCXX.cpp

1904–1906

Okay, GCC errors for the NonLiteral case in C++20 mode. I think that's good enough reason for us to leave Clang doing the same (as the patch currently does).

struct NonLiteral {
  NonLiteral() {}
};

constexpr auto dependent_var_def_lambda(bool b) {
  if (!b)
    NonLiteral n;
  return 0;
}

https://godbolt.org/z/fM9fanxrG

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

18–23

The case here is unconditional and not called. So, it should be in constant-expression-cxx2b.cpp because that is the file with other unconditional (and not called) cases. That a call never produces a constant expression is a property of the evaluation rules.

The other file currently has eval_goto::f, which does have a condition gating the evaluation of the goto (and is called). A copy of that function (but no call) would be what fits in this file.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

I am not in favour of getting rid of the #ifdefs. They still tell us that the "conformance" warnings are associated with the right modes.

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

97–124

I was saying that these test_in_lambdas tests (not run under C++20 at the time) were mostly redundant.

I agree that we don't need to test the full set of explicitly-constexpr lambdas. The "tests should be structured" comment actually asks for less tests (focus on the callable in constant expression evaluation case). That is because the new rules are not used in the implicitly-constexpr determination for lambdas in older modes. Contrasting explicitly-constexpr lambdas in older modes (which can be evaluated in constant expressions) with the corresponding not-explicitly-constexpr lambdas (which are not implicitly constexpr) has meaning.

It may help to leave a short rationale comment in the test for why we have one(?) test with an explicitly-constexpr lambda and why we only call it for a successful constant expression evaluation.

203–207

Suggest to go for the version that involves template instantiation:

template <typename T>
constexpr auto dependent_var_def_lambda(void) {
  return [](bool b) {
    if (!b)
      T t;
    return 0;
  };
}

constexpr auto non_literal_valid_in_cxx2b = dependent_var_def_lambda<NonLiteral>()(true);

209

Isn't this the "not 'ok'" case? The naming as non_literal_ok is confusing.

[cor3ntin]

• Tidy up tests
• Add comments
• Add a test with a non literal variable in dependant context as per Hubert's suggestion

[cor3ntin]

• clang-format

[hubert.reinterpretcast]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/dtor.cpp

26–28

Typo still present.

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

2–3

Flip cxx2a and cxx2b prefixes to match mode used. Add -Wno-c++2b-extensions since tests for those warnings are covered in p3-2b.cpp.

9

It's customary to have the L suffix in the context of checking __cplusplus.

91

Evaluate as constexpr.

117

Evaluate as constexpr.

119

Move #endif to here (from below) so the explicitly-constexpr lambda cases are also tried in C++20 mode.

121–122

Fix typos.

126

Adjust for suggested changes: do not expect C++2b mode warning in C++20 mode.

133

Adjust for suggested changes: do not expect C++2b mode warning in C++20 mode.

142

Adjust for suggested changes: do not expect C++2b mode warning in C++20 mode.

148–149

Minor: Adjust alignment of comments.

153

Adjust for C++20/C++2b differences.

157–159

Guard calls to be C++2b only (since definition is not okay in C++20 mode). Adjust naming so that "ok" name is used for the C++2b-valid case.

161–162

Move #endif up so the explicitly-constexpr lambda cases are also tried in C++20 mode.

[hubert.reinterpretcast]

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

164

Fix typo and expand comment.

166–170

Remove this lambda. It is not callable in any constant expression even under C++2b mode.

195–196

Minor nit: Align comments.

208–210

Minor nit: Align comments.

[cor3ntin]

Tidy up the tests again

[cor3ntin]

Add ifdef around tests that should not run in c++20 mode

[cor3ntin]

Switch variable names (non_literal_ko/non_literal_ok)

[hubert.reinterpretcast]

LGTM with minor nit. Thank you.

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

5

Minor nit: Formatting.

[cor3ntin]

Fix formatting

[cor3ntin]

In D111400#3397533, @hubert.reinterpretcast wrote:

LGTM with minor nit. Thank you.

Thanks a lot for the review.
I will probably merge tomorrow unless @aaron.ballman or @erichkeane have further comments

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

18–23

The idea is that p3-2b.cpp would check for things without evaluating them, whether constant-expression-cxx2b.cpp does evaluate them - aka define vs use. Let me know if that clarifies or if you would still prefer i remove redundant test from p3-2b.cpp

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

To be clear, i meant using //cxx20-warning and things like that instead, which is functionally equivalent. Does that make sense?

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

119

I mean sure I can do that, but what are we testing here?

209

You are right, I switched it.

[hubert.reinterpretcast]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

18–23

Regarding the test here (and related possible tests), I'm willing to go with what's in the patch now.

I was pointing out that constant-expression-cxx2b.cpp does have cases that are not evaluated (::f and ::g) where the construct is reached unconditionally (i.e., cases like this one, except not for goto); therefore, this test and those tests should be in the same file.

At the same time, the compat warning should be tested (in this file) as being present on the definition even if it is only conditionally reachable and there are no uses of the function (dtor.cpp covers the same for the extension warning).

As for which file tests like the current one should go, I would characterize the difference between p3-2b.cpp and constant-expression-cxx2b.cpp as not "define versus use", but instead as "definition rules versus evaluation rules". I would argue that the truth of "never produces a constant expression" is a consequence from the evaluation rules.

33–35

If moving tests around re: "never produces a constant expression", move this one (non_literal()) too.

39

Actually, I think we only decided that it should always be an error in older modes (and we didn't decide not to add a compat warning). That is, the extension and compat warnings just happen to be paired currently in the patch. Now that the code has cleared out of my system a bit, I believe that there is no fundamental reason for the two warnings to be paired.

I'm fine with getting this patch landed and then fixing this after. Maybe @aaron.ballman would comment as well.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

Yes it does. I think that would be good (but does not need to be part of this patch).

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

119

We're testing that the extension behaviour is actually extended to explicitly-constexpr lambdas in C++20 mode despite the non-application (in C++20 mode) of the new rules when determining whether a lambda is implicitly constexpr.

Having the test reinforces that the behaviour is as intended, which serves a design documentation purpose.

The test also arises when applying closed-box testing methodology to speculate how a desired behaviour may have been implemented in a way that also leads to undesired behaviour. In other words, maybe the code keyed off too much on being in a lambda body.

Yes, I know we can read the code, but then again that's today's code and not necessarily tomorrow's.

[erichkeane]

1 request for a test, and 1 hope that @aaron.ballman will help bikeshed (or just say its fine!), but otherwise LGTM.

clang/include/clang/Basic/DiagnosticASTKinds.td

69

Hmm... this feels a little awkward to me. Though, I usually have Aaron do the bikeshedding, so if he didn't come up with better I guess we can let it go.

clang/lib/AST/ExprConstant.cpp

5010

Can we make sure we have tests for the 'other' two types of TSCSpec? I'm not too worried about C11 thread local (it does, after all, require static), but the GNU __thread does not.

[aaron.ballman]

I don't spot anything overly concerning in this patch, I believe it LGTM as well.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

39

I would also be fine with addressing that after this patch lands.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

1–5

FWIW, I also agree that it'd be good to use -verify=something instead of #ifdef (but not strictly necessary for this patch).

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

119

Having the test reinforces that the behaviour is as intended, which serves a design documentation purpose.

We do this in our tests somewhat regularly, but please be sure to add comments to explain that the test is serving a design documentation purpose, otherwise it can be easy to later go "oh, this is obviously broken nonsense so it's fine that behavior changed" by accident.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticASTKinds.td

69

I didn't think it was overly awkward, about the only question I had was "should we quote the static and thread_local as keywords?" when I reviewed.

[erichkeane]

clang/include/clang/Basic/DiagnosticASTKinds.td

69

Ok, I can live with that. AS far as quoting, I think we are consistently inconsistent on that one.

[hubert.reinterpretcast]

clang/include/clang/Basic/DiagnosticASTKinds.td

69

Minor nit:
The code already behaves as-if the resolution of CWG 2552 is applied. Let's use the corresponding wording.

[cor3ntin]

• Add tests for _Thread_local, thread

(these should be supported in c++23 constexpr function)

• Change /declaration/definition/ in a diagnostic message

[erichkeane]

In D111400#3399876, @cor3ntin wrote:

• Add tests for _Thread_local, thread

(these should be supported in c++23 constexpr function)

• Change /declaration/definition/ in a diagnostic message

SGTM, thanks!

[cor3ntin]

I will probably land that soon if there are no further issue

According to my notes, i then need to

• Cleanup clang/test/SemaCXX/constant-expression-cxx14.cpp (remove -Werror, #ifdef)
• Add braces in CheckConstexprFunctionStmt
• We may still miss a compatibility warning for non-literal in c++23 mode?

[hubert.reinterpretcast]

Confirming LGTM with minor comments.

In D111400#3399929, @cor3ntin wrote:

• We may still miss a compatibility warning for non-literal in c++23 mode?

My understanding is that Aaron and I both want the warning added (but are okay with having this patch landed first).

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

24

Formatting nit.

30

Formatting nit.

[aaron.ballman]

In D111400#3400011, @hubert.reinterpretcast wrote:

Confirming LGTM with minor comments.

In D111400#3399929, @cor3ntin wrote:

• We may still miss a compatibility warning for non-literal in c++23 mode?

My understanding is that Aaron and I both want the warning added (but are okay with having this patch landed first).

+1 to this

[cor3ntin]

Formatting

[cor3ntin]

@hubert.reinterpretcast @aaron.ballman @erichkeane Thanks a lot for the review. I'm working on making PRs for the further changes we agreed to do.

clang/docs/ReleaseNotes.rst

 - Diagnose consteval and constexpr issues that happen at namespace scope. This
   partially addresses `Issue 51593 <https://github.com/llvm/llvm-project/issues/51593>`_.
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Implemented `P2128R6: Multidimensional subscript operator <https://wg21.link/P2128R6>`_.
 - Implemented `P0849R8: auto(x): decay-copy in the language <https://wg21.link/P0849R8>`_.
+- Implemented `P2242R3: Non-literal variables (and labels and gotos) in constexpr functions <https://wg21.link/P2242R3>`_.
 
 CUDA Language Changes in Clang
 ------------------------------
 
 Objective-C Language Changes in Clang
 -------------------------------------
 
 OpenCL C Language Changes in Clang

clang/include/clang/Basic/DiagnosticASTKinds.td

 def note_constexpr_dynamic_alloc : Note<
   "%select{pointer|reference}0 to %select{|subobject of }1"
   "heap-allocated object is not a constant expression">;
 def note_consteval_address_accessible : Note<
   "%select{pointer|reference}0 to a consteval declaration "
   "is not a constant expression">;
 def note_constexpr_uninitialized : Note<
   "%select{|sub}0object of type %1 is not initialized">;
+def note_constexpr_static_local : Note<
+  "control flows through the definition of a %select{static|thread_local}0 variable">;
 def note_constexpr_subobject_declared_here : Note<
   "subobject declared here">;
 def note_constexpr_array_index : Note<"cannot refer to element %0 of "
   "%select{array of %2 element%plural{1:|:s}2|non-array object}1 "
   "in a constant expression">;
 def note_constexpr_float_arithmetic : Note<
   "floating point arithmetic produces %select{an infinity|a NaN}0">;
 def note_constexpr_dynamic_rounding : Note<

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx11_compat_constexpr_body_invalid_stmt : Warning<
   InGroup<CXXPre14Compat>, DefaultIgnore;
 def ext_constexpr_body_invalid_stmt_cxx20 : ExtWarn<
   "use of this statement in a constexpr %select{function|constructor}0 "
   "is a C++20 extension">, InGroup<CXX20>;
 def warn_cxx17_compat_constexpr_body_invalid_stmt : Warning<
   "use of this statement in a constexpr %select{function|constructor}0 "
   "is incompatible with C++ standards before C++20">,
   InGroup<CXXPre20Compat>, DefaultIgnore;
+def ext_constexpr_body_invalid_stmt_cxx2b : ExtWarn<
+  "use of this statement in a constexpr %select{function|constructor}0 "
+  "is a C++2b extension">, InGroup<CXX2b>;
+def warn_cxx20_compat_constexpr_body_invalid_stmt : Warning<
+  "use of this statement in a constexpr %select{function|constructor}0 "
+  "is incompatible with C++ standards before C++2b">,
+  InGroup<CXXPre2bCompat>, DefaultIgnore;
 def ext_constexpr_type_definition : ExtWarn<
   "type definition in a constexpr %select{function|constructor}0 "
   "is a C++14 extension">, InGroup<CXX14>;
 def warn_cxx11_compat_constexpr_type_definition : Warning<
   "type definition in a constexpr %select{function|constructor}0 "
   "is incompatible with C++ standards before C++14">,
   InGroup<CXXPre14Compat>, DefaultIgnore;
 def err_constexpr_vla : Error<
   "variably-modified type %0 cannot be used in a constexpr "
   "%select{function|constructor}1">;
 def ext_constexpr_local_var : ExtWarn<
   "variable declaration in a constexpr %select{function|constructor}0 "
   "is a C++14 extension">, InGroup<CXX14>;
 def warn_cxx11_compat_constexpr_local_var : Warning<
   "variable declaration in a constexpr %select{function|constructor}0 "
   "is incompatible with C++ standards before C++14">,
   InGroup<CXXPre14Compat>, DefaultIgnore;
-def err_constexpr_local_var_static : Error<
-  "%select{static|thread_local}1 variable not permitted in a constexpr "
-  "%select{function|constructor}0">;
+def ext_constexpr_static_var : ExtWarn<
+  "definition of a %select{static|thread_local}1 variable "
+  "in a constexpr %select{function|constructor}0 "
+  "is a C++2b extension">, InGroup<CXX2b>;
+def warn_cxx20_compat_constexpr_static_var : Warning<
+  "definition of a %select{static|thread_local}1 variable "
+  "in a constexpr %select{function|constructor}0 "
+  "is incompatible with C++ standards before C++2b">,
+  InGroup<CXXPre2bCompat>, DefaultIgnore;
 def err_constexpr_local_var_non_literal_type : Error<
   "variable of non-literal type %1 cannot be defined in a constexpr "
-  "%select{function|constructor}0">;
+  "%select{function|constructor}0 before C++2b">;
 def ext_constexpr_local_var_no_init : ExtWarn<
   "uninitialized variable in a constexpr %select{function|constructor}0 "
   "is a C++20 extension">, InGroup<CXX20>;
 def warn_cxx17_compat_constexpr_local_var_no_init : Warning<
   "uninitialized variable in a constexpr %select{function|constructor}0 "
   "is incompatible with C++ standards before C++20">,
   InGroup<CXXPre20Compat>, DefaultIgnore;
 def ext_constexpr_function_never_constant_expr : ExtWarn<

clang/lib/AST/ExprConstant.cpp

case ESR_CaseNotFound:
     // expression. We have no intention of supporting that.
     Info.FFDiag(Found->getBeginLoc(),
                 diag::note_constexpr_stmt_expr_unsupported);
     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()) {
+    Info.CCEDiag(VD->getLocation(), diag::note_constexpr_static_local)
+        << (VD->getTSCSpec() == TSCS_unspecified ? 0 : 1) << VD;
+    return false;
+  }
+  return true;
+}
+
 // Evaluate a statement.
 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
                                    const Stmt *S, const SwitchCase *Case) {
   if (!Info.nextStep(S))
     return ESR_Failed;
 
   // If we're hunting down a 'case' or 'default' label, recurse through
   // substatements until we hit the label.
if (Case) {
     }
 
     case Stmt::DeclStmtClass: {
       // Start the lifetime of any uninitialized variables we encounter. They
       // might be used by the selected branch of the switch.
       const DeclStmt *DS = cast<DeclStmt>(S);
       for (const auto *D : DS->decls()) {
         if (const auto *VD = dyn_cast<VarDecl>(D)) {
+          if (!CheckLocalVariableDeclaration(Info, VD))
+            return ESR_Failed;
           if (VD->hasLocalStorage() && !VD->getInit())
             if (!EvaluateVarDecl(Info, VD))
               return ESR_Failed;
           // FIXME: If the variable has initialization that can't be jumped
           // over, bail out of any immediately-surrounding compound-statement
           // too. There can't be any case labels here.
         }
       }
       return ESR_CaseNotFound;
default:
     return ESR_Failed;
 
   case Stmt::NullStmtClass:
     return ESR_Succeeded;
 
   case Stmt::DeclStmtClass: {
     const DeclStmt *DS = cast<DeclStmt>(S);
     for (const auto *D : DS->decls()) {
+      const VarDecl *VD = dyn_cast_or_null<VarDecl>(D);
+      if (VD && !CheckLocalVariableDeclaration(Info, VD))
+        return ESR_Failed;
       // Each declaration initialization is its own full-expression.
       FullExpressionRAII Scope(Info);
       if (!EvaluateDecl(Info, D) && !Info.noteFailure())
         return ESR_Failed;
       if (!Scope.destroy())
         return ESR_Failed;
     }
     return ESR_Succeeded;
   }

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.CPlusPlus20 ? "201907L" :
-                        LangOpts.CPlusPlus17 ? "201603L" :
-                        LangOpts.CPlusPlus14 ? "201304L" : "200704");
+    Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus2b   ? "202110L"
+                                           : 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",
                         LangOpts.CPlusPlus17 ? "201411L" : "200410");
     Builder.defineMacro("__cpp_decltype", "200707L");
     Builder.defineMacro("__cpp_attributes", "200809L");
     Builder.defineMacro("__cpp_rvalue_references", "200610L");

clang/lib/Sema/SemaDeclCXX.cpp

case Decl::Decomposition: {
       //   a definition of a variable of non-literal type or of static or
       //   thread storage duration or [before C++2a] for which no
       //   initialization is performed.
       const auto *VD = cast<VarDecl>(DclIt);
       if (VD->isThisDeclarationADefinition()) {
         if (VD->isStaticLocal()) {
           if (Kind == Sema::CheckConstexprKind::Diagnose) {
             SemaRef.Diag(VD->getLocation(),
-                         diag::err_constexpr_local_var_static)
+                         SemaRef.getLangOpts().CPlusPlus2b
+                             ? diag::warn_cxx20_compat_constexpr_static_var
+                             : diag::ext_constexpr_static_var)
                 << isa<CXXConstructorDecl>(Dcl)
                 << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
-          }
+          } else if (!SemaRef.getLangOpts().CPlusPlus2b) {
             return false;
           }
-        if (CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(),
+        }
+        if (!SemaRef.LangOpts.CPlusPlus2b &&
+            CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(),
                              diag::err_constexpr_local_var_non_literal_type,
                              isa<CXXConstructorDecl>(Dcl)))
           return false;
         if (!VD->getType()->isDependentType() &&
             !VD->hasInit() && !VD->isCXXForRangeDecl()) {
           if (Kind == Sema::CheckConstexprKind::Diagnose) {
             SemaRef.Diag(
                 VD->getLocation(),
                 SemaRef.getLangOpts().CPlusPlus20

 }
 
 /// Check the provided statement is allowed in a constexpr function
 /// definition.
 static bool
 CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
                            SmallVectorImpl<SourceLocation> &ReturnStmts,
                            SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc,
+                           SourceLocation &Cxx2bLoc,
                            Sema::CheckConstexprKind Kind) {
   // - its function-body shall be [...] a compound-statement that contains only
   switch (S->getStmtClass()) {
   case Stmt::NullStmtClass:
     //   - null statements,
     return true;
 
   case Stmt::DeclStmtClass:
case Stmt::ReturnStmtClass:
     }
 
     ReturnStmts.push_back(S->getBeginLoc());
     return true;
 
   case Stmt::AttributedStmtClass:
     // Attributes on a statement don't affect its formal kind and hence don't
     // affect its validity in a constexpr function.
-    return CheckConstexprFunctionStmt(SemaRef, Dcl,
-                                      cast<AttributedStmt>(S)->getSubStmt(),
-                                      ReturnStmts, Cxx1yLoc, Cxx2aLoc, Kind);
+    return CheckConstexprFunctionStmt(
+        SemaRef, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,
+        Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind);
 
   case Stmt::CompoundStmtClass: {
     // C++1y allows compound-statements.
     if (!Cxx1yLoc.isValid())
       Cxx1yLoc = S->getBeginLoc();
 
     CompoundStmt *CompStmt = cast<CompoundStmt>(S);
     for (auto *BodyIt : CompStmt->body()) {
       if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
-                                      Cxx1yLoc, Cxx2aLoc, Kind))
+                                      Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
         return false;
     }
     return true;
   }
 
   case Stmt::IfStmtClass: {
     // C++1y allows if-statements.
     if (!Cxx1yLoc.isValid())
       Cxx1yLoc = S->getBeginLoc();
 
     IfStmt *If = cast<IfStmt>(S);
     if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
-                                    Cxx1yLoc, Cxx2aLoc, Kind))
+                                    Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
       return false;
     if (If->getElse() &&
         !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
-                                    Cxx1yLoc, Cxx2aLoc, Kind))
+                                    Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
       return false;
     return true;
   }
 
   case Stmt::WhileStmtClass:
   case Stmt::DoStmtClass:
   case Stmt::ForStmtClass:
   case Stmt::CXXForRangeStmtClass:
   case Stmt::ContinueStmtClass:
     // C++1y allows all of these. We don't allow them as extensions in C++11,
     // because they don't make sense without variable mutation.
     if (!SemaRef.getLangOpts().CPlusPlus14)
       break;
     if (!Cxx1yLoc.isValid())
       Cxx1yLoc = S->getBeginLoc();
     for (Stmt *SubStmt : S->children())
       if (SubStmt &&
           !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
-                                      Cxx1yLoc, Cxx2aLoc, Kind))
+                                      Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
         return false;
     return true;
 
   case Stmt::SwitchStmtClass:
   case Stmt::CaseStmtClass:
   case Stmt::DefaultStmtClass:
   case Stmt::BreakStmtClass:
     // C++1y allows switch-statements, and since they don't need variable
     // mutation, we can reasonably allow them in C++11 as an extension.
     if (!Cxx1yLoc.isValid())
       Cxx1yLoc = S->getBeginLoc();
     for (Stmt *SubStmt : S->children())
       if (SubStmt &&
           !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
-                                      Cxx1yLoc, Cxx2aLoc, Kind))
+                                      Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
+        return false;
+    return true;
+
+  case Stmt::LabelStmtClass:
+  case Stmt::GotoStmtClass:
+    if (Cxx2bLoc.isInvalid())
+      Cxx2bLoc = S->getBeginLoc();
+    for (Stmt *SubStmt : S->children())
+      if (SubStmt &&
+          !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
+                                      Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
         return false;
     return true;
 
   case Stmt::GCCAsmStmtClass:
   case Stmt::MSAsmStmtClass:
     // C++2a allows inline assembly statements.
   case Stmt::CXXTryStmtClass:
     if (Cxx2aLoc.isInvalid())
       Cxx2aLoc = S->getBeginLoc();
     for (Stmt *SubStmt : S->children()) {
       if (SubStmt &&
           !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
-                                      Cxx1yLoc, Cxx2aLoc, Kind))
+                                      Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
         return false;
     }
     return true;
 
   case Stmt::CXXCatchStmtClass:
     // Do not bother checking the language mode (already covered by the
     // try block check).
-    if (!CheckConstexprFunctionStmt(SemaRef, Dcl,
-                                    cast<CXXCatchStmt>(S)->getHandlerBlock(),
-                                    ReturnStmts, Cxx1yLoc, Cxx2aLoc, Kind))
+    if (!CheckConstexprFunctionStmt(
+            SemaRef, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,
+            Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
       return false;
     return true;
 
   default:
     if (!isa<Expr>(S))
       break;
 
     // C++1y allows expression-statements.
if (isa<CXXTryStmt>(Body)) {
     }
   }
 
   // - its function-body shall be [...] a compound-statement that contains only
   //   [... list of cases ...]
   //
   // Note that walking the children here is enough to properly check for
   // CompoundStmt and CXXTryStmt body.
-  SourceLocation Cxx1yLoc, Cxx2aLoc;
+  SourceLocation Cxx1yLoc, Cxx2aLoc, Cxx2bLoc;
   for (Stmt *SubStmt : Body->children()) {
     if (SubStmt &&
         !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
-                                    Cxx1yLoc, Cxx2aLoc, Kind))
+                                    Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
       return false;
   }
 
   if (Kind == Sema::CheckConstexprKind::CheckValid) {
     // If this is only valid as an extension, report that we don't satisfy the
     // constraints of the current language.
-    if ((Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus20) ||
+    if ((Cxx2bLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus2b) ||
+        (Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus20) ||
         (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
       return false;
+  } else if (Cxx2bLoc.isValid()) {
+    SemaRef.Diag(Cxx2bLoc,
+                 SemaRef.getLangOpts().CPlusPlus2b
+                     ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt
+                     : diag::ext_constexpr_body_invalid_stmt_cxx2b)
+        << isa<CXXConstructorDecl>(Dcl);
   } else if (Cxx2aLoc.isValid()) {
     SemaRef.Diag(Cxx2aLoc,
          SemaRef.getLangOpts().CPlusPlus20
            ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
            : diag::ext_constexpr_body_invalid_stmt_cxx20)
       << isa<CXXConstructorDecl>(Dcl);
   } else if (Cxx1yLoc.isValid()) {
     SemaRef.Diag(Cxx1yLoc,

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/dtor.cpp

-// RUN: %clang_cc1 -std=c++2a -verify %s
+// RUN: %clang_cc1 -std=c++2a -verify=expected,cxx2a %s
+// RUN: %clang_cc1 -std=c++2b -verify=expected %s
 
 // p3: if the function is a constructor or destructor, its class shall not have
 // any virtual base classes;
 namespace vbase {
   struct A {};
   struct B : virtual A { // expected-note {{virtual}}
     constexpr ~B() {} // expected-error {{constexpr member function not allowed in struct with virtual base class}}
   };
 }
 
-// p3: its function-body shall not enclose
-//  -- a goto statement
-//  -- an identifier label
-//  -- a variable of non-literal type or of static or thread storage duration
 namespace contents {
   struct A {
     constexpr ~A() {
-      goto x; // expected-error {{statement not allowed in constexpr function}}
+      return;
+      goto x; // cxx2a-warning {{use of this statement in a constexpr function is a C++2b extension}}
       x: ;
     }
   };
   struct B {
     constexpr ~B() {
-      x: ; // expected-error {{statement not allowed in constexpr function}}
+    x:; // cxx2a-warning {{use of this statement in a constexpr function is a C++2b extension}}
     }
   };
-  struct Nonlit { Nonlit(); }; // expected-note {{not literal}}
+  struct Nonlit { // cxx2a-note {{'Nonlit' is not literal because}}
+    Nonlit();
+  };
   struct C {
     constexpr ~C() {
-      Nonlit nl; // expected-error {{non-literal}}
+      return;
+      Nonlit nl; // cxx2a-error {{variable of non-literal type 'contents::Nonlit' cannot be defined in a constexpr function before C++2b}}
     }
   };
   struct D {
     constexpr ~D() {
-      static int a; // expected-error {{static variable}}
+      return;
+      static int a; // cxx2a-warning {{definition of a static variable in a constexpr function is a C++2b extension}}
     }
   };
   struct E {
     constexpr ~E() {
-      thread_local int e; // expected-error {{thread_local variable}}
+      return;
+      thread_local int e; // cxx2a-warning {{definition of a thread_local variable in a constexpr function is a C++2b extension}}
     }
   };
   struct F {
     constexpr ~F() {
+      return;
       extern int f;
     }
   };
 }
 
 // p5: for every subobject of class type or (possibly multi-dimensional) array
 // thereof, that class type shall have a constexpr destructor
 namespace subobject {

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

+// RUN: %clang_cc1 -verify -std=c++2b -Wpre-c++2b-compat %s
+
+constexpr int h(int n) {
+  if (!n)
+    return 0;
+  static const int m = n; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  return m;
+}
+
+constexpr int i(int n) {
+  if (!n)
+    return 0;
+  thread_local const int m = n; // expected-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  return m;
+}
+
+constexpr int g() { // expected-error {{constexpr function never produces a constant expression}}
+  goto test;        // expected-note {{subexpression not valid in a constant expression}} \
+           // expected-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}}
+test:
+  return 0;
+}
+
+constexpr void h() {
+label:; // expected-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}}
+}
+
+struct NonLiteral {
+  NonLiteral() {}
+};
+
+constexpr void non_literal() { // expected-error {{constexpr function never produces a constant expression}}
+  NonLiteral n;                // expected-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}}
+}
+
+constexpr void non_literal2(bool b) {
+  if (!b)
+    NonLiteral n;
+}
+
+constexpr int c_thread_local(int n) {
+  if (!n)
+    return 0;
+  static _Thread_local int a; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  _Thread_local int b;        // // expected-error {{'_Thread_local' variables must have global storage}}
+  return 0;
+}
+
+constexpr int gnu_thread_local(int n) {
+  if (!n)
+    return 0;
+  static __thread int a; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  __thread int b;        // expected-error {{'__thread' variables must have global storage}}
+  return 0;
+}

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

-// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++11 -Werror=c++14-extensions -Werror=c++20-extensions %s
-// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++14 -DCXX14 -Werror=c++20-extensions %s
-// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++20 -DCXX14 -DCXX20 %s
+// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++11 -Werror=c++14-extensions -Werror=c++20-extensions -Werror=c++2b-extensions %s
+// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++14 -DCXX14 -Werror=c++20-extensions -Werror=c++2b-extensions %s
+// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++20 -DCXX14 -DCXX20 -Werror=c++2b-extensions %s
+// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++2b -DCXX14 -DCXX20 -DCXX2b %s
 
 namespace N {
   typedef char C;
 }
 
 namespace M {
   typedef double D;
 }
 
-struct NonLiteral { // expected-note 3{{no constexpr constructors}}
+struct NonLiteral { // expected-note 2{{no constexpr constructors}}
   NonLiteral() {}
   NonLiteral(int) {}
 };
 struct Literal {
   constexpr Literal() {}
   operator int() const { return 0; }
 };
 
if (b)
     asm("int3");
 #if !defined(CXX20)
   // expected-error@-2 {{use of this statement in a constexpr function is a C++20 extension}}
 #endif
   return 0;
 }
 constexpr int DisallowedStmtsCXX14_2() {
   //  - a goto statement
-  goto x; // expected-error {{statement not allowed in constexpr function}}
-x:
+  try {
+  } catch (...) {
+    goto x;
+  x:;
+  }
+#ifndef CXX2b
+  // expected-error@-4 {{use of this statement in a constexpr function is a C++2b extension}}
+#endif
   return 0;
 }
 constexpr int DisallowedStmtsCXX14_2_1() {
   try {
-    return 0;
   } catch (...) {
-  merp: goto merp; // expected-error {{statement not allowed in constexpr function}}
+  merp:
+    goto merp;
+#ifndef CXX2b
+    // expected-error@-3 {{use of this statement in a constexpr function is a C++2b extension}}
+#endif
   }
+  return 0;
 }
 constexpr int DisallowedStmtsCXX14_3() {
   //  - a try-block,
   try {} catch (...) {}
 #if !defined(CXX20)
   // expected-error@-2 {{use of this statement in a constexpr function is a C++20 extension}}
 #endif
   return 0;
 }
 constexpr int DisallowedStmtsCXX14_4() {
   //  - a definition of a variable of non-literal type
-  NonLiteral nl; // expected-error {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function}}
   return 0;
+  NonLiteral nl;
+#ifndef CXX2b
+  // expected-error@-2 {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function before C++2b}}
+  // expected-note@14  {{'NonLiteral' is not literal}}
+#endif
 }
+
 constexpr int DisallowedStmtsCXX14_5() {
+  return 0;
   //  - a definition of a variable of static storage duration
-  static constexpr int n = 123; // expected-error {{static variable not permitted in a constexpr function}}
-  return n;
+  static constexpr int n = 123;
+#ifndef CXX2b
+  // expected-error@-2 {{definition of a static variable in a constexpr function is a C++2b extension}}
+#endif
+#if !defined(CXX14)
+  // expected-error@-5 {{variable declaration in a constexpr function is a C++14 extension}}
+#endif
 }
 constexpr int DisallowedStmtsCXX14_6() {
   //  - a definition of a variable of thread storage duration
-  thread_local constexpr int n = 123; // expected-error {{thread_local variable not permitted in a constexpr function}}
-  return n;
+  return 0;
+  thread_local constexpr int n = 123;
+#ifndef CXX2b
+  // expected-error@-2 {{definition of a thread_local variable in a constexpr function is a C++2b extension}}
+#endif
+#if !defined(CXX14)
+  // expected-error@-5 {{variable declaration in a constexpr function is a C++14 extension}}
+#endif
 }
 constexpr int DisallowedStmtsCXX14_7() {
   //  - a definition of a variable for which no initialization is performed
   int n;
 #ifndef CXX20
   // expected-error@-2 {{uninitialized variable in a constexpr function}}
 #endif
   return 0;
constexpr int abs(int x) {
     if (x < 0)
 #ifndef CXX14
       // expected-error@-2 {{C++14}}
 #endif
       x = -x;
     return x;
   }
   constexpr int first(int n) {
-    static int value = n; // expected-error {{static variable not permitted}}
-    return value;
+    return 0;
+    static int value = n;
+#ifndef CXX2b
+    // expected-error@-2 {{definition of a static variable in a constexpr function is a C++2b extension}}
+#endif
+#ifndef CXX14
+    // expected-error@-5 {{variable declaration in a constexpr function is a C++14 extension}}
+#endif
   }
   constexpr int uninit() {
     int a;
 #ifndef CXX20
     // expected-error@-2 {{uninitialized}}
 #endif
     return a;
   }

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, 201907)
+#if check(constexpr, 0, 200704, 201304, 201603, 201907, 202110)
 #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-cxx14.cpp

 // Variables can be declared in constexpr functions.
 constexpr int g(int k) {
   const int n = 9;
   int k2 = k * k;
   int k3 = k2 * k;
   return 3 * k3 + 5 * k2 + n * k - 20;
 }
 static_assert(g(2) == 42, "");
-constexpr int h(int n) {
-  static const int m = n; // expected-error {{static variable not permitted in a constexpr function}}
+constexpr int h(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}} \
+                          // cxx14_20-warning {{definition of a static variable in a constexpr function is a C++2b extension}}
   return m;
 }
-constexpr int i(int n) {
-  thread_local const int m = n; // expected-error {{thread_local variable not permitted in a constexpr function}}
+constexpr int i(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}} \
+                                // cxx14_20-warning {{definition of a thread_local variable in a constexpr function is a C++2b extension}}
   return m;
 }
 
 // if-statements can be used in constexpr functions.
 constexpr int j(int k) {
   if (k == 5)
     return 1;
   if (k == 1)
     return 5;
   else {
     if (int n = 2 * k - 4) {
       return n + 1;
       return 2;
     }
   }
 } // expected-note 2{{control reached end of constexpr function}}
 static_assert(j(0) == -3, "");
 static_assert(j(1) == 5, "");
 static_assert(j(2), ""); // expected-error {{constant expression}} expected-note {{in call to 'j(2)'}}
 static_assert(j(3) == 3, "");
 static_assert(j(4) == 5, "");
 static_assert(j(5) == 1, "");
 
 // There can be 0 return-statements.
 constexpr void k() {

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}}
+  NonLiteral() {}
+};
+
+#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 c_thread_local(int n) { // expected-error {{constexpr function never produces a constant expression}}
+  static _Thread_local int m = 0;     // expected-note {{control flows through the definition of a thread_local variable}} \
+                                      // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  return m;
+}
+
+constexpr int gnu_thread_local(int n) { // expected-error {{constexpr function never produces a constant expression}}
+  static __thread int m = 0;            // expected-note {{control flows through the definition of a thread_local variable}} \
+                                        // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}}
+  return m;
+}
+
+constexpr int h(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 - &m;
+}
+constexpr int i(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 - &m;
+}
+
+constexpr int j(int n) {
+  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;
+}
+constexpr int j0 = j(0);
+
+constexpr int k(int n) {
+  if (!n)
+    return 0;
+  thread_local const int m = n; // cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}}
+
+  return m;
+}
+constexpr int k0 = k(0);
+
+constexpr int j_evaluated(int n) {
+  if (!n)
+    return 0;
+  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 je = j_evaluated(1); // expected-error {{constexpr variable 'je' must be initialized by a constant expression}}  \
+                                   // expected-note {{in call}}
+
+constexpr int k_evaluated(int n) {
+  if (!n)
+    return 0;
+  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}}
+  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}}
+  return m;
+}
+
+constexpr int non_literal(bool b) {
+  if (!b)
+    return 0;
+  NonLiteral n;
+}
+
+constexpr int non_literal_1 = non_literal(false);
+
+namespace eval_goto {
+
+constexpr int f(int x) {
+  if (x) {
+    return 0;
+  } else {
+    goto test; // expected-note {{subexpression not valid in a constant expression}} \
+               // cxx2b-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}}
+  }
+test:
+  return 0;
+}
+
+int a = f(0);
+constexpr int b = f(0); // expected-error {{must be initialized by a constant expression}} \
+                        // expected-note {{in call to 'f(0)'}}
+constexpr int c = f(1);
+
+constexpr int label() {
+
+test: // cxx2b-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}}
+  return 0;
+}
+
+constexpr int d = label();
+
+} // 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}}
+    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;
+  }
+  (1);
+
+  auto c = [](int n) constexpr {
+    if (!n)
+      return 0;
+    else
+      goto test; // expected-note {{subexpression not valid in a constant expression}} \
+                 // cxx2b-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}}
+  test:
+    return 1;
+  };
+  c(0);
+  constexpr auto c_error = c(1); // expected-error {{constexpr variable 'c_error' must be initialized by a constant expression}} \
+                                 // expected-note {{in call to}}
+
+  auto non_literal = [](bool b) constexpr {
+    if (!b)
+      NonLiteral n; // cxx2b-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}} \
+                    // cxx2a-error {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function before C++2b}}
+    return 0;
+  };
+
+#if __cplusplus > 202002L
+  constexpr auto non_literal_ko = non_literal(false); // cxx2b-error {{constexpr variable 'non_literal_ko' must be initialized by a constant expression}} \
+                                                      // cxx2b-note {{in call}}
+
+  constexpr auto non_literal_ok = non_literal(true);
+#endif
+}
+
+// Test whether lambdas are correctly treated as implicitly constexpr under the
+// relaxed C++23 rules (and similarly as not implicitly constexpr under the
+// C++20 rules).
+int test_lambdas_implicitly_constexpr() {
+
+  auto b = [](int n) { // cxx2a-note 2{{declared here}}
+    if (!n)
+      return 0;
+    static const int m = n; // cxx2b-note {{control flows through the definition of a static variable}}
+    return m;
+  };
+
+  auto b1 = b(1);
+  constexpr auto b2 = b(0); // cxx2a-error {{must be initialized by a constant expression}} \
+                            // cxx2a-note {{non-constexpr function}}
+
+  constexpr auto b3 = b(1); // expected-error{{constexpr variable 'b3' must be initialized by a constant expression}} \
+                            // cxx2a-note {{non-constexpr function}} \
+                            // cxx2b-note {{in call}}
+
+  auto c = [](int n) { // cxx2a-note 2{{declared here}}
+    if (!n)
+      return 0;
+    else
+      goto test; // cxx2b-note {{subexpression not valid in a constant expression}}
+  test:
+    return 1;
+  };
+  c(0);
+  constexpr auto c_ok = c(0); // cxx2a-error {{must be initialized by a constant expression}} \
+                              // cxx2a-note {{non-constexpr function}}
+
+  constexpr auto c_error = c(1); // expected-error {{constexpr variable 'c_error' must be initialized by a constant expression}} \
+                                 // cxx2a-note {{non-constexpr function}} \
+                                 // cxx2b-note {{in call to}}
+
+  auto non_literal = [](bool b) { // cxx2a-note 2{{declared here}}
+    if (b)
+      NonLiteral n; // cxx2b-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}}
+    return 0;
+  };
+
+  constexpr auto non_literal_ko = non_literal(true); // expected-error {{constexpr variable 'non_literal_ko' must be initialized by a constant expression}} \
+                                                     // cxx2a-note {{non-constexpr function}} \
+                                                     // cxx2b-note {{in call}}
+
+  constexpr auto non_literal_ok = non_literal(false); // cxx2a-error {{must be initialized by a constant expression}} \
+                                                      // cxx2a-note {{non-constexpr function}}
+}
+
+template <typename T>
+constexpr auto dependent_var_def_lambda(void) {
+  return [](bool b) { // cxx2a-note {{declared here}}
+    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}}

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Multidimensional subscript operator</td>
       <td><a href="https://wg21.link/P2128R6">P2128R6</a></td>
       <td class="unreleased" align="center">Clang 15</td>
     </tr>
     <tr>
       <td>Non-literal variables (and labels and gotos) in constexpr functions</td>
       <td><a href="https://wg21.link/P2242R3">P2242R3</a></td>
-      <td class="none" align="center">No</td>
+      <td class="unreleased" align="center">Clang 15</td>
     </tr>
     <tr>
       <td>Character encoding of diagnostic text</td>
       <td><a href="https://wg21.link/P2246R1">P2246R1</a></td>
       <td class="full" align="center">Yes</td>
     </tr>
     <tr>
       <td>Character sets and encodings</td>