[clang][SemaCXX] Diagnose tautological uses of consteval if and is_constant_evaluated

[hazohelet]

Summary

This patch makes clang diagnose extensive cases of consteval if and is_constant_evaluated usage that are tautologically true or false.
This introduces a new IsRuntimeEvaluated boolean flag to Sema::ExpressionEvaluationContextRecord that means the immediate appearance of if consteval or is_constant_evaluated are tautologically false(e.g. inside if !consteval {} block or non-constexpr-qualified function definition body)
This patch also pushes new expression evaluation context when parsing the condition of if constexpr and initializer of constexpr variables so that Sema can be aware that the use of consteval if and is_consteval are tautologically true in if constexpr condition and constexpr variable initializers.
BEFORE this patch, the warning for is_constant_evaluated was emitted from constant evaluator. This patch moves the warning logic to Sema in order to diagnose tautological use of is_constant_evaluated in the same way as consteval if.

This patch separates initializer evaluation context from InitializerScopeRAII.
This fixes a bug that was happening when user takes address of function address in initializers of non-local variables.

Fixes https://github.com/llvm/llvm-project/issues/43760
Fixes https://github.com/llvm/llvm-project/issues/51567

[cor3ntin]

Thanks for working on this!
I left some comments, i hope it helps!

clang/include/clang/Sema/Sema.h

1292

I think I'd prefer a boolean for that, ExpressionEvaluationContext somewhat matches standard definitions.
I think we might mostly be able to reuse PotentiallyEvaluatedIfUsed | PotentiallyEvaluated.

RuntimeEvaluated is anything that does not have a parent context that is constant evaluated/immediate/unevaluated. Maybe you could try to make a function for that?

clang/lib/Parse/ParseDeclCXX.cpp

3210–3212

I think I'd prefer casting D to a VarDecl rather than adding a parameter

3219–3226

Maybe we should instead say that a constexpr FieldDecl is ConstantEvaluated ?
InConstantEvaluated in general seems redundant

clang/lib/Parse/ParseExpr.cpp

240 ↗

(On Diff #539461)

I'd rather either get rid of InConstantEvaluated, or at least consider UnevaluatedContext as ConstantEvaluated everywhere (ie by changing DiagnoseTautologicalIsConstantEvaluated)

clang/lib/Parse/ParseStmt.cpp

1513–1516

This seems wrong, the condition of a if statement is not constant evaluated.

clang/lib/Sema/SemaDecl.cpp

15241–15252

There are a bunch of white spaces only changes there

clang/lib/Sema/SemaDeclCXX.cpp

17962–18006

Can you explain the changes to this file? they seems to affect test cases unrelated to the goal of this PR

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

1964

This change does not seem correct

[Mordante]

I only looked at the libc++ part.

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

27

Since libc++ support the latest ToT Clang and the last two official releases this wont work. The expected-warning needs to be a expected-warning-re that works for both the new and old diagnostic

[philnik]

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

27

You can also just shorten it to 'std::is_constant_evaluated' will always evaluate to. Seems good enough to me.

[hazohelet]

Address comments from Corentin, Mark and Nikolas

• Removed InConstantEvaluated
• Removed RuntimeEvaluated expression evaluation context kind and instead added a boolean IsRuntimeEvaluated to Sema::ExpressionEvaluationContextRecord
• Handle unevaluated context as constant when emitting the diagnostics
• NFC stylistic changes
• Fixed libcxx CI test

[hazohelet]

Thank you for the review!

clang/include/clang/Sema/Sema.h

1292

I made it a boolean instead of a new expression evaluation context.

RuntimeEvaluated is anything that does not have a parent context that is constant evaluated/immediate/unevaluated. Maybe you could try to make a function for that?

I dont't think it is correct. The definitions body of constexpr-qualified function and non-qualified function both push PotentiallyEvaluated, so we need some way to distinguish them, and this time it is a boolean.

clang/lib/Parse/ParseDeclCXX.cpp

3219–3226

I removed InConstantEvaluated

clang/lib/Parse/ParseStmt.cpp

1513–1516

In this case /*ShouldEnter=*/IsConstexpr, so the constant evaluation context is pushed only when it is a condition of constexpr if. The condition of constexpr if shall be a constant expression as per https://eel.is/c++draft/stmt.if#2

clang/lib/Sema/SemaDeclCXX.cpp

17962–18006

When we push/pop evaluation context here, it behaves synchronously with InitializerScopeRAII, in ParseDecl.cpp, which makes the evaluation of Actions.AddInitializerToDecl happen outside of the initializer expression evaluation context (e.g. initializer scope popped in 2581 and AddInitializerToDecl evaluated in 2592 in ParseDecl.cpp). This is causing a bug BEFORE this patch (https://godbolt.org/z/b18jxKT54 and the removed FIXME in test/SemaCXX/cxx2a-consteval.cpp) because we were pushing evaluation context if the variable isNonlocalVariable. This PR separates the handling of expression evaluation context of initializers from InitializerScopeRAII to resolve these bugs.

The arguable changes in diagnostics caused by this are the removals of
warn_uninit_self_reference_in_reference_init against constexpr int &n = n; (You mentioned) and
warn_impcast_integer_precision_constant against constexpr signed char a = 2*100;
Both are diagnosed by calling Sema::DiagRuntimeBehavior, and Sema::DiagIfReachable called by this intentionally avoids emitting diagnostics against initializer of constexpr variables. (https://github.com/llvm/llvm-project/blob/ab73bd3897b58ecde22ec5eea14b6252f2d69b6e/clang/lib/Sema/SemaExpr.cpp#L20712-L20719)
They were diagnosed BEFORE this patch because the expression evaluation context was outside of the initializer evaluation context, and it emitted false positives against cases like constexpr signed char a = true ? 3 : 200; (https://godbolt.org/z/9z1rer7E3)
I think if the evaluated result of constexpr variable initializer does not fit the variable type it should be diagnosed, but the logic should be added to where we handle constexpr variables.

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

1964

This is because it is diagnosed by Sema::DiagRuntimeBehavior
In this case constexpr evaluator is emitting an error, so I don't think the loss of this warning is problematic.
Please see my comment about the changes in ParseDeclCXX.cpp for details

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

27

Thanks!

[Mordante]

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

27

I really would like a regex. To me the current message misses an important piece of information; the true part. I care less about the rest of the message, but stripping the true means a warning like std::is_constant_evaluated' will always evaluate to FALSE would be valid too.

[cor3ntin]

clang/include/clang/Basic/DiagnosticSemaKinds.td

1566–1567

To be consistent with other tautological warnings

8849

clang/include/clang/Sema/Sema.h

1292

Right, thanks for clarifying, i missed that

clang/lib/Parse/ParseDecl.cpp

2440

Why are we looking at whether static vars are const qualified?

clang/lib/Parse/ParseStmt.cpp

1513–1516

I missed that, makes sense!

clang/lib/Sema/SemaDeclCXX.cpp

17962–18006

Thanks for the detailed explanation.
Separating InitializerScopeRAII from evaluation scope is something i support.
Did you try removing the test in DiagIfReachable, see how much breaks?
In any case, there are 2 fixme in that function already, that should cover us.
It might be useful to better describe these changes in the release notes / commit message

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp

96

this is a funny one, what's the history of that?

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

27

Agreed with Mordante

[philnik]

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp

96

Probably some code moving around. I think this was originally in another function.

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

27

We're not in the business of testing the compiler though. Taking a closer look, I'm not actually sure why this test exists at all. It doesn't seem like it tests anything useful w.r.t. the library. This has been added in 2fc5a78, but there the warning isn't checked, so that was clearly not the original intention.

[hazohelet]

clang/lib/Parse/ParseDecl.cpp

2440

void func() { // IsRuntimeEvaluated
	int        A = std::is_constant_evaluated(); // false
	const int  B = std::is_constant_evaluated(); // not tautology
	static int C = std::is_constant_evaluated(); // not tautology
}

Variable initializers can inherit the enclosing evaluation scope's IsRuntimeEvaluated attribute in most cases, but when the enclosing scope is IsRuntimeEvaluated and the variable is const-qualified or non-local, the initializer is not IsRuntimeEvaluated.
Manually setting context kind to PotentiallyEvaluated is redundant, so I'll remove it.

clang/lib/Sema/SemaDeclCXX.cpp

17962–18006

I forgot to write that this PR pushes ConstantEvaluated on constexpr var initializers and thus DiagRuntimeBehavior returns before calling DiagIfReachable.

Locally, I tried making DiagRuntimeBehavior emit diagnostics on constexpr var initializers. It causes test failure in 7 test files and the added diagnostics seem redundant.
I don't list all of them here, but especially problematic would be variable template: https://github.com/llvm/llvm-project/blob/e8dc9dcd7df798039ccf23d74343bf688b1fd648/clang/test/CXX/temp/temp.constr/temp.constr.constr/non-function-templates.cpp#L11-L16 . Clang would emit false positive about narrowing conversion every time it gets instantiated.
So, I don't think it's a good idea to let DiagRuntimeBehavior emit diagnostics on constexpr var initializers.
I'll better describe the change here, thanks.

[ldionne]

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

27

FWIW I agree, in fact I think we could probably use // ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=warning

[hazohelet]

Address review comments

• Rename tablegen name of the diagnostics to follow other tautological warnings
• Remove redundant modification of context kind to PotentiallyEvaluated
• Use regex for libcxx test part (tentative)

[hazohelet]

Regarding the clang CI failure, libcxx's __libcpp_is_constant_evaluated always returns false under C++03 or earlier, where constexpr isn't available.
(Code: https://github.com/llvm/llvm-project/blob/036a1b2202cb71aacfa72ef15145a88dc50a02cf/libcxx/include/__type_traits/is_constant_evaluated.h#L26-L28)
_LIBCPP_CONSTEXPR expands to nothing under C++03 mode, and thus this returns false every time as clang now says.
(Live demo: https://godbolt.org/z/oszebM5o5)
I'm not sure how I should fix it, so I would like to ask for help from libcxx folks.

[ldionne]

LGTM for libc++.

[cor3ntin]

This looks good to me modulo nitpicks.
When you land that, please make an issue on github for the missing narrowing warning, it seems important.

I'll wait before approving in case @aaron.ballman spot things i missed

clang/lib/Sema/SemaExpr.cpp

7079

I think DiagnoseTautologicalIsConstantEvaluated might be confusing without context, suggesting another name

clang/lib/Sema/SemaStmt.cpp

938–944

I think that might be somewhat nicer (make sure to run clang-format :))

[hazohelet]

In D155064#4514893, @cor3ntin wrote:

This looks good to me modulo nitpicks.
When you land that, please make an issue on github for the missing narrowing warning, it seems important.

I'll wait before approving in case @aaron.ballman spot things i missed

I've already prepared another patch to fix the narrowing issue. Should I add the diff to this patch or open another revision?

FWIW, I believe const bool c = std::is_constant_evaluated(); this particular case should also be diagnosed because it could be a common mistake as was mentioned in https://github.com/llvm/llvm-project/issues/43760#issuecomment-981022686.

[cor3ntin]

In D155064#4523024, @hazohelet wrote:

In D155064#4514893, @cor3ntin wrote:

This looks good to me modulo nitpicks.
When you land that, please make an issue on github for the missing narrowing warning, it seems important.

I'll wait before approving in case @aaron.ballman spot things i missed

I've already prepared another patch to fix the narrowing issue. Should I add the diff to this patch or open another revision?

I think merging the two patches would make sense, yes, that way we avoid regressions

FWIW, I believe const bool c = std::is_constant_evaluated(); this particular case should also be diagnosed because it could be a common mistake as was mentioned in https://github.com/llvm/llvm-project/issues/43760#issuecomment-981022686.

i think this is less pressing. doing that later (ie, for clang 18) is more reasonable. There are probably some interesting edge cases with constant initialization

[hazohelet]

Address comments from Corentin

• NFC stylistic changes
• Bring back narrowing warning on constexpr variables to avoid regression
• Newly diagnose narrowing conversions on constant-evaluated initializers in general (e..g immediate function context, and constexpr variable templates)

[cor3ntin]

clang/test/SemaCXX/vartemplate-lambda.cpp

17

This also looks like a regression.

The current error is much clearer, can you investigate?

<source>:3:22: error: constexpr variable 't<int>' must be initialized by a constant expression
    3 |   static constexpr T t = [](int f = T(7)){return f;}();
      |                      ^   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:6:12: note: in instantiation of static data member 'S::t<int>' requested here
    6 | int a = S::t<int>;
      |            ^
<source>:3:26: note: non-literal type 'S::(lambda at <source>:3:26)' cannot be used in a constant expression
    3 |   static constexpr T t = [](int f = T(7)){return f;}();
      |                          ^

Why do we emt 2 errors instead of a single note? Here the error is that the initializer is not a constant expression, everything else should be notes.

[hazohelet]

clang/test/SemaCXX/vartemplate-lambda.cpp

17

"lambda cannot be in constant expression" error is emitted from Sema against lambda expressions in constant-evaluated contexts in C++14 mode, and the note is emitted from constexpr evaluator.
The Sema-side error is emitted twice because it is emitted both before/after instantiation.
We can suppress one of them by ignoring it when sema is instantiating variable template initializer.
Or we can completely suppress this Sema error against initializers to avoid duplicate errors from Sema and constexpr evaluator.
I think "lambda cannot be in constant expression" Sema error is more understandable than the constexpr evaluator note "non-literal type cannot be in constant expression", so I think it is ok to keep one Sema error here.

[cor3ntin]

clang/test/SemaCXX/vartemplate-lambda.cpp

17

So maybe the issue is that we are not making the declaration invalid in sema when we get this error? Can you look into it?
any opinion @aaron.ballman

[hazohelet]

Address comments from Corentin

• When emitting "lambda expression may not appear inside of a constant expression" error from Sema::PopExpressionEvaluationContext, mark the variable declaration as invalid if the popped context is initializer evaluation context.
• This stops constexpr evaluator from evaluating the initializer and emitting duplicate errors.

[hazohelet]

clang/test/SemaCXX/vartemplate-lambda.cpp

17

I updated the patch to keep a single sema error here and stop constant interpreter from evaluating the initializer by marking declaration invalid. I like having one sema error here.

[cor3ntin]

clang/test/SemaCXX/vartemplate-lambda.cpp

17

I'll wait a bit to approve because I'd like a second opinion, but otherwise I think we are in pretty good shape in this patch!

[hazohelet]

Fixed libc++ tests (NFC)
There's no change in clang codes.
This change should not change the semantics of all relevant codes because this only replaces tautologically-false uses of is_constant_evaluated() with false through macros.
These tautologically-false uses in tests are in if-condition expression inside non-constexpr functions.

• Make __libcpp_is_constant_evaluated() in libcxx/include/__type_traits/is_constant_evaluated.h return false instead of __builtin_is_constant_evaluated() in pre-C++11 mode.
• Set TEST_IS_CONSTANT_EVALUATED macro to false in pre-C++11 mode.
• Remove all tautologically-false use of TEST_IS_CONSTANT_EVALUATED macro in tests by defining 4 more macros TEST_IS_CONSTANT_EVALUATED_CXX{14, 17, 20, 23} and replacing former use of TEST_IS_CONSTANT_EVALUATED with the corresponding one.

(Git diff context is not complete in order to fit within ~8MB patch file size limit of Phabricator)

[hazohelet]

@ldionne @philnik @Mordante
Is this way of fixing libc++ tests OK from libc++ side? If there's better way to fix them I am happy to follow it.

[hazohelet]

I've noticed several shortcoming/limitations of this patch.

1. Function arguments: When we parse the arguments to a function call, the callee isn't still resolved, so we don't know whether it's consteval. If the callee is consteval, its argument is known to be constant-evaluated regardless of its surrounding evaluation context.

e.g.

consteval int ce(int n){ return n;};
int f() {
	int a = ce(__builtin_is_constant_evaluated()); // tautologically true
}

2. init-statement of constexpr-if:

The condition is required to be a constant expression, but the init-stmt before it isn't.
e.g. Given if constexpr (InitStmt; Cond) {}, InitStmt is evaluated in the surrounding evaluation context.
If the init-statement is a declaration we can push initializer evaluation context like we do in other variables. However, if the init-statement is an expression, when clang parses the expression, clang doesn't know whether it is parsing the init-statement or the condition. https://github.com/llvm/llvm-project/blob/e3c57fdd8439ba82c67347629a3c66f293e1f3d0/clang/lib/Parse/ParseExprCXX.cpp#L2102

If we are to handle these cases with perfection, we need to defer warning emissions, but I'm skeptical about the value we obtain from this effort.

For the first problem, we can make IsRuntimeEvaluated false while parsing arguments to avoid emitting incorrect diagnostics although it makes false negatives on tautologically-false uses in arguments.
The second problem is difficult because we cannot avoid incorrect diagnostics in InitStmt expression of constexpr-if with a simple fix. But I think it's acceptable for the time being because it would be a pretty rare case to use is_constant_evaluated there.

@cor3ntin
BTW, can I separate the initializer evaluation context bug fix part to make another PR? Another patch I'm working on locally also suffers from the evaluation context bug, and I want to land that part relatively soon.
Also, it might be nice to separate the NFC libc++ test modifications I recently uploaded because it's too much despite being NFC. Or we can turn off this tautology warning against macros. Do you think it's reasonable?

[hazohelet]

• Tentatively disable the warning on macros so as not to make a fuss in libc++ tests.
• Fixed incorrect output in arguments.
• Fixed incorrect output in declaration of init-statement of constexpr-if condition.
• Added tests with FIXMEs about the limitation I mentioned before.

[hazohelet]

Resolved the constexpr-if init-statement expression evaluation context problem.

[cjdb]

clang/test/SemaCXX/warn-constant-evaluated-constexpr.cpp

38

This should also generate a fix-it hint, since we can automate the fix.

clang/test/SemaCXX/warn-tautological-meta-constant.cpp

19

I'm not a fan of this diagnostic text: it doesn't offer insight into what's gone wrong or provide actionable feedback on how to fix the code.

[hazohelet]

Thanks for the feedback.

clang/test/SemaCXX/warn-constant-evaluated-constexpr.cpp

38

I think it's reasonable to show fix-it hint to remove constexpr here.
For that we need to store the source range of constexpr in evaluation context record if it's constexpr-if condition.

clang/test/SemaCXX/warn-tautological-meta-constant.cpp

19

I agree that the current wording (... will always evaluate to true in this context) is not great, but I'm not sure how to improve it because the reason to see this diagnostic would mostly be a misunderstanding of the C++ const semantics.
At least, if the appearance of is_constant_evaluated is in the condition of constexpr-if, probably we can say they should remove constexpr.
CC @aaron.ballman

[hazohelet]

Address comments from Chris

• Generate fix-it hint to remove constexpr in constexpr-if

Added SourceLocation field to Sema that saves the location of constexpr in constexpr-if.

[hazohelet]

rebase to upstream to run ci

[Mordante]

libcxx/include/__type_traits/is_constant_evaluated.h

31

Why is this needed? Does this mean the builtin will fail in C++03 mode?

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

27

We're not in the business of testing the compiler though. Taking a closer look, I'm not actually sure why this test exists at all. It doesn't seem like it tests anything useful w.r.t. the library. This has been added in 2fc5a78, but there the warning isn't checked, so that was clearly not the original intention.

I agree. But to me this test tests whether

[hazohelet]

libcxx/include/__type_traits/is_constant_evaluated.h

31

__libcpp_is_constant_evaluated always returns false under C++03 or earlier, where constexpr isn't available. This is a fix to run libc++ tests without seeing warnings from clang with this patch.
(Live demo: https://godbolt.org/z/oszebM5o5)

[Mordante]

libcxx/include/__type_traits/is_constant_evaluated.h

31

I see can you add a comment in that regard? To me it looks like the builtin fails in C++03, where returning false indeed is always the right answer.

[hazohelet]

Address comments from Mark

• Added comment about the need of macro use in libc++ include file.

[philnik]

libcxx/include/__type_traits/is_constant_evaluated.h

31

https://godbolt.org/z/bafeeY7b7 shows that __builtin_is_constant_evaluated() doesn't always return false in C++03, so this change seems wrong to me.

[hazohelet]

libcxx/include/__type_traits/is_constant_evaluated.h

31

This is NFC.
The problem is that __libcpp_is_constant_evaluated() has different semantics from __builtin_is_constant_evaluated() in C++03.
The cause of this tautological-falsity here is whether __libcpp_is_constant_evaluated() is constexpr-qualified or not.
_LIBCPP_CONSTEXPR macro expands to constexpr since C++11, but in pre-C++11 mode, it expands to nothing.
So in C++03 mode this function is something like bool __libcpp_is_constant_evaluated() { return __builtin_is_constant_evaluated(); }, where it is tautologically-false because it is not constexpr-qualified.

As you mentioned, __builtin_is_constant_evaluated does not change its semantics depending on C++ versions.
However, __libcpp_is_constant_evaluated() always returns false in C++03 as in https://godbolt.org/z/oszebM5o5

[hazohelet]

Ping

[hazohelet]

Ping

[cor3ntin]

@philnik @Mordante were the libc++ concerns addressed?

[ldionne]

The libc++ changes are reasonable. We could discuss more around how to handle C++03 in __libcpp_is_constant_evaluated but I don't think it's worth delaying this patch for that.

libcxx/include/__type_traits/is_constant_evaluated.h

31

This explanation makes sense to me. I think it's reasonable to return false unconditionally in C++03 mode.

[cor3ntin]

LGTM, thanks!

[hazohelet]

After discussion in https://github.com/llvm/llvm-project/pull/66222, I noticed I had misunderstood the recursiveness of constant-evaluated context.
I was pushing constant-evaluating on the lambda body when it appears inside constant-evaluated context. This was causing false positive in

constexpr auto cexpr_lambda = []() {
  return __builtin_is_constant_evaluated();
}

I fixed this by stopping pushing constant-evaluated context (See SemaLambda.cpp). Instead, I am pushing immediate-function context when the outer evaluation context is immediate function context as well as when it's consteval lambda so that we can warn on

consteval void f() {
	auto lam = []() { return __builtin_is_constant_evaluated(); };
}

@cor3ntin
Should this patch wait for https://github.com/llvm/llvm-project/pull/66222?

[cor3ntin]

@hazohelet Nah, feel free to merge that first! Thanks

[hans]

We saw a new warning in Chromium after this, and I wasn't sure if that's intentional:

#include <limits>

template <typename T> float foo(T input) {
  if (sizeof(T) > 2) {
    return 42;
  } else {
    constexpr float inverseMax = 1.0f / std::numeric_limits<T>::max();
    return input * inverseMax;
  }
}

float f() {
  return foo(1);
}
$ build/bin/clang -c /tmp/a.cc
/tmp/a.cc:7:41: warning: implicit conversion from 'int' to 'float' changes value from 2147483647 to 2147483648 [-Wimplicit-const-int-float-conversion]
    7 |     constexpr float inverseMax = 1.0f / std::numeric_limits<T>::max();
      |                                       ~ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/tmp/a.cc:13:10: note: in instantiation of function template specialization 'foo<int>' requested here
   13 |   return foo(1);
      |          ^
1 warning generated.

Note that the branch with the conversion can be determined to not be taken based on the template argument.

Using if constexpr suppresses the warning, but I'm not sure if that should really be necessary?

(Our tracking bug is https://crbug.com/1487142)

[abrachet]

struct S {
  template <typename F>
  constexpr bool a(F&& f) const {
    // This works previously in clang and on gcc
    return f(1); // no matching function for call to object of type ...
  }
};

template <typename>
struct S1 {
  void f() {
    auto test = [] (auto) {
      S s;
      // Remove this constexpr and it compiles fine.
      constexpr auto f = [](auto&&) { return true; };
      return s.a(f);
    };
    test(1);
  }
};

void a() {
  S1<int> s;
  s.f();
}

The following doesn't compile after this change (I've verified that reverting makes the issue go away). This code also compiles fine on gcc. Would you mind taking a look?

[sammccall]

Hi, I'm afraid this breaks valid code with false diagnostics, I need to revert.

Specifically it complains about missing lambda captures for values that are in fact arguments to the lambda:

template <typename F>
constexpr void inner(F f) {
  return f(0);
}

template <typename F>
void outer(F f) {
  inner([](auto I) {
    constexpr auto kFuncs = [](F& g) { return g(); };
    (void) kFuncs;
  });
}

void entry() {
  outer([&] {});
}

$ bin/clang++ -fsyntax-only ~/test.cc

/usr/local/google/home/sammccall/test.cc:9:47: error: variable 'g' cannot be implicitly captured in a lambda with no capture-default specified
    9 |     constexpr auto kFuncs = [](F& g) { return g(); };
      |                                               ^
/usr/local/google/home/sammccall/test.cc:9:29: note: while substituting into a lambda expression here
    9 |     constexpr auto kFuncs = [](F& g) { return g(); };
      |                             ^
/usr/local/google/home/sammccall/test.cc:3:10: note: in instantiation of function template specialization 'outer((lambda at /usr/local/google/home/sammccall/test.cc:15:9))::(anonymous class)::operator()<int>' requested here
    3 |   return f(0);
      |          ^
/usr/local/google/home/sammccall/test.cc:8:3: note: in instantiation of function template specialization 'inner<(lambda at /usr/local/google/home/sammccall/test.cc:8:9)>' requested here
    8 |   inner([](auto I) {
      |   ^
/usr/local/google/home/sammccall/test.cc:15:3: note: in instantiation of function template specialization 'outer<(lambda at /usr/local/google/home/sammccall/test.cc:15:9)>' requested here
   15 |   outer([&] {});
      |   ^
/usr/local/google/home/sammccall/test.cc:9:35: note: 'g' declared here
    9 |     constexpr auto kFuncs = [](F& g) { return g(); };
      |                                   ^
/usr/local/google/home/sammccall/test.cc:9:29: note: lambda expression begins here
    9 |     constexpr auto kFuncs = [](F& g) { return g(); };
      |                             ^
/usr/local/google/home/sammccall/test.cc:9:30: note: capture 'g' by value
    9 |     constexpr auto kFuncs = [](F& g) { return g(); };
      |                              ^
      |                              g
/usr/local/google/home/sammccall/test.cc:9:30: note: capture 'g' by reference
    9 |     constexpr auto kFuncs = [](F& g) { return g(); };
      |                              ^
      |                              &g
/usr/local/google/home/sammccall/test.cc:9:30: note: default capture by value
    9 |     constexpr auto kFuncs = [](F& g) { return g(); };
      |                              ^
      |                              =
/usr/local/google/home/sammccall/test.cc:9:30: note: default capture by reference
    9 |     constexpr auto kFuncs = [](F& g) { return g(); };
      |                              ^
      |                              &
1 error generated.

[hazohelet]

In D155064#4651306, @hans wrote:

We saw a new warning in Chromium after this, and I wasn't sure if that's intentional:

#include <limits>

template <typename T> float foo(T input) {
  if (sizeof(T) > 2) {
    return 42;
  } else {
    constexpr float inverseMax = 1.0f / std::numeric_limits<T>::max();
    return input * inverseMax;
  }
}

float f() {
  return foo(1);
}
$ build/bin/clang -c /tmp/a.cc
/tmp/a.cc:7:41: warning: implicit conversion from 'int' to 'float' changes value from 2147483647 to 2147483648 [-Wimplicit-const-int-float-conversion]
    7 |     constexpr float inverseMax = 1.0f / std::numeric_limits<T>::max();
      |                                       ~ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/tmp/a.cc:13:10: note: in instantiation of function template specialization 'foo<int>' requested here
   13 |   return foo(1);
      |          ^
1 warning generated.

Note that the branch with the conversion can be determined to not be taken based on the template argument.

Using if constexpr suppresses the warning, but I'm not sure if that should really be necessary?

(Our tracking bug is https://crbug.com/1487142)

It's unintended, but the cause is that I started using Sema::Diag instead of Sema::DiagRuntimeBehavior, in narrowing check for constexpr variable initializers, and thus lost the reachability analysis. It will be a simple fix, but would involve some adaptations to Sema::DiagIfReachable. I'll fix it after other concerns are resolved.

[hazohelet]

Thanks for the report about the errors in lambdas. The culprit is clang/lib/Sema/SemaTemplateInstantiateDecl.cpp. I am pushing constant-evaluated context if the instantiated variable is constexpr variable, and somehow it causes those errors. I'll take deeper look into them tomorrow.

[hazohelet]

Thank you for the revert!

This looks like a general issue of clang on template deduction in constant-evaluated context (https://godbolt.org/z/zTro7Ycfa). Pushing constant-evaluated context against initializer of instantiated constexpr variables made this bug appear in broader scenarios.
I can circumvent this problem by not pushing constant-evaluated context on instantiated constexpr variable initializers, but that in turn would force me to do tricky workaround in warnings on narrowing conversions in global constexpr variable templates.

@cor3ntin
The constant-evaluated-context miscompilation bisected to https://reviews.llvm.org/D140554
Is this the intended result of that patch?
I'm at lost how to proceed further on this patch. The only way looks like some workarounds in narrowing conversion warning mechanism, but is it acceptable?

clang/docs/ReleaseNotes.rst

 
 Attribute Changes in Clang
 --------------------------
 
 Improvements to Clang's diagnostics
 -----------------------------------
 - Clang constexpr evaluator now prints template arguments when displaying
   template-specialization function calls.
+- Clang now diagnoses wider cases of tautological use of consteval if or
+  ``std::is_constant_evaluated``. This also suppresses some false positives.
+  (`#43760: <https://github.com/llvm/llvm-project/issues/43760>`_)
+  (`#51567: <https://github.com/llvm/llvm-project/issues/51567>`_)
+- Clang now diagnoses narrowing implicit conversions on variable initializers in immediate
+  function context and on constexpr variable template initializers.
 
 Bug Fixes in This Version
 -------------------------
 - Fixed an issue where a class template specialization whose declaration is
   instantiated in one module and whose definition is instantiated in another
   module may end up with members associated with the wrong declaration of the
   class, which can result in miscompiles in some cases.
 

clang/include/clang/Basic/DiagnosticASTKinds.td

def warn_constexpr_unscoped_enum_out_of_range : Warning<
   "enumeration type %3">, DefaultError, InGroup<DiagGroup<"enum-constexpr-conversion">>;
 
 // This is a temporary diagnostic, and shall be removed once our
 // implementation is complete, and like the preceding constexpr notes belongs
 // in Sema.
 def note_unimplemented_constexpr_lambda_feature_ast : Note<
     "unimplemented constexpr lambda feature: %0 (coming soon!)">;
 
-def warn_is_constant_evaluated_always_true_constexpr : Warning<
-  "'%0' will always evaluate to 'true' in a manifestly constant-evaluated expression">,
-  InGroup<DiagGroup<"constant-evaluated">>;
-
 // inline asm related.
 let CategoryName = "Inline Assembly Issue" in {
   def err_asm_invalid_escape : Error<
     "invalid %% escape in inline assembly string">;
   def err_asm_unknown_symbolic_operand_name : Error<
     "unknown symbolic operand name in inline assembly string">;
 
   def err_asm_unterminated_symbolic_operand_name : Error<

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_static_assert_invalid_mem_fn_ret_ty : Error<
   "function returning an object convertible to '%select{std::size_t|const char *}0'">;
 def warn_static_assert_message_constexpr : Warning<
   "the message in this static assertion is not a "
   "constant expression">,
   DefaultError, InGroup<DiagGroup<"invalid-static-assert-message">>;
 def err_static_assert_message_constexpr : Error<
   "the message in a static assertion must be produced by a "
   "constant expression">;
 
-def warn_consteval_if_always_true : Warning<
-  "consteval if is always true in an %select{unevaluated|immediate}0 context">,
+def warn_tautological_consteval_if : Warning<
+  "consteval if is always %select{true|false}0 in this context">,
   InGroup<DiagGroup<"redundant-consteval-if">>;
 
 def ext_inline_variable : ExtWarn<
   "inline variables are a C++17 extension">, InGroup<CXX17>;
 def warn_cxx14_compat_inline_variable : Warning<
   "inline variables are incompatible with C++ standards before C++17">,
   DefaultIgnore, InGroup<CXXPre17Compat>;
 
def warn_unused_constructor_msg : Warning<
   "ignoring temporary created by a constructor declared with %0 attribute: %1">,
   InGroup<UnusedValue>;
 def warn_side_effects_unevaluated_context : Warning<
   "expression with side effects has no effect in an unevaluated context">,
   InGroup<UnevaluatedExpression>;
 def warn_side_effects_typeid : Warning<
   "expression with side effects will be evaluated despite being used as an "
   "operand to 'typeid'">, InGroup<PotentiallyEvaluatedExpression>;
+def warn_tautological_is_constant_evaluated : Warning<
+  "'%select{std::is_constant_evaluated|__builtin_is_constant_evaluated}0' will always evaluate to %select{false|true}1 in this context">,
+  InGroup<DiagGroup<"constant-evaluated">>;
 def warn_unused_result : Warning<
   "ignoring return value of function declared with %0 attribute">,
   InGroup<UnusedResult>;
 def warn_unused_result_msg : Warning<
   "ignoring return value of function declared with %0 attribute: %1">,
   InGroup<UnusedResult>;
 def warn_unused_result_typedef_unsupported_spelling : Warning<
   "'[[%select{nodiscard|gnu::warn_unused_result}0]]' attribute ignored when "

clang/include/clang/Sema/Sema.h

enum class ExpressionEvaluationContext {
     /// we would like to provide diagnostics (e.g., passing non-POD arguments
     /// through varargs) but do not want to mark declarations as "referenced"
     /// until the default argument is used.
     PotentiallyEvaluatedIfUsed
   };
 
   using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>;
 
   /// Data structure used to record current or nested
   /// expression evaluation contexts.
   struct ExpressionEvaluationContextRecord {
     /// The expression evaluation context.
     ExpressionEvaluationContext Context;
 
     /// Whether the enclosing context needed a cleanup.
     CleanupInfo ParentCleanup;
 
enum ExpressionKind {
       EK_Decltype, EK_TemplateArgument, EK_Other
     } ExprContext;
 
     // A context can be nested in both a discarded statement context and
     // an immediate function context, so they need to be tracked independently.
     bool InDiscardedStatement;
     bool InImmediateFunctionContext;
     bool InImmediateEscalatingFunctionContext;
+    // The immediate occurances of consteval if or std::is_constant_evaluated()
+    // are tautologically false
+    bool IsRuntimeEvaluated;
 
     bool IsCurrentlyCheckingDefaultArgumentOrInitializer = false;
 
     // When evaluating immediate functions in the initializer of a default
     // argument or default member initializer, this is the declaration whose
     // default initializer is being evaluated and the location of the call
     // or constructor definition.
     struct InitializationContext {
ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
                                       unsigned NumCleanupObjects,
                                       CleanupInfo ParentCleanup,
                                       Decl *ManglingContextDecl,
                                       ExpressionKind ExprContext)
         : Context(Context), ParentCleanup(ParentCleanup),
           NumCleanupObjects(NumCleanupObjects), NumTypos(0),
           ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext),
           InDiscardedStatement(false), InImmediateFunctionContext(false),
-          InImmediateEscalatingFunctionContext(false) {}
+          InImmediateEscalatingFunctionContext(false),
+          IsRuntimeEvaluated(false) {}
 
     bool isUnevaluated() const {
       return Context == ExpressionEvaluationContext::Unevaluated ||
              Context == ExpressionEvaluationContext::UnevaluatedAbstract ||
              Context == ExpressionEvaluationContext::UnevaluatedList;
     }
 
     bool isConstantEvaluated() const {

clang/lib/AST/ExprConstant.cpp

       // a branch on __builtin_constant_p(expr).
       return Success(false, E);
     }
     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
     return false;
   }
 
   case Builtin::BI__builtin_is_constant_evaluated: {
-    const auto *Callee = Info.CurrentCall->getCallee();
-    if (Info.InConstantContext && !Info.CheckingPotentialConstantExpression &&
-        (Info.CallStackDepth == 1 ||
-         (Info.CallStackDepth == 2 && Callee->isInStdNamespace() &&
-          Callee->getIdentifier() &&
-          Callee->getIdentifier()->isStr("is_constant_evaluated")))) {
-      // FIXME: Find a better way to avoid duplicated diagnostics.
-      if (Info.EvalStatus.Diag)
-        Info.report((Info.CallStackDepth == 1) ? E->getExprLoc()
-                                               : Info.CurrentCall->CallLoc,
-                    diag::warn_is_constant_evaluated_always_true_constexpr)
-            << (Info.CallStackDepth == 1 ? "__builtin_is_constant_evaluated"
-                                         : "std::is_constant_evaluated");
-    }
-
     return Success(Info.InConstantContext, E);
   }
 
   case Builtin::BI__builtin_ctz:
   case Builtin::BI__builtin_ctzl:
   case Builtin::BI__builtin_ctzll:
   case Builtin::BI__builtin_ctzs: {
     APSInt Val;

clang/lib/Parse/ParseDecl.cpp

 Decl *Parser::ParseDeclarationAfterDeclarator(
     Declarator &D, const ParsedTemplateInfo &TemplateInfo) {
   if (ParseAsmAttributesAfterDeclarator(D))
     return nullptr;
 
   return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
 }
 
+/// Determine whether the given declaration is a global variable or
+/// static data member.
+static bool isNonlocalVariable(const Decl *D) {
+  if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
+    return Var->hasGlobalStorage();
+
+  return false;
+}
+
 Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
     Declarator &D, const ParsedTemplateInfo &TemplateInfo, ForRangeInit *FRI) {
   // RAII type used to track whether we're inside an initializer.
   struct InitializerScopeRAII {
     Parser &P;
     Declarator &D;
     Decl *ThisDecl;
 
void pop() {
           S = P.getCurScope();
         P.Actions.ActOnCXXExitDeclInitializer(S, ThisDecl);
         if (S)
           P.ExitScope();
       }
       ThisDecl = nullptr;
     }
   };
+  struct EnterInitializerExpressionEvaluationContext {
+    Sema &S;
+    bool Entered;
+
+    EnterInitializerExpressionEvaluationContext(Sema &S, Declarator &D,
+                                                Decl *ThisDecl)
+        : S(S), Entered(false) {
+      if (ThisDecl && S.getLangOpts().CPlusPlus && !ThisDecl->isInvalidDecl()) {
+        Entered = true;
+        bool RuntimeEvaluated = S.ExprEvalContexts.back().IsRuntimeEvaluated;
+        Sema::ExpressionEvaluationContext NewEEC =
+            S.ExprEvalContexts.back().Context;
+        if ((D.getDeclSpec().getTypeQualifiers() == DeclSpec::TQ_const ||
+             isNonlocalVariable(ThisDecl)) &&
+            S.ExprEvalContexts.back().IsRuntimeEvaluated) {
+          RuntimeEvaluated = false;
+        }
+        if (D.getDeclSpec().hasConstexprSpecifier()) {
+          NewEEC = Sema::ExpressionEvaluationContext::ConstantEvaluated;
+          RuntimeEvaluated = false;
+        }
+        S.PushExpressionEvaluationContext(NewEEC, ThisDecl);
+        S.ExprEvalContexts.back().IsRuntimeEvaluated = RuntimeEvaluated;
+      }
+    }
+    ~EnterInitializerExpressionEvaluationContext() {
+      if (Entered)
+        S.PopExpressionEvaluationContext();
+    }
+  };
 
   enum class InitKind { Uninitialized, Equal, CXXDirect, CXXBraced };
   InitKind TheInitKind;
   // If a '==' or '+=' is found, suggest a fixit to '='.
   if (isTokenEqualOrEqualTypo())
     TheInitKind = InitKind::Equal;
   else if (Tok.is(tok::l_paren))
     TheInitKind = InitKind::CXXDirect;
if (Tok.is(tok::kw_delete)) {
       if (D.isFunctionDeclarator())
         Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
           << 0 /* default */;
       else
         Diag(ConsumeToken(), diag::err_default_special_members)
             << getLangOpts().CPlusPlus20;
     } else {
       InitializerScopeRAII InitScope(*this, D, ThisDecl);
+      EnterInitializerExpressionEvaluationContext InitEC(Actions, D, ThisDecl);
 
       if (Tok.is(tok::code_completion)) {
         cutOffParsing();
         Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
         Actions.FinalizeDeclaration(ThisDecl);
         return nullptr;
       }
 
Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
   case InitKind::CXXDirect: {
     // Parse C++ direct initializer: '(' expression-list ')'
     BalancedDelimiterTracker T(*this, tok::l_paren);
     T.consumeOpen();
 
     ExprVector Exprs;
 
     InitializerScopeRAII InitScope(*this, D, ThisDecl);
+    EnterInitializerExpressionEvaluationContext InitEC(Actions, D, ThisDecl);
 
     auto ThisVarDecl = dyn_cast_or_null<VarDecl>(ThisDecl);
     auto RunSignatureHelp = [&]() {
       QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
           ThisVarDecl->getType()->getCanonicalTypeInternal(),
           ThisDecl->getLocation(), Exprs, T.getOpenLocation(),
           /*Braced=*/false);
       CalledSignatureHelp = true;
case InitKind::CXXDirect: {
     }
     break;
   }
   case InitKind::CXXBraced: {
     // Parse C++0x braced-init-list.
     Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
 
     InitializerScopeRAII InitScope(*this, D, ThisDecl);
+    EnterInitializerExpressionEvaluationContext InitEC(Actions, D, ThisDecl);
 
     PreferredType.enterVariableInit(Tok.getLocation(), ThisDecl);
     ExprResult Init(ParseBraceInitializer());
 
     InitScope.pop();
 
     if (Init.isInvalid()) {
       Actions.ActOnInitializerError(ThisDecl);

clang/lib/Parse/ParseDeclCXX.cpp

 ///     braced-init-list
 ///
 ///   defaulted/deleted function-definition:
 ///     '=' 'default'
 ///     '=' 'delete'
 ///
 /// Prior to C++0x, the assignment-expression in an initializer-clause must
 /// be a constant-expression.
 ExprResult Parser::ParseCXXMemberInitializer(Decl *D, bool IsFunction,
                                              SourceLocation &EqualLoc) {
   assert(Tok.isOneOf(tok::equal, tok::l_brace) &&
          "Data member initializer not starting with '=' or '{'");
 
+  bool IsConstexpr = false;
+  if (const auto *VD = dyn_cast_if_present<VarDecl>(D))
+    IsConstexpr = VD->isConstexpr();
+
   EnterExpressionEvaluationContext Context(
       Actions,
-      isa_and_present<FieldDecl>(D)
+      IsConstexpr ? Sema::ExpressionEvaluationContext::ConstantEvaluated
+      : isa_and_present<FieldDecl>(D)
           ? Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed
           : Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
       D);
   Actions.ExprEvalContexts.back().InImmediateEscalatingFunctionContext = true;
   if (TryConsumeToken(tok::equal, EqualLoc)) {
     if (Tok.is(tok::kw_delete)) {
       // In principle, an initializer of '= delete p;' is legal, but it will
       // never type-check. It's better to diagnose it as an ill-formed
       // expression than as an ill-formed deleted non-function member. An
       // initializer of '= delete p, foo' will never be parsed, because a
       // top-level comma always ends the initializer expression.
       const Token &Next = NextToken();

clang/lib/Parse/ParseStmt.cpp

StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
 
   // Parse the condition.
   StmtResult InitStmt;
   Sema::ConditionResult Cond;
   SourceLocation LParen;
   SourceLocation RParen;
   std::optional<bool> ConstexprCondition;
   if (!IsConsteval) {
+    EnterExpressionEvaluationContext Consteval(
+        Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated,
+        /*LambdaContextDecl=*/nullptr,
+        Sema::ExpressionEvaluationContextRecord::EK_Other,
+        /*ShouldEnter=*/IsConstexpr);
 
     if (ParseParenExprOrCondition(&InitStmt, Cond, IfLoc,
                                   IsConstexpr ? Sema::ConditionKind::ConstexprIf
                                               : Sema::ConditionKind::Boolean,
                                   LParen, RParen))
       return StmtError();
 
     if (IsConstexpr)
StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
   StmtResult ThenStmt;
   {
     bool ShouldEnter = ConstexprCondition && !*ConstexprCondition;
     Sema::ExpressionEvaluationContext Context =
         Sema::ExpressionEvaluationContext::DiscardedStatement;
     if (NotLocation.isInvalid() && IsConsteval) {
       Context = Sema::ExpressionEvaluationContext::ImmediateFunctionContext;
       ShouldEnter = true;
+    } else if (NotLocation.isValid() && IsConsteval) {
+      Context = Actions.ExprEvalContexts.back().Context;
+      ShouldEnter = true;
     }
 
     EnterExpressionEvaluationContext PotentiallyDiscarded(
         Actions, Context, nullptr,
         Sema::ExpressionEvaluationContextRecord::EK_Other, ShouldEnter);
+    if (NotLocation.isValid() && IsConsteval)
+      Actions.ExprEvalContexts.back().IsRuntimeEvaluated = true;
     ThenStmt = ParseStatement(&InnerStatementTrailingElseLoc);
   }
 
   if (Tok.isNot(tok::kw_else))
     MIChecker.Check();
 
   // Pop the 'if' scope if needed.
   InnerScope.Exit();
if (Tok.is(tok::kw_else)) {
 
     MisleadingIndentationChecker MIChecker(*this, MSK_else, ElseLoc);
     bool ShouldEnter = ConstexprCondition && *ConstexprCondition;
     Sema::ExpressionEvaluationContext Context =
         Sema::ExpressionEvaluationContext::DiscardedStatement;
     if (NotLocation.isValid() && IsConsteval) {
       Context = Sema::ExpressionEvaluationContext::ImmediateFunctionContext;
       ShouldEnter = true;
+    } else if (NotLocation.isInvalid() && IsConsteval) {
+      Context = Actions.ExprEvalContexts.back().Context;
+      ShouldEnter = true;
     }
 
     EnterExpressionEvaluationContext PotentiallyDiscarded(
         Actions, Context, nullptr,
         Sema::ExpressionEvaluationContextRecord::EK_Other, ShouldEnter);
+    if (NotLocation.isInvalid() && IsConsteval)
+      Actions.ExprEvalContexts.back().IsRuntimeEvaluated = true;
     ElseStmt = ParseStatement();
 
     if (ElseStmt.isUsable())
       MIChecker.Check();
 
     // Pop the 'else' scope if needed.
     InnerScope.Exit();
   } else if (Tok.is(tok::code_completion)) {

clang/lib/Sema/SemaChecking.cpp

     if (LHS->getValue() != 0 && RHS->getValue() != 0)
       S.Diag(ExprLoc, diag::warn_integer_constants_in_conditional_always_true);
   }
 }
 
 static void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
                                     SourceLocation CC,
                                     bool *ICContext = nullptr,
-                                    bool IsListInit = false) {
+                                    bool IsListInit = false,
+                                    bool IsConstexprInit = false) {
   if (E->isTypeDependent() || E->isValueDependent()) return;
 
   const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr();
   const Type *Target = S.Context.getCanonicalType(T).getTypePtr();
   if (Source == Target) return;
   if (Target->isDependentType()) return;
 
   // If the conversion context location is invalid don't complain. We also

                 llvm::APFloat::rmNearestTiesToEven);
 
         if (ConversionStatus != llvm::APFloat::opOK) {
           SmallString<32> PrettySourceValue;
           SourceInt->toString(PrettySourceValue, 10);
           SmallString<32> PrettyTargetValue;
           TargetFloatValue.toString(PrettyTargetValue, TargetPrecision);
 
-          S.DiagRuntimeBehavior(
-              E->getExprLoc(), E,
+          PartialDiagnostic PD =
               S.PDiag(diag::warn_impcast_integer_float_precision_constant)
-                  << PrettySourceValue << PrettyTargetValue << E->getType() << T
-                  << E->getSourceRange() << clang::SourceRange(CC));
+              << E->getSourceRange() << clang::SourceRange(CC);
+          if (IsConstexprInit)
+            S.Diag(E->getExprLoc(), PD);
+          else
+            S.DiagRuntimeBehavior(E->getExprLoc(), E, PD);
         }
       } else {
         // Otherwise, the implicit conversion may lose precision.
         DiagnoseImpCast(S, E, T, CC,
                         diag::warn_impcast_integer_float_precision);
       }
     }
   }

       Value = Result.Val.getInt();
 
       if (S.SourceMgr.isInSystemMacro(CC))
         return;
 
       std::string PrettySourceValue = toString(Value, 10);
       std::string PrettyTargetValue = PrettyPrintInRange(Value, TargetRange);
 
-      S.DiagRuntimeBehavior(
-          E->getExprLoc(), E,
+      PartialDiagnostic PD =
           S.PDiag(diag::warn_impcast_integer_precision_constant)
-              << PrettySourceValue << PrettyTargetValue << E->getType() << T
-              << E->getSourceRange() << SourceRange(CC));
+          << E->getSourceRange() << SourceRange(CC);
+      if (IsConstexprInit)
+        S.Diag(E->getExprLoc(), PD);
+      else
+        S.DiagRuntimeBehavior(E->getExprLoc(), E, PD);
       return;
     }
 
     // People want to build with -Wshorten-64-to-32 and not -Wconversion.
     if (S.SourceMgr.isInSystemMacro(CC))
       return;
 
     if (TargetRange.Width == 32 && S.Context.getIntWidth(E->getType()) == 64)

     Expr::EvalResult Result;
     if (E->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects) &&
         !S.SourceMgr.isInSystemMacro(CC)) {
       llvm::APSInt Value = Result.Val.getInt();
       if (isSameWidthConstantConversion(S, E, T, CC)) {
         std::string PrettySourceValue = toString(Value, 10);
         std::string PrettyTargetValue = PrettyPrintInRange(Value, TargetRange);
 
-        S.DiagRuntimeBehavior(
-            E->getExprLoc(), E,
+        PartialDiagnostic PD =
             S.PDiag(diag::warn_impcast_integer_precision_constant)
-                << PrettySourceValue << PrettyTargetValue << E->getType() << T
-                << E->getSourceRange() << SourceRange(CC));
+            << E->getSourceRange() << SourceRange(CC);
+        if (IsConstexprInit)
+          S.Diag(E->getExprLoc(), PD);
+        else
+          S.DiagRuntimeBehavior(E->getExprLoc(), E, PD);
         return;
       }
     }
 
     // Fall through for non-constants to give a sign conversion warning.
   }
 
   if ((!isa<EnumType>(Target) || !isa<EnumType>(Source)) &&

   // Examine, but don't traverse into the source expression of an
   // OpaqueValueExpr, since it may have multiple parents and we don't want to
   // emit duplicate diagnostics. Its fine to examine the form or attempt to
   // evaluate it in the context of checking the specific conversion to T though.
   if (auto *OVE = dyn_cast<OpaqueValueExpr>(E))
     if (auto *Src = OVE->getSourceExpr())
       SourceExpr = Src;
 
+  bool IsConstexprInit =
+      S.isConstantEvaluated() &&
+      isa_and_present<VarDecl>(S.ExprEvalContexts.back().ManglingContextDecl);
+  // Constant-evaluated initializers are not diagnosed by DiagRuntimeBehavior,
+  // but narrowings from the evaluated result to the variable type should be
+  // diagnosed.
+  if (IsConstexprInit && SourceExpr->getType() != T) {
+    CheckImplicitConversion(S, SourceExpr, T, CC, nullptr, IsListInit,
+                            /*IsConstexprInit=*/true);
+  }
+
   if (const auto *UO = dyn_cast<UnaryOperator>(SourceExpr))
     if (UO->getOpcode() == UO_Not &&
         UO->getSubExpr()->isKnownToHaveBooleanValue())
       S.Diag(UO->getBeginLoc(), diag::warn_bitwise_negation_bool)
           << OrigE->getSourceRange() << T->isBooleanType()
           << FixItHint::CreateReplacement(UO->getBeginLoc(), "!");
 
   if (const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))

 
   // Check implicit argument conversions for function calls.
   if (CallExpr *Call = dyn_cast<CallExpr>(SourceExpr))
     CheckImplicitArgumentConversions(S, Call, CC);
 
   // Go ahead and check any implicit conversions we might have skipped.
   // The non-canonical typecheck is just an optimization;
   // CheckImplicitConversion will filter out dead implicit conversions.
-  if (SourceExpr->getType() != T)
+  if (!IsConstexprInit && SourceExpr->getType() != T)
     CheckImplicitConversion(S, SourceExpr, T, CC, nullptr, IsListInit);
 
   // Now continue drilling into this expression.
 
   if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
     // The bound subexpressions in a PseudoObjectExpr are not reachable
     // as transitive children.
     // FIXME: Use a more uniform representation for this.

clang/lib/Sema/SemaDecl.cpp

 
   if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
     FD = FunTmpl->getTemplatedDecl();
   else
     FD = cast<FunctionDecl>(D);
 
   // Do not push if it is a lambda because one is already pushed when building
   // the lambda in ActOnStartOfLambdaDefinition().
-  if (!isLambdaCallOperator(FD))
+  if (!isLambdaCallOperator(FD)) {
     // [expr.const]/p14.1
     // An expression or conversion is in an immediate function context if it is
     // potentially evaluated and either: its innermost enclosing non-block scope
     // is a function parameter scope of an immediate function.
     PushExpressionEvaluationContext(
         FD->isConsteval() ? ExpressionEvaluationContext::ImmediateFunctionContext
                           : ExprEvalContexts.back().Context);
+    if (!FD->isConsteval() && !FD->isConstexpr())
+      ExprEvalContexts.back().IsRuntimeEvaluated = true;
+  }
 
   // Each ExpressionEvaluationContextRecord also keeps track of whether the
   // context is nested in an immediate function context, so smaller contexts
   // that appear inside immediate functions (like variable initializers) are
   // considered to be inside an immediate function context even though by
   // themselves they are not immediate function contexts. But when a new
   // function is entered, we need to reset this tracking, since the entered
   // function might be not an immediate function.
   ExprEvalContexts.back().InImmediateFunctionContext = FD->isConsteval();

clang/lib/Sema/SemaDeclCXX.cpp

 
 void Sema::SetFunctionBodyKind(Decl *D, SourceLocation Loc,
                                FnBodyKind BodyKind) {
   switch (BodyKind) {
   case FnBodyKind::Delete:
     SetDeclDeleted(D, Loc);
     break;
   case FnBodyKind::Default:
     SetDeclDefaulted(D, Loc);
     break;
   case FnBodyKind::Other:
     llvm_unreachable(
         "Parsed function body should be '= delete;' or '= default;'");
   }
 }
 
 bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
                                              const CXXMethodDecl *Old) {
   const auto *NewFT = New->getType()->castAs<FunctionProtoType>();
   const auto *OldFT = Old->getType()->castAs<FunctionProtoType>();
 
   if (OldFT->hasExtParameterInfos()) {
     for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
       // A parameter of the overriding method should be annotated with noescape
       // if the corresponding parameter of the overridden method is annotated.
       if (OldFT->getExtParameterInfo(I).isNoEscape() &&
           !NewFT->getExtParameterInfo(I).isNoEscape()) {
         Diag(New->getParamDecl(I)->getLocation(),
              diag::warn_overriding_method_missing_noescape);
         Diag(Old->getParamDecl(I)->getLocation(),
              diag::note_overridden_marked_noescape);
       }
   }
 
   // Virtual overrides must have the same code_seg.
   const auto *OldCSA = Old->getAttr<CodeSegAttr>();
   const auto *NewCSA = New->getAttr<CodeSegAttr>();
   if ((NewCSA || OldCSA) &&
       (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
     Diag(New->getLocation(), diag::err_mismatched_code_seg_override);
     Diag(Old->getLocation(), diag::note_previous_declaration);
     return true;
   }
 
   CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
 
   // If the calling conventions match, everything is fine
   if (NewCC == OldCC)
     return false;
 
   // If the calling conventions mismatch because the new function is static,
   // suppress the calling convention mismatch error; the error about static
   // function override (err_static_overrides_virtual from
   // Sema::CheckFunctionDeclaration) is more clear.
   if (New->getStorageClass() == SC_Static)
     return false;
 
   Diag(New->getLocation(),
        diag::err_conflicting_overriding_cc_attributes)
     << New->getDeclName() << New->getType() << Old->getType();
   Diag(Old->getLocation(), diag::note_overridden_virtual_function);

   if (D->getFriendObjectKind())
     Diag(D->getLocation(), diag::err_pure_friend);
   else if (auto *M = dyn_cast<CXXMethodDecl>(D))
     CheckPureMethod(M, ZeroLoc);
   else
     Diag(D->getLocation(), diag::err_illegal_initializer);
 }
 
-/// Determine whether the given declaration is a global variable or
-/// static data member.
-static bool isNonlocalVariable(const Decl *D) {
-  if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
-    return Var->hasGlobalStorage();
-
-  return false;
-}
-
 /// Invoked when we are about to parse an initializer for the declaration
 /// 'Dcl'.
 ///
 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
 /// static data member of class X, names should be looked up in the scope of
 /// class X. If the declaration had a scope specifier, a scope will have
 /// been created and passed in for this purpose. Otherwise, S will be null.
 void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) {
   // If there is no declaration, there was an error parsing it.
   if (!D || D->isInvalidDecl())
     return;
 
   // We will always have a nested name specifier here, but this declaration
   // might not be out of line if the specifier names the current namespace:
   //   extern int n;
   //   int ::n = 0;
   if (S && D->isOutOfLine())
     EnterDeclaratorContext(S, D->getDeclContext());
 
   // If we are parsing the initializer for a static data member, push a
   // new expression evaluation context that is associated with this static
   // data member.
-  if (isNonlocalVariable(D))
-    PushExpressionEvaluationContext(
-        ExpressionEvaluationContext::PotentiallyEvaluated, D);
 }
 
 /// Invoked after we are finished parsing an initializer for the declaration D.
 void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
   // If there is no declaration, there was an error parsing it.
   if (!D || D->isInvalidDecl())
     return;
 
-  if (isNonlocalVariable(D))
-    PopExpressionEvaluationContext();
-
   if (S && D->isOutOfLine())
     ExitDeclaratorContext(S);
 }
 
 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
 /// C++ if/switch/while/for statement.
 /// e.g: "if (int x = f()) {...}"
 DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {

clang/lib/Sema/SemaExpr.cpp

static void DiagnosedUnqualifiedCallsToStdFunctions(Sema &S, CallExpr *Call) {
   if (BuiltinID != Builtin::BImove && BuiltinID != Builtin::BIforward)
     return;
 
   S.Diag(DRE->getLocation(), diag::warn_unqualified_call_to_std_cast_function)
       << FD->getQualifiedNameAsString()
       << FixItHint::CreateInsertion(DRE->getLocation(), "std::");
 }
 
+// Diagnose uses of std::is_constant_evaluated or
+// __builtin_is_constant_evaluated in contexts where the result is known at
+// compile time.
+static void DiagnoseTautologicalCallToIsConstantEvaluated(Sema &S,
+                                                          CallExpr *CE) {
+  if (S.inTemplateInstantiation())
+    return;
+  if (const FunctionDecl *FD = CE->getDirectCallee()) {
+    bool IsBuiltin =
+        FD->getBuiltinID() == Builtin::BI__builtin_is_constant_evaluated;
+
+    if ((FD->isInStdNamespace() &&
+         FD->getNameAsString() == "is_constant_evaluated") ||
+        IsBuiltin) {
+      bool AlwaysTrue = S.ExprEvalContexts.back().isConstantEvaluated() ||
+                        S.ExprEvalContexts.back().isUnevaluated();
+      bool AlwaysFalse = S.ExprEvalContexts.back().IsRuntimeEvaluated;
+      if (AlwaysTrue || AlwaysFalse)
+        S.Diag(CE->getBeginLoc(), diag::warn_tautological_is_constant_evaluated)
+            << IsBuiltin << AlwaysTrue;
+    }
+  }
+}
+
 ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                                MultiExprArg ArgExprs, SourceLocation RParenLoc,
                                Expr *ExecConfig) {
   ExprResult Call =
       BuildCallExpr(Scope, Fn, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
                     /*IsExecConfig=*/false, /*AllowRecovery=*/true);
   if (Call.isInvalid())
     return Call;
if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn)) {
     }
   }
 
   if (LangOpts.OpenMP)
     Call = ActOnOpenMPCall(Call, Scope, LParenLoc, ArgExprs, RParenLoc,
                            ExecConfig);
   if (LangOpts.CPlusPlus) {
     CallExpr *CE = dyn_cast<CallExpr>(Call.get());
-    if (CE)
+    if (CE) {
       DiagnosedUnqualifiedCallsToStdFunctions(*this, CE);
+      DiagnoseTautologicalCallToIsConstantEvaluated(*this, CE);
+    }
   }
   return Call;
 }
 
 /// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
 /// This provides the location of the left/right parens and a list of comma
 /// locations.
 ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
if (!getLangOpts().CPlusPlus20 &&
         D = diag::err_lambda_in_constant_expression;
       } else if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument) {
         // C++17 [expr.prim.lamda]p2:
         // A lambda-expression shall not appear [...] in a template-argument.
         D = diag::err_lambda_in_invalid_context;
       } else
         llvm_unreachable("Couldn't infer lambda error message.");
 
+      if (auto *VD = dyn_cast_if_present<VarDecl>(Rec.ManglingContextDecl))
+        VD->setInvalidDecl();
       for (const auto *L : Rec.Lambdas)
         Diag(L->getBeginLoc(), D);
     }
   }
 
   WarnOnPendingNoDerefs(Rec);
   HandleImmediateInvocations(*this, Rec);
 

clang/lib/Sema/SemaLambda.cpp

if (Expr *TRC = Method->getTrailingRequiresClause()) {
     }
   }
 
   // Enter a new evaluation context to insulate the lambda from any
   // cleanups from the enclosing full-expression.
   PushExpressionEvaluationContext(
       LSI->CallOperator->isConsteval()
           ? ExpressionEvaluationContext::ImmediateFunctionContext
+      : isConstantEvaluated()
+          ? ExpressionEvaluationContext::ConstantEvaluated
           : ExpressionEvaluationContext::PotentiallyEvaluated);
   ExprEvalContexts.back().InImmediateFunctionContext =
       LSI->CallOperator->isConsteval();
   ExprEvalContexts.back().InImmediateEscalatingFunctionContext =
       getLangOpts().CPlusPlus20 && LSI->CallOperator->isImmediateEscalating();
 }
 
 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,

clang/lib/Sema/SemaStmt.cpp

if (std::get<0>(LHC)) {
                    diag::warn_attributes_likelihood_ifstmt_conflict)
           << ThenAttr << ThenAttr->getRange();
       Diags.Report(ElseAttr->getLocation(), diag::note_conflicting_attribute)
           << ElseAttr << ElseAttr->getRange();
     }
   }
 
   if (ConstevalOrNegatedConsteval) {
-    bool Immediate = ExprEvalContexts.back().Context ==
-                     ExpressionEvaluationContext::ImmediateFunctionContext;
-    if (CurContext->isFunctionOrMethod()) {
-      const auto *FD =
-          dyn_cast<FunctionDecl>(Decl::castFromDeclContext(CurContext));
-      if (FD && FD->isImmediateFunction())
-        Immediate = true;
-    }
-    if (isUnevaluatedContext() || Immediate)
-      Diags.Report(IfLoc, diag::warn_consteval_if_always_true) << Immediate;
+    bool AlwaysTrue = ExprEvalContexts.back().isConstantEvaluated() ||
+                      ExprEvalContexts.back().isUnevaluated();
+    bool AlwaysFalse = ExprEvalContexts.back().IsRuntimeEvaluated;
+    if (AlwaysTrue || AlwaysFalse)
+      Diags.Report(IfLoc, diag::warn_tautological_consteval_if)
+          << (AlwaysTrue
+                  ? StatementKind == IfStatementKind::ConstevalNegated
+                  : StatementKind == IfStatementKind::ConstevalNonNegated);
   }
 
   return BuildIfStmt(IfLoc, StatementKind, LParenLoc, InitStmt, Cond, RParenLoc,
                      thenStmt, ElseLoc, elseStmt);
 }
 
 StmtResult Sema::BuildIfStmt(SourceLocation IfLoc,
                              IfStatementKind StatementKind,
                              SourceLocation LParenLoc, Stmt *InitStmt,

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

void Sema::InstantiateVariableInitializer(
   // would otherwise imply that the variable is a definition for a
   // non-static data member.
   if (OldVar->isInlineSpecified())
     Var->setInlineSpecified();
   else if (OldVar->isInline())
     Var->setImplicitlyInline();
 
   if (OldVar->getInit()) {
-    EnterExpressionEvaluationContext Evaluated(
-        *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var);
+    Sema::ExpressionEvaluationContext InitEvalContext =
+        Var->isConstexpr()
+            ? Sema::ExpressionEvaluationContext::ConstantEvaluated
+            : Sema::ExpressionEvaluationContext::PotentiallyEvaluated;
+    EnterExpressionEvaluationContext Evaluated(*this, InitEvalContext, Var);
 
     // Instantiate the initializer.
     ExprResult Init;
 
     {
       ContextRAII SwitchContext(*this, Var->getDeclContext());
       Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
                               OldVar->getInitStyle() == VarDecl::CallInit);

clang/test/AST/Interp/builtins.cpp

-// RUN: %clang_cc1 -fexperimental-new-constant-interpreter %s -verify
-// RUN: %clang_cc1 -fexperimental-new-constant-interpreter %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter %s -Wno-constant-evaluated -verify
+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter %s -Wno-constant-evaluated -S -emit-llvm -o - | FileCheck %s
 // RUN: %clang_cc1 -verify=ref %s -Wno-constant-evaluated
 // RUN: %clang_cc1 -verify=ref %s -Wno-constant-evaluated %s -S -emit-llvm -o - | FileCheck %s
 
 // expected-no-diagnostics
 // ref-no-diagnostics
 
 using size_t = decltype(sizeof(int));
 

clang/test/AST/Interp/if.cpp

-// RUN: %clang_cc1 -std=c++23 -fsyntax-only -fexperimental-new-constant-interpreter %s -verify
-// RUN: %clang_cc1 -std=c++23 -fsyntax-only %s -verify=ref
+// RUN: %clang_cc1 -std=c++23 -fsyntax-only -fexperimental-new-constant-interpreter -Wno-redundant-consteval-if %s -verify
+// RUN: %clang_cc1 -std=c++23 -fsyntax-only -Wno-redundant-consteval-if %s -verify=ref
 
 // expected-no-diagnostics
 // ref-no-diagnostics
 
 namespace ConstEval {
   constexpr int f() {
     int i = 0;
     if consteval {

clang/test/AST/Interp/literals.cpp

void func() {
     constexpr int oofda = sizeof(int[n++]); // expected-error {{must be initialized by a constant expression}} \
                                             // ref-error {{must be initialized by a constant expression}}
   }
 
 
 #if __cplusplus >= 202002L
   /// FIXME: The following code should be accepted.
   consteval int foo(int n) { // ref-error {{consteval function never produces a constant expression}}
-    return sizeof(int[n]); // ref-note 3{{not valid in a constant expression}} \
-                           // expected-note {{not valid in a constant expression}}
+    return sizeof(int[n]); // ref-note 2 {{not valid in a constant expression}}
   }
-  constinit int var = foo(5); // ref-error {{not a constant expression}} \
-                              // ref-note 2{{in call to}} \
+  constinit int var = foo(5); // ref-note {{in call to}} \
                               // ref-error {{does not have a constant initializer}} \
                               // ref-note {{required by 'constinit' specifier}} \
-                              // expected-error  {{is not a constant expression}} \
-                              // expected-note {{in call to}} \
                               // expected-error {{does not have a constant initializer}} \
                               // expected-note {{required by 'constinit' specifier}} \
 
 #endif
 };
 
 namespace rem {
   static_assert(2 % 2 == 0, "");

clang/test/CXX/expr/expr.const/p2-0x.cpp

namespace Overflow {
     constexpr int n8 = -1 + n7; // expected-error {{constant expression}} expected-note {{value -2147483649 is outside the range of }}
     constexpr int n9 = n3 - 0; // ok
     constexpr int n10 = n3 - -1; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range of }}
     constexpr int n11 = -1 - n3; // ok
     constexpr int n12 = -2 - n3; // expected-error {{constant expression}} expected-note {{value -2147483649 is outside the range of }}
     constexpr int n13 = n5 + n5; // expected-error {{constant expression}} expected-note {{value -4294967296 is outside the range of }}
     constexpr int n14 = n3 - n5; // expected-error {{constant expression}} expected-note {{value 4294967295 is outside the range of }}
     constexpr int n15 = n5 * n5; // expected-error {{constant expression}} expected-note {{value 4611686018427387904 is outside the range of }}
-    constexpr signed char c1 = 100 * 2; // ok expected-warning{{changes value}}
-    constexpr signed char c2 = '\x64' * '\2'; // also ok  expected-warning{{changes value}}
+    constexpr signed char c1 = 100 * 2; // ok expected-warning {{changes value from 200 to -56}}
+    constexpr signed char c2 = '\x64' * '\2'; // also ok expected-warning {{changes value from 200 to -56}}
     constexpr long long ll1 = 0x7fffffffffffffff; // ok
     constexpr long long ll2 = ll1 + 1; // expected-error {{constant}} expected-note {{ 9223372036854775808 }}
     constexpr long long ll3 = -ll1 - 1; // ok
     constexpr long long ll4 = ll3 - 1; // expected-error {{constant}} expected-note {{ -9223372036854775809 }}
     constexpr long long ll5 = ll3 * ll3; // expected-error {{constant}} expected-note {{ 85070591730234615865843651857942052864 }}
 
     // Yikes.
     char melchizedek[2200000000];

clang/test/CXX/expr/expr.const/p6-2a.cpp

struct Temporary {
   int &&temp;
   constexpr ~Temporary() {
     int n = temp; // expected-note {{outside the expression that created the temporary}}
   }
 };
 constexpr Temporary t = {3}; // expected-error {{must have constant destruction}} expected-note {{created here}} expected-note {{in call}}
 
 namespace P1073R3 {
-consteval int f() { return 42; } // expected-note 2 {{declared here}}
+consteval int f() { return 42; } // expected-note {{declared here}}
 consteval auto g() { return f; }
 consteval int h(int (*p)() = g()) { return p(); }
 constexpr int r = h();
-constexpr auto e = g();  // expected-error {{call to consteval function 'P1073R3::g' is not a constant expression}} \
-                            expected-error {{constexpr variable 'e' must be initialized by a constant expression}} \
-                            expected-note 2 {{pointer to a consteval declaration is not a constant expression}}
+constexpr auto e = g(); // expected-error {{constexpr variable 'e' must be initialized by a constant expression}} \
+                           expected-note {{pointer to a consteval declaration is not a constant expression}}
 static_assert(r == 42);
 } // namespace P1073R3

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p3.cpp

void test_nonaggregate(int i) {
   decltype(lambda2) bar = {}; // expected-error{{no matching constructor}}
   static_assert(__is_literal(decltype(lambda2)) == (__cplusplus >= 201703L), "");
 }
 
 constexpr auto literal = []{};
 #if __cplusplus < 201703L
 // expected-error@-2 {{constexpr variable cannot have non-literal type}}
 // expected-note@-3 {{lambda closure types are non-literal types before C++17}}
+// expected-error@-4 {{a lambda expression may not appear inside of a constant expression}}
 #endif

clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p4.cpp

 // RUN: %clang_cc1 -std=c++23 -verify %s
 
 void test_consteval() {
   if consteval ({(void)1;});  // expected-error {{expected { after consteval}}
   if consteval (void) 0; // expected-error {{expected { after consteval}}
   if consteval {
     (void)0;
   } else (void)0; // expected-error {{expected { after else}}
 
   static_assert([] {
-    if consteval {
+    if consteval { // expected-warning {{consteval if is always true}}
       return 0;
     }
     return 1;
   }() == 0);
 
   static_assert([] {
-    if consteval {
+    if consteval { // expected-warning {{consteval if is always true}}
       return 0;
     } else {
       return 1;
     }
   }() == 0);
 
   static_assert([] {
-    if !consteval {
+    if !consteval { // expected-warning {{consteval if is always false}}
       return 0;
     } else {
       return 1;
     }
   }() == 1);
 
   static_assert([] {
-    if not consteval {
+    if not consteval { // expected-warning {{consteval if is always false}}
       return 0;
     }
     return 1;
   }() == 1);
 
   if consteval [[likely]] { // expected-warning {{attribute 'likely' has no effect when annotating an 'if consteval' statement}}\
-                            // expected-note 2{{annotating the 'if consteval' statement here}}
+                            // expected-note 2{{annotating the 'if consteval' statement here}} \
+                            // expected-warning {{consteval if is always false}}
 
 
   }
   else [[unlikely]] { // expected-warning {{attribute 'unlikely' has no effect when annotating an 'if consteval' statement}}
 
   }
 
 }
 
 void test_consteval_jumps() {
-  if consteval { // expected-note 4{{jump enters controlled statement of consteval if}}
+  if consteval { // expected-warning {{consteval if is always false}} \
+                 // expected-note 4{{jump enters controlled statement of consteval if}}
     goto a;
     goto b; // expected-error {{cannot jump from this goto statement to its label}}
   a:;
   } else {
     goto b;
     goto a; // expected-error {{cannot jump from this goto statement to its label}}
   b:;
   }
   goto a; // expected-error {{cannot jump from this goto statement to its label}}
   goto b; // expected-error {{cannot jump from this goto statement to its label}}
 }
 
 void test_consteval_switch() {
   int x = 42;
   switch (x) {
-    if consteval { // expected-note 2{{jump enters controlled statement of consteval if}}
+    if consteval { // expected-warning {{consteval if is always false}} \
+                   // expected-note 2{{jump enters controlled statement of consteval if}}
     case 1:;       // expected-error {{cannot jump from switch statement to this case label}}
     default:;      // expected-error {{cannot jump from switch statement to this case label}}
     } else {
     }
   }
   switch (x) {
-    if consteval { // expected-note 2{{jump enters controlled statement of consteval if}}
+    if consteval { // expected-warning {{consteval if is always false}} \
+                   // expected-note 2{{jump enters controlled statement of consteval if}}
     } else {
     case 2:;  // expected-error {{cannot jump from switch statement to this case label}}
     default:; // expected-error {{cannot jump from switch statement to this case label}}
     }
   }
 }
 
 consteval int f(int i) { return i; }
constexpr int h(int i) { // expected-note {{declared here}}
   if !consteval {
     return f(i); // expected-error {{call to consteval function 'f' is not a constant expression}}\
                      // expected-note  {{cannot be used in a constant expression}}
   }
   return 0;
 }
 
 consteval void warn_in_consteval() {
-  if consteval { // expected-warning {{consteval if is always true in an immediate context}}
-    if consteval {} // expected-warning {{consteval if is always true in an immediate context}}
+  if consteval { // expected-warning {{consteval if is always true in this context}}
+    if consteval {} // expected-warning {{consteval if is always true in this context}}
   }
 }
 
 constexpr void warn_in_consteval2() {
   if consteval {
-    if consteval {} // expected-warning {{consteval if is always true in an immediate context}}
+    if consteval {} // expected-warning {{consteval if is always true in this context}}
   }
 }
 
 auto y = []() consteval {
-  if consteval { // expected-warning {{consteval if is always true in an immediate context}}
-    if consteval {} // expected-warning {{consteval if is always true in an immediate context}}
+  if consteval { // expected-warning {{consteval if is always true in this context}}
+    if consteval {} // expected-warning {{consteval if is always true in this context}}
   }
 };
 
 namespace test_transform {
 int f(auto n) {
-  if consteval {
+  if consteval { // expected-warning {{consteval if is always false}}
     n.foo; //expected-error {{no member named}}
   }
   else {
   }
 
-  if !consteval {
+  if !consteval { // expected-warning {{consteval if is always true}}
     n.foo; //expected-error {{no member named}}
   }
   else {
   }
 
   return 0;
 }
 

clang/test/Parser/pragma-fenv_access.c

 //expected-note@+2 {{declared here}}
 #endif
   CONST float frac = one/three;
   CONST double d = one;
   CONST int not_too_big = 255;
   CONST float fnot_too_big = not_too_big;
   CONST int too_big = 0x7ffffff0;
 #if defined(CPP)
-//expected-warning@+2{{implicit conversion}}
+//expected-warning@+2{{implicit conversion from 'const int' to 'const float' changes value from 2147483632 to 2147483648}}
 #endif
   CONST float fbig = too_big; // inexact
 #if !defined(CPP)
 #define static_assert _Static_assert
 #endif
 enum {
   e1 = (int)one, e3 = (int)three, e4 = (int)four, e_four_quarters = (int)(frac_ok * 4)
 };

clang/test/SemaCXX/constant-conversion.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-apple-darwin %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify -triple x86_64-apple-darwin %s
 
 // This file tests -Wconstant-conversion, a subcategory of -Wconversion
 // which is on by default.
 
 constexpr int nines() { return 99999; }
 
 void too_big_for_char(int param) {
   char warn1 = false ? 0 : 99999;

 void test_bitfield() {
   struct S {
     int one_bit : 1;
   } s;
 
   s.one_bit = 1;    // expected-warning {{implicit truncation from 'int' to a one-bit wide bit-field changes value from 1 to -1}}
   s.one_bit = true; // no-warning
 }
+
+namespace Initializers {
+constexpr char ok = true ? 0 : 200;
+constexpr char a = 200; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}}
+char b = 200; // expected-warning {{implicit conversion from 'int' to 'char' changes value from 200 to -56}}
+const char c = 200; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}}
+
+void f() {
+  constexpr char a = 200; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}}
+  char b = 200; // expected-warning {{implicit conversion from 'int' to 'char' changes value from 200 to -56}}
+  const char c = 200; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}}
+  static char d = 2 * 100; // expected-warning {{implicit conversion from 'int' to 'char' changes value from 200 to -56}}
+}
+
+constexpr void g() {
+  constexpr char a = 2 * 100; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}}
+  char b = 2 * 100; // expected-warning {{implicit conversion from 'int' to 'char' changes value from 200 to -56}}
+  const char c = 2 * 100; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}}
+}
+
+consteval void h() {
+  char ok = true ? 0 : 200;
+  constexpr char a = 200; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}}
+  char b = 200; // expected-warning {{implicit conversion from 'int' to 'char' changes value from 200 to -56}}
+  const char c = 200; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}}
+}
+
+template <int N>
+int templ() {
+  constexpr char a = false ? 129 : N; // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 200 to -56}} \
+                                      // expected-warning {{implicit conversion from 'int' to 'const char' changes value from 345 to 89}}
+  return 3;
+}
+
+void call_templ() {
+  int ok = templ<127>();
+  int l = templ<3>();
+  int m = templ<200>(); // expected-note {{in instantiation of}}
+  int n = templ<345>(); // expected-note {{in instantiation of}}
+}
+
+template <int a, int b>
+constexpr signed char diff = a > b ? a - b : b - a; // expected-warning{{changes value from 201 to -55}} \
+                                                    // expected-warning{{changes value from 199 to -57}} \
+                                                    // expected-warning{{changes value from 299 to 43}} \
+                                                    // expected-warning{{changes value from 301 to 45}}
+
+void test_diff() {
+  char ok1 = diff<201, 100>;
+  char ok2 = diff<101, 200>;
+  char s1 = diff<301, 100>; // expected-note {{in instantiation of}}
+  char s2 = diff<101, 300>; // expected-note {{in instantiation of}}
+  char w1 = diff<101, 400>; // expected-note {{in instantiation of}}
+  char w2 = diff<401, 100>; // expected-note {{in instantiation of}}
+}
+}

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

protected:
       E val{0}; // cxx11-error {{cannot initialize a member subobject of type 'E' with an rvalue of type 'int'}} cxx11-note {{here}}
   };
   // FIXME: We should avoid issuing this follow-on diagnostic.
   constexpr X x{}; // cxx11-error {{constant expression}} cxx11-note {{not initialized}}
 }
 
 namespace Lifetime {
   void f() {
-    constexpr int &n = n; // expected-error {{constant expression}} expected-note {{use of reference outside its lifetime}} expected-warning {{not yet bound to a value}}
+    constexpr int &n = n; // expected-error {{constant expression}} expected-note {{use of reference outside its lifetime}}
     constexpr int m = m; // expected-error {{constant expression}} expected-note {{read of object outside its lifetime}}
   }
 
   constexpr int &get(int &&n) { return n; }
   // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
   constexpr int &&get_rv(int &&n) { return static_cast<int&&>(n); }
   struct S {
     int &&r;

clang/test/SemaCXX/cxx2a-consteval.cpp

struct derp {
   int b = 0;
 };
 
 constexpr derp d;
 
 struct test {
   consteval int operator[](int i) const { return {}; }
   consteval const derp * operator->() const { return &d; }
-  consteval int f() const { return 12; } // expected-note 2{{declared here}}
+  consteval int f() const { return 12; } // expected-note {{declared here}}
 };
 
 constexpr test a;
 
 // We previously rejected both of these overloaded operators as taking the
 // address of a consteval function outside of an immediate context, but we
 // accepted direct calls to the overloaded operator. Now we show that we accept
 // both forms.
 constexpr int s = a.operator[](1);
 constexpr int t = a[1];
 constexpr int u = a.operator->()->b;
 constexpr int v = a->b;
-// FIXME: I believe this case should work, but we currently reject.
-constexpr int w = (a.*&test::f)(); // expected-error {{cannot take address of consteval function 'f' outside of an immediate invocation}}
+constexpr int w = (a.*&test::f)();
 constexpr int x = a.f();
 
 // Show that we reject when not in an immediate context.
 int w2 = (a.*&test::f)(); // expected-error {{cannot take address of consteval function 'f' outside of an immediate invocation}}
 }
 
 namespace PR48235 {
 consteval int d() {

 
 namespace GH58207 {
 struct tester {
     consteval tester(const char* name) noexcept { }
 };
 consteval const char* make_name(const char* name) { return name;}
 consteval const char* pad(int P) { return "thestring"; }
 
-int bad = 10; // expected-note 6{{declared here}}
+int bad = 10; // expected-note 5{{declared here}}
 
 tester glob1(make_name("glob1"));
 tester glob2(make_name("glob2"));
 constexpr tester cglob(make_name("cglob"));
-tester paddedglob(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::make_name' is not a constant expression}} \
+tester paddedglob(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::tester::tester' is not a constant expression}} \
                                         // expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
 
 constexpr tester glob3 = { make_name("glob3") };
-constexpr tester glob4 = { make_name(pad(bad)) }; // expected-error {{call to consteval function 'GH58207::make_name' is not a constant expression}} \
-                                                  // expected-error {{constexpr variable 'glob4' must be initialized by a constant expression}} \
-                                                  // expected-note 2{{read of non-const variable 'bad' is not allowed in a constant expression}}
+constexpr tester glob4 = { make_name(pad(bad)) }; // expected-error {{constexpr variable 'glob4' must be initialized by a constant expression}} \
+                                                  // expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
 
 auto V = make_name(pad(3));
 auto V1 = make_name(pad(bad)); // expected-error {{call to consteval function 'GH58207::make_name' is not a constant expression}} \
                                // expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
 
 
 void foo() {
   static tester loc1(make_name("loc1"));
   static constexpr tester loc2(make_name("loc2"));
-  static tester paddedloc(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::make_name' is not a constant expression}} \
+  static tester paddedloc(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::tester::tester' is not a constant expression}} \
                                                 // expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
 }
 
 void bar() {
-  static tester paddedloc(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::make_name' is not a constant expression}} \
+  static tester paddedloc(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::tester::tester' is not a constant expression}} \
                                                 // expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
 }
 }

clang/test/SemaCXX/cxx2b-consteval-if.cpp

 
 constexpr auto h() {
   if consteval  { return 0; }
   if !consteval { return 0; } // okay
 }
 
 constexpr auto i() {
   if consteval {
-    if consteval { // expected-warning {{consteval if is always true in an immediate context}}
+    if consteval { // expected-warning {{consteval if is always true in this context}}
       return 1;
     }
     return 2;
   } else {
     return 1.0; // expected-error {{'auto' in return type deduced as 'double' here but deduced as 'int' in earlier return statement}}
   }
 }
 

clang/test/SemaCXX/cxx2b-consteval-propagate.cpp

struct SS {
   int x = f(0); // expected-error {{call to consteval function 'GH63742::f' is not a constant expression}} \
                 // expected-note  {{declared here}} \
                 // expected-note  {{in call to 'f(0)'}}
   SS();
 };
 SS::SS(){} // expected-note {{in the default initializer of 'x'}}
 
 consteval int f2(int x) {
-    if (!__builtin_is_constant_evaluated()) side_effect();
+    if (!__builtin_is_constant_evaluated()) side_effect(); // expected-warning {{'__builtin_is_constant_evaluated' will always evaluate to true}}
     return x;
 }
 struct S2 {
     int x = f2(0);
     constexpr S2();
 };
 
 constexpr S2::S2(){}

clang/test/SemaCXX/vartemplate-lambda.cpp

 // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s
 
 template <class> auto fn0 = [] {};
 template <typename> void foo0() { fn0<char>(); }
 
 template<typename T> auto fn1 = [](auto a) { return a + T(1); };
 template<typename T> auto v1 = [](int a = T()) { return a; }();
 // expected-error@-1{{cannot initialize a parameter of type 'int' with an rvalue of type 'int *'}}
 // expected-note@-2{{in instantiation of default function argument expression for 'operator()<int *>' required here}}
 // expected-note@-3{{passing argument to parameter 'a' here}}
 // expected-note@-4{{substituting into a lambda}}
 
 struct S {
   template<class T>
-  static constexpr T t = [](int f = T(7)){return f;}(); // expected-error{{constexpr variable 't<int>' must be initialized by a constant expression}} expected-note{{cannot be used in a constant expression}}
+  static constexpr T t = [](int f = T(7)){return f;}(); // expected-error{{a lambda expression may not appear inside of a constant expression}}
 };
 
 template <typename X>
 int foo2() {
   X a = 0x61;
   fn1<char>(a);
   (void)v1<int>;
   (void)v1<int *>; // expected-note{{in instantiation of variable template specialization 'v1' requested here}}
-  (void)S::t<int>; // expected-note{{in instantiation of static data member 'S::t<int>' requested here}}
+  (void)S::t<int>;
   return 0;
 }
 
 template<class C>
 int foo3() {
   C::m1(); // expected-error{{type 'long long' cannot be used prior to '::' because it has no members}}
   return 1;
 }

clang/test/SemaCXX/warn-constant-evaluated-constexpr.cpp

 // RUN: %clang_cc1 -std=c++2a -fsyntax-only -verify %s
 
 namespace std {
 constexpr bool is_constant_evaluated() noexcept {
   return __builtin_is_constant_evaluated();
 }
 } // namespace std
 
 constexpr int fn1() {
-  if constexpr (std::is_constant_evaluated()) // expected-warning {{'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}}
+  if constexpr (std::is_constant_evaluated()) // expected-warning {{'std::is_constant_evaluated' will always evaluate to true in this context}}
     return 0;
   else
     return 1;
 }
 
 constexpr int fn2() {
-  if constexpr (!std::is_constant_evaluated()) // expected-warning {{'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}}
+  if constexpr (!std::is_constant_evaluated()) // expected-warning {{'std::is_constant_evaluated' will always evaluate to true in this context}}
     return 0;
   else
     return 1;
 }
 
 constexpr int fn3() {
-  if constexpr (std::is_constant_evaluated() == false) // expected-warning {{'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}}
+  if constexpr (std::is_constant_evaluated() == false) // expected-warning {{'std::is_constant_evaluated' will always evaluate to true in this context}}
     return 0;
   else
     return 1;
 }
 
 constexpr int fn4() {
-  if constexpr (__builtin_is_constant_evaluated() == true) // expected-warning {{'__builtin_is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}}
+  if constexpr (__builtin_is_constant_evaluated() == true) // expected-warning {{'__builtin_is_constant_evaluated' will always evaluate to true in this context}}
     return 0;
   else
     return 1;
 }
 
 constexpr int fn5() {
-  if constexpr (__builtin_is_constant_evaluated()) // expected-warning {{'__builtin_is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}}
+  if constexpr (__builtin_is_constant_evaluated()) // expected-warning {{'__builtin_is_constant_evaluated' will always evaluate to true in this context}}
     return 0;
   else
     return 1;
 }
 
 constexpr int nowarn1() {
   if (std::is_constant_evaluated())
     return 0;

clang/test/SemaCXX/warn-tautological-meta-constant.cpp

+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify %s
+
+namespace std {
+constexpr inline bool
+  is_constant_evaluated() noexcept {
+    if consteval { return true; } else { return false; }
+  }
+} // namespace std
+
+namespace P1938 {
+  constexpr int f1() {
+  if constexpr (!std::is_constant_evaluated() && sizeof(int) == 4) { // expected-warning {{always evaluate to true}}
+    return 0;
+  }
+  if (std::is_constant_evaluated()) {
+    return 42;
+  } else {
+    if constexpr (std::is_constant_evaluated()) { // expected-warning {{always evaluate to true}}
+      return 0;
+    }
+  }
+  return 7;
+}
+
+
+consteval int f2() {
+  if (std::is_constant_evaluated() && f1()) { // expected-warning {{always evaluate to true}}
+    return 42;
+  }
+  return 7;
+}
+
+
+int f3() {
+  if (std::is_constant_evaluated() && f1()) { // expected-warning {{always evaluate to false}}
+    return 42;
+  }
+  return 7;
+}
+}
+
+void non_qual() {
+  int ff = std::is_constant_evaluated(); // expected-warning {{always evaluate to false}}
+  const int aa = std::is_constant_evaluated();
+  constexpr int tt = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  static int bb = std::is_constant_evaluated();
+  constexpr int cc = [](){
+    if consteval {return 8;} // expected-warning {{always true}}
+  }();
+  auto lamda = []() {
+    if consteval {return 8;}
+    else {return 4;}
+  };
+  auto lamda_const = []() consteval {
+    if consteval {return 8;} // expected-warning {{always true}}
+    else {return 4;}
+  };
+  if consteval { // expected-warning {{always false}}
+    int b = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  }
+}
+
+constexpr void in_constexpr() {
+  int aa = std::is_constant_evaluated();
+  constexpr int bb = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  const int cc = std::is_constant_evaluated();
+  if consteval {
+    int dd = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+    constexpr int ee = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+    const int ff = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  } else {
+    int dd = std::is_constant_evaluated(); // expected-warning {{always evaluate to false}}
+    constexpr int ee = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+    const int ff = std::is_constant_evaluated();
+    const int qq = std::is_constant_evaluated() ? dd : 3;
+  }
+
+  if consteval {
+    if consteval {} // expected-warning {{always true}}
+    if !consteval {} // expected-warning {{always false}}
+  } else {
+    if consteval {} // expected-warning {{always false}}
+    if !consteval {} // expected-warning {{always true}}
+  }
+  if !consteval {
+    if consteval {} // expected-warning {{always false}}
+    if !consteval {} // expected-warning {{always true}}
+  } else {
+    if consteval {} // expected-warning {{always true}}
+    if !consteval {} // expected-warning {{always false}}
+  }
+}
+
+consteval void in_consteval() {
+  int aa = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  constexpr int bb = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  const int cc = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  auto lambda = []() {
+  int a(std::is_constant_evaluated()); // expected-warning {{always evaluate to true}}
+  constexpr int b = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  const int c = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  };
+  if !consteval {} // expected-warning {{always false}}
+}
+
+static_assert(std::is_constant_evaluated()); // expected-warning {{always evaluate to true}}
+static_assert(__builtin_is_constant_evaluated()); // expected-warning {{always evaluate to true}}
+
+template <bool b>
+void templ() {
+  if constexpr(std::is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+  constexpr bool c = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  if consteval {} // expected-warning {{always false}}
+}
+
+template <> void templ<std::is_constant_evaluated()>() { // expected-warning {{always evaluate to true}}
+  if constexpr(std::is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+  constexpr bool c = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  if consteval {} // expected-warning {{always false}}
+  templ<false>();
+}
+
+static_assert([] {
+    if consteval { // expected-warning {{always true}}
+      return 0;
+    } else {
+      return 1;
+    }
+  }() == 0);
+constexpr bool b = __builtin_is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+constexpr bool c = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+constinit bool d = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+int p = __builtin_is_constant_evaluated();
+const int q = __builtin_is_constant_evaluated();
+
+template <bool c = std::is_constant_evaluated()> // expected-warning {{always evaluate to true}}
+void vvv() {
+  return;
+}
+
+template<> void vvv<true>() {}
+template<> void vvv<false>() {}
+
+template<typename T> concept C = __builtin_is_constant_evaluated();// expected-warning {{always evaluate to true}}
+
+struct Foo {
+  static constexpr bool ce = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  const static bool nonce = std::is_constant_evaluated();
+  bool b = std::is_constant_evaluated();
+
+  Foo() {
+    if constexpr(std::is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+    bool aa = std::is_constant_evaluated(); // expected-warning {{always evaluate to false}}
+    static bool bb = std::is_constant_evaluated();
+    constexpr bool cc = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+    if consteval {} // expected-warning {{always false}}
+  }
+  constexpr Foo(int) {
+    if constexpr(std::is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+    bool aa = std::is_constant_evaluated();
+    static bool bb = std::is_constant_evaluated();
+    constexpr bool cc = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  }
+  consteval Foo(int *) {
+    if constexpr(std::is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+    bool aa = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+    static bool bb = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+    constexpr bool cc = std::is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+  }
+};

clang/test/SemaTemplate/concepts.cpp

void g6() {
      return T(); // expected-error {{expression contains unexpanded parameter pack 'T'}}
      }(),
      ...); // expected-error {{does not contain any unexpanded}}
   }
 }
 
 namespace BuiltinIsConstantEvaluated {
   // Check that we do all satisfaction and diagnostic checks in a constant context.
-  template<typename T> concept C = __builtin_is_constant_evaluated(); // expected-warning {{always}}
+  template<typename T> concept C = __builtin_is_constant_evaluated(); // expected-warning {{always evaluate to true}}
   static_assert(C<int>);
 
-  template<typename T> concept D = __builtin_is_constant_evaluated() == true; // expected-warning {{always}}
+  template<typename T> concept D = __builtin_is_constant_evaluated() == true; // expected-warning {{always evaluate to true}}
   static_assert(D<int>);
 
-  template<typename T> concept E = __builtin_is_constant_evaluated() == true && // expected-warning {{always}}
+  template<typename T> concept E = __builtin_is_constant_evaluated() == true && // expected-warning {{always evaluate to true}}
                                    false; // expected-note {{'false' evaluated to false}}
   static_assert(E<int>); // expected-error {{failed}} expected-note {{because 'int' does not satisfy 'E'}}
 
-  template<typename T> concept F = __builtin_is_constant_evaluated() == false; // expected-warning {{always}}
+  template<typename T> concept F = __builtin_is_constant_evaluated() == false; // expected-warning {{always evaluate to true}}
   // expected-note@-1 {{'__builtin_is_constant_evaluated() == false' (1 == 0)}}
   static_assert(F<int>); // expected-error {{failed}} expected-note {{because 'int' does not satisfy 'F'}}
 
-  template<typename T> concept G = __builtin_is_constant_evaluated() && // expected-warning {{always}}
+  template<typename T> concept G = __builtin_is_constant_evaluated() && // expected-warning {{always evaluate to true}}
                                    false; // expected-note {{'false' evaluated to false}}
   static_assert(G<int>); // expected-error {{failed}} expected-note {{because 'int' does not satisfy 'G'}}
 }
 
 namespace NoConstantFolding {
   // Ensure we use strict constant evaluation rules when checking satisfaction.
   int n;
   template <class T> concept C = &n + 3 - 3 == &n; // expected-error {{non-constant expression}} expected-note {{cannot refer to element 3 of non-array object}}

clang/unittests/Support/TimeProfilerTest.cpp

 | EvaluateAsRValue (<test.cc:9:14>)
 | EvaluateForOverflow (<test.cc:9:9, col:14>)
 | isPotentialConstantExpr (slow_namespace::slow_func)
 | EvaluateAsBooleanCondition (<test.cc:8:21, col:25>)
 | | EvaluateAsRValue (<test.cc:8:21, col:25>)
 | EvaluateAsBooleanCondition (<test.cc:8:21, col:25>)
 | | EvaluateAsRValue (<test.cc:8:21, col:25>)
 | EvaluateAsInitializer (slow_value)
-| EvaluateAsConstantExpr (<test.cc:17:33, col:59>)
 | EvaluateAsConstantExpr (<test.cc:18:11, col:37>)
 | EvaluateAsRValue (<test.cc:22:14, line:23:58>)
 | EvaluateAsInitializer (slow_init_list)
 | PerformPendingInstantiations
 )");
 
   // NOTE: If this test is failing, run this test with
   // `llvm::errs() << TraceGraph;` and change the assert above.

libcxx/include/__type_traits/is_constant_evaluated.h

 
 #if _LIBCPP_STD_VER >= 20
 _LIBCPP_INLINE_VISIBILITY inline constexpr bool is_constant_evaluated() noexcept {
   return __builtin_is_constant_evaluated();
 }
 #endif
 
 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR bool __libcpp_is_constant_evaluated() _NOEXCEPT {
+#ifndef _LIBCPP_CXX03_LANG
   return __builtin_is_constant_evaluated();
+#else
+  return false;
+#endif
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_CONSTANT_EVALUATED_H

libcxx/test/libcxx/algorithms/robust_against_copying_comparators.pass.cpp

#endif
     (void)std::is_heap_until(first, last, Less<T>(&copies)); assert(copies == 0);
     (void)std::is_partitioned(first, last, UnaryTrue<T>(&copies)); assert(copies == 0);
     (void)std::is_permutation(first, last, first2, Equal<T>(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 11
     (void)std::is_permutation(first, last, first2, last2, Equal<T>(&copies)); assert(copies == 0);
 #endif
     (void)std::is_sorted(first, last, Less<T>(&copies)); assert(copies == 0);
     (void)std::is_sorted_until(first, last, Less<T>(&copies)); assert(copies == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED) { (void)std::inplace_merge(first, mid, last, Less<T>(&copies)); assert(copies == 0); }
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) { (void)std::inplace_merge(first, mid, last, Less<T>(&copies)); assert(copies == 0); }
     (void)std::lexicographical_compare(first, last, first2, last2, Less<T>(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 17
     (void)std::lexicographical_compare_three_way(first, last, first2, last2, ThreeWay<T>(&copies)); assert(copies == 0);
 #endif
     (void)std::lower_bound(first, last, value, Less<T>(&copies)); assert(copies == 0);
     (void)std::make_heap(first, last, Less<T>(&copies)); assert(copies == 0);
     (void)std::max(value, value, Less<T>(&copies)); assert(copies == 0);
 #if TEST_STD_VER >= 11
#endif
     (void)std::set_intersection(first, mid, mid, last, first2, Less<T>(&copies)); assert(copies == 0);
     (void)std::set_symmetric_difference(first, mid, mid, last, first2, Less<T>(&copies)); assert(copies == 0);
     (void)std::set_union(first, mid, mid, last, first2, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort(first, first+3, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort(first, first+4, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort(first, first+5, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort(first, last, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort_heap(first, last, Less<T>(&copies)); assert(copies == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED) { (void)std::stable_partition(first, last, UnaryTrue<T>(&copies)); assert(copies == 0); }
-    if (!TEST_IS_CONSTANT_EVALUATED) { (void)std::stable_sort(first, last, Less<T>(&copies)); assert(copies == 0); }
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) { (void)std::stable_partition(first, last, UnaryTrue<T>(&copies)); assert(copies == 0); }
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) { (void)std::stable_sort(first, last, Less<T>(&copies)); assert(copies == 0); }
     (void)std::transform(first, last, first2, UnaryTransform<T>(&copies)); assert(copies == 0);
     (void)std::transform(first, mid, mid, first2, BinaryTransform<T>(&copies)); assert(copies == 0);
     (void)std::unique(first, last, Equal<T>(&copies)); assert(copies == 0);
     (void)std::unique_copy(first, last, first2, Equal<T>(&copies)); assert(copies == 0);
     (void)std::upper_bound(first, last, value, Less<T>(&copies)); assert(copies == 0);
 
     return true;
 }

libcxx/test/libcxx/strings/basic.string/string.capacity/PR53170.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 bool test() {
     // Test that a call to reserve() does shrink the string.
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
         S s(1000, 'a');
         typename S::size_type old_cap = s.capacity();
         s.resize(20);
         assert(s.capacity() == old_cap);
 
         s.reserve();
         assert(s.capacity() < old_cap);
     }

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp

auto to_subranges = std::views::transform([](auto& vec) {
     std::vector<std::ranges::subrange<Iter, Sent>> to_subrange_vector(range2.begin(), range2.end());
 
     std::ranges::copy(subrange_vector | std::views::join, (to_subrange_vector | std::views::join).begin());
     assert(std::ranges::equal(to_subrange_vector | std::views::join, std::array{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}));
   }
 }
 
 int main(int, char**) {
-  if (!std::is_constant_evaluated()) {
-    test_containers<std::deque<int>, std::deque<int>>();
-    test_containers<std::deque<int>, std::vector<int>>();
-    test_containers<std::vector<int>, std::deque<int>>();
-    test_containers<std::vector<int>, std::vector<int>>();
-  }
 
   types::for_each(types::forward_iterator_list<int*>{}, []<class Iter> {
     test_join_view<Iter, Iter>();
     test_join_view<Iter, sentinel_wrapper<Iter>>();
     test_join_view<Iter, sized_sentinel<Iter>>();
   });
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

TEST_CONSTEXPR_CXX23 void operator()() {
     types::for_each(types::concatenate_t<types::cpp17_input_iterator_list<std::unique_ptr<int>*>,
                                          types::type_list<cpp17_output_iterator<std::unique_ptr<int>*> > >(),
                     Test1<InIter>());
   }
 };
 
 TEST_CONSTEXPR_CXX20 bool test() {
   types::for_each(types::cpp17_input_iterator_list<int*>(), TestOutIters());
-  if (TEST_STD_VER >= 23 || !TEST_IS_CONSTANT_EVALUATED)
+  if (TEST_STD_VER >= 23 || !TEST_IS_CONSTANT_EVALUATED_CXX20)
     types::for_each(types::cpp17_input_iterator_list<std::unique_ptr<int>*>(), Test1OutIters());
 
   { // Make sure that padding bits aren't copied
     Derived src(1, 2, 3);
     Derived dst(4, 5, 6);
     std::move(static_cast<PaddedBase*>(&src), static_cast<PaddedBase*>(&src) + 1, static_cast<PaddedBase*>(&dst));
     assert(dst.a_ == 1);
     assert(dst.b_ == 2);

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp

struct Test1OutIters {
   TEST_CONSTEXPR_CXX23 void operator()() {
     types::for_each(types::concatenate_t<types::bidirectional_iterator_list<std::unique_ptr<int>*> >(),
                     Test1<InIter>());
   }
 };
 
 TEST_CONSTEXPR_CXX20 bool test() {
   types::for_each(types::bidirectional_iterator_list<int*>(), TestOutIters());
-  if (TEST_STD_VER >= 23 || !TEST_IS_CONSTANT_EVALUATED)
+  if (TEST_STD_VER >= 23 || !TEST_IS_CONSTANT_EVALUATED_CXX20)
     types::for_each(types::bidirectional_iterator_list<std::unique_ptr<int>*>(), Test1OutIters());
 
   { // Make sure that padding bits aren't copied
     Derived src(1, 2, 3);
     Derived dst(4, 5, 6);
     std::move_backward(
         static_cast<PaddedBase*>(&src), static_cast<PaddedBase*>(&src) + 1, static_cast<PaddedBase*>(&dst) + 1);
     assert(dst.a_ == 1);

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp

static_assert(std::is_same<decltype(std::find(Iter(arr), Iter(arr), 0)), Iter>::value, "");
       assert(base(iter) == arr + 9);
     }
 
     { // if no element matches, last is returned
       Iter iter = std::find(Iter(arr), Iter(arr + 10), CompareT(20));
       assert(base(iter) == arr + 10);
     }
 
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
       comparable_data.clear();
   }
 };
 
 template <class IndexT>
 class Comparable {
   IndexT index_;
 

libcxx/test/std/algorithms/robust_against_proxy_iterators_lifetime_bugs.pass.cpp

#endif
   // TODO: set_difference
   // TODO: set_intersection
   // TODO: set_symmetric_difference
   // TODO: set_union
   test(simple_in, [&](I b, I e) { (void) std::remove(b, e, x); });
   test(simple_in, [&](I b, I e) { (void) std::remove_if(b, e, is_neg); });
   test(simple_in, [&](I b, I e) { (void) std::reverse(b, e); });
   // TODO: rotate
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     test(simple_in, [&](I b, I e) { (void) std::shuffle(b, e, rand_gen()); });
   // TODO: unique
   test(simple_in, [&](I b, I e) { (void) std::partition(b, e, is_neg); });
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     test(simple_in, [&](I b, I e) { (void) std::stable_partition(b, e, is_neg); });
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     test(sort_test_in, [&](I b, I e) { (void) std::sort(b, e); });
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     test(sort_test_in, [&](I b, I e) { (void) std::stable_sort(b, e); });
   // TODO: partial_sort
   // TODO: nth_element
   // TODO: inplace_merge
   test(simple_in, [&](I b, I e) { (void) std::make_heap(b, e); });
   // TODO: push_heap
   // TODO: pop_heap
   // TODO: sort_heap

libcxx/test/std/algorithms/robust_re_difference_type.compile.pass.cpp

 #if TEST_STD_VER > 11
     (void)std::is_permutation(first, last, first2, last2);
     (void)std::is_permutation(first, last, first2, last2, std::equal_to<void*>());
 #endif
     (void)std::is_sorted(first, last);
     (void)std::is_sorted(first, last, std::less<void*>());
     (void)std::is_sorted_until(first, last);
     (void)std::is_sorted_until(first, last, std::less<void*>());
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::inplace_merge(first, mid, last);
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::inplace_merge(first, mid, last, std::less<void*>());
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) (void)std::inplace_merge(first, mid, last);
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) (void)std::inplace_merge(first, mid, last, std::less<void*>());
     (void)std::iter_swap(first, mid);
     (void)std::lexicographical_compare(first, last, first2, last2);
     (void)std::lexicographical_compare(first, last, first2, last2, std::less<void*>());
 #if TEST_STD_VER > 17
     // `lexicographical_compare_three_way` static_asserts that the difference type is an integer, as
     // required by https://eel.is/c++draft/iterator.iterators#2.2
     //(void)std::lexicographical_compare_three_way(first, last, first2, last2);
     //(void)std::lexicographical_compare_three_way(first, last, first2, last2, std::compare_three_way());

 #if TEST_STD_VER > 17
     (void)std::shift_left(first, last, count);
     (void)std::shift_right(first, last, count);
 #endif
     (void)std::sort(first, last);
     (void)std::sort(first, last, std::less<void*>());
     (void)std::sort_heap(first, last);
     (void)std::sort_heap(first, last, std::less<void*>());
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::stable_partition(first, last, UnaryTrue());
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::stable_sort(first, last);
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::stable_sort(first, last, std::less<void*>());
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) (void)std::stable_partition(first, last, UnaryTrue());
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) (void)std::stable_sort(first, last);
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) (void)std::stable_sort(first, last, std::less<void*>());
     (void)std::swap_ranges(first, last, first2);
     (void)std::transform(first, last, first2, UnaryTransform());
     (void)std::transform(first, mid, mid, first2, BinaryTransform());
     (void)std::unique(first, last);
     (void)std::unique(first, last, std::equal_to<void*>());
     (void)std::unique_copy(first, last, first2);
     (void)std::unique_copy(first, last, first2, std::equal_to<void*>());
     (void)std::upper_bound(first, last, value);

libcxx/test/std/containers/sequences/vector.bool/reserve.pass.cpp

#if TEST_STD_VER >= 11
         assert(v.size() == 100);
         assert(v.capacity() >= 100);
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() >= 150);
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
         std::vector<bool, limited_allocator<bool, 10> > v;
         v.reserve(5);
         try {
             // A typical implementation would allocate chunks of bits.
             // In libc++ the chunk has the same size as the machine word. It is
             // reasonable to assume that in practice no implementation would use
             // 64 kB or larger chunks.
             v.reserve(10 * 65536);

libcxx/test/std/containers/sequences/vector/access.pass.cpp

 TEST_CONSTEXPR_CXX20 void test_get_basic(Vector& c, int start_value) {
     const int n = static_cast<int>(c.size());
     for (int i = 0; i < n; ++i)
         assert(c[i] == start_value + i);
     for (int i = 0; i < n; ++i)
         assert(c.at(i) == start_value + i);
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
         try {
             TEST_IGNORE_NODISCARD c.at(n);
             assert(false);
         } catch (const std::out_of_range&) {}
     }
 #endif
 
     assert(c.front() == start_value);

libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp

TEST_CONSTEXPR_CXX20 bool tests() {
         assert(v.size() == 100);
         assert(v.capacity() == 100);
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() == 150);
         assert(is_contiguous_container_asan_correct(v));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
         std::vector<int> v;
         std::size_t sz = v.max_size() + 1;
 
         try {
             v.reserve(sz);
             assert(false);
         } catch (const std::length_error&) {
             assert(v.size() == 0);
             assert(v.capacity() == 0);
         }
     }
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
         std::vector<int> v(10, 42);
         int* previous_data = v.data();
         std::size_t previous_capacity = v.capacity();
         std::size_t sz = v.max_size() + 1;
 
         try {
             v.reserve(sz);
             assert(false);
#if TEST_STD_VER >= 11
       assert(v.capacity() == 100);
       v.reserve(150);
       assert(v.size() == 100);
       assert(v.capacity() == 150);
       assert(is_contiguous_container_asan_correct(v));
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
         std::vector<int, limited_allocator<int, 100> > v;
         v.reserve(50);
         assert(v.capacity() == 50);
         assert(is_contiguous_container_asan_correct(v));
         try {
             v.reserve(101);
             assert(false);
         } catch (const std::length_error&) {

libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp

TEST_CONSTEXPR_CXX20 bool tests() {
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
         std::vector<int, limited_allocator<int, 400> > v(100);
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         LIBCPP_ASSERT(v.capacity() == 200); // assumes libc++'s 2x growth factor
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }

libcxx/test/std/strings/basic.string/string.access/at.pass.cpp

 {
     const S& cs = s;
     if (pos < s.size())
     {
         assert(s.at(pos) == s[pos]);
         assert(cs.at(pos) == cs[pos]);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.at(pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp

if (res_arg <= s.max_size())
         assert(s == s0);
         assert(s.capacity() >= res_arg);
         assert(s.capacity() >= s.size());
 #if TEST_STD_VER > 17
         assert(s.capacity() >= old_cap); // reserve never shrinks as of P0966 (C++20)
 #endif
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.reserve(res_arg);
             LIBCPP_ASSERT(s.__invariants());
             assert(false);
         }
         catch (std::length_error&)

libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp

 {
     if (n <= s.max_size())
     {
         s.resize(n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.resize(n);
             assert(false);
         }
         catch (std::length_error&)
         {

libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp

 {
     if (n <= s.max_size())
     {
         s.resize(n, c);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.resize(n, c);
             assert(false);
         }
         catch (std::length_error&)
         {

libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp

if (pos <= sv.size())
         assert(pos <= sv.size());
         std::size_t rlen = std::min(sv.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= sv.size())
         assert(pos <= sv.size());
         std::size_t rlen = std::min(sv.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

#if TEST_STD_VER >= 11
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(), A());
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
   }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     const char * p1 = "This is my first string";
     const char * p2 = "This is my second string";
 
     alloc_imp imp1;
     alloc_imp imp2;
     S s1(p1, A(&imp1));

libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp

if (pos <= str.size())
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = str.size() - pos;
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             S s2(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= str.size())
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             S s2(str, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= str.size())
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             S s2(str, pos, n, a);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp

 {
     if (pos <= sv.size())
     {
         s.append(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.append(sv, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= sv.size())
     {
         s.append(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.append(sv, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
#endif
     test(s_short, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
          std::string("hello\0", 6));
     test(s_long, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
          std::string("Lorem ipsum dolor sit amet, consectetur/\0", 41));
 
     s_sneaky.reserve(12);
     test(s_sneaky, s_sneaky.data(), s_sneaky.data() + 6, std::string("hellohello\0", 11));
 
-     if (!TEST_IS_CONSTANT_EVALUATED) {
+     if (!TEST_IS_CONSTANT_EVALUATED_CXX20) {
        const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
        test(s_othertype, first + 2, first + 5, std::string("hellollo"));
      }
   }
 
   { // test with a move iterator that returns char&&
     typedef forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp

 {
     if (pos <= str.size())
     {
         s.append(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.append(str, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= str.size())
     {
         s.append(str, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.append(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp

 {
     if (pos <= sv.size())
     {
         s.assign(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.assign(sv, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= sv.size())
     {
         s.assign(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.assign(sv, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp

 {
     if (pos <= str.size())
     {
         s.assign(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.assign(str, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= str.size())
     {
         s.assign(str, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.assign(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp

test(S str, typename S::value_type* s, typename S::size_type n,
     {
         typename S::size_type r = cs.copy(s, n, pos);
         typename S::size_type rlen = std::min(n, cs.size() - pos);
         assert(r == rlen);
         for (r = 0; r < rlen; ++r)
             assert(S::traits_type::eq(cs[pos+r], s[r]));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             typename S::size_type r = cs.copy(s, n, pos);
             ((void)r); // Prevent unused warning
             assert(false);
         }
         catch (std::out_of_range&)

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp

test(S s, typename S::size_type pos, typename S::size_type n, S expected)
     if (pos <= old_size)
     {
         s.erase(pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s[s.size()] == typename S::value_type());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.erase(pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
test(S s, typename S::size_type pos, S expected)
     if (pos <= old_size)
     {
         s.erase(pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s[s.size()] == typename S::value_type());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.erase(pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
#endif
     typedef std::string S;
     const std::uint8_t p[] = "ABCD";
 
     S s;
     s.insert(s.begin(), p, p + 4);
     assert(s == "ABCD");
   }
 
-  if (!TEST_IS_CONSTANT_EVALUATED) { // regression-test inserting into self in sneaky ways
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20) { // regression-test inserting into self in sneaky ways
     std::string s_short = "hello";
     std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
     std::string s_othertype = "hello";
     const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
 
     test(s_short, 0, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
          std::string("\0hello", 6));
     test(s_long, 0, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

test(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2,
     S s0 = s;
     if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.insert(pos1, sv, pos2, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos1, sv, pos2, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
test_npos(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2, S expected)
     S s0 = s;
     if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.insert(pos1, sv, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos1, sv, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp

test(S s, typename S::size_type pos, const typename S::value_type* str, S expected)
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

test(S s, typename S::size_type pos, const typename S::value_type* str,
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos, str, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp

test(S s, typename S::size_type pos, typename S::size_type n,
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, n, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos, n, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp

test(S s, typename S::size_type pos, S str, S expected)
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

test(S s, typename S::size_type pos1, S str, typename S::size_type pos2,
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos1, str, pos2, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
test_npos(S s, typename S::size_type pos1, S str, typename S::size_type pos2, S expected)
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos1, str, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp

test(S s, typename S::size_type pos, SV sv, S expected)
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, sv);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.insert(pos, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+20, S("abcdefghijklmnopqrst12345678901234567890"));
 
     return true;
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 bool test9() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX20) { // test iterator operations that throw
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter());

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

if (pos1 <= old_size && pos2 <= sv.size())
         s.replace(pos1, n1, sv, pos2, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         SizeT xlen = std::min<SizeT>(n1, old_size - pos1);
         SizeT rlen = std::min<SizeT>(n2, sv.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos1, n1, sv, pos2, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos1 <= old_size && pos2 <= sv.size())
         s.replace(pos1, n1, sv, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         SizeT xlen = std::min<SizeT>(n1, old_size - pos1);
         SizeT rlen = std::min<SizeT>(S::npos, sv.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos1, n1, sv, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp

if (pos <= old_size)
         s.replace(pos, n1, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = S::traits_type::length(str);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp

if (pos <= old_size)
         s.replace(pos, n1, str, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = n2;
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos, n1, str, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp

if (pos <= old_size)
         s.replace(pos, n1, n2, c);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = n2;
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos, n1, n2, c);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp

if (pos1 <= old_size)
         s.replace(pos1, n1, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = str.size();
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

if (pos1 <= old_size && pos2 <= str.size())
         s.replace(pos1, n1, str, pos2, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(n2, str.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos1, n1, str, pos2, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos1 <= old_size && pos2 <= str.size())
         s.replace(pos1, n1, str, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(S::npos, str.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos1, n1, str, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp

if (pos1 <= old_size)
         s.replace(pos1, n1, sv);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = sv.size();
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             s.replace(pos1, n1, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp

 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      SV sv,      typename S::size_type pos2, typename S::size_type n2, int x)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     if (pos1 <= s.size() && pos2 <= sv.size())
         assert(sign(s.compare(pos1, n1, sv, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
 #endif
 }
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test_npos(const S& s, typename S::size_type pos1, typename S::size_type n1,
           SV sv,      typename S::size_type pos2, int x)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     if (pos1 <= s.size() && pos2 <= sv.size())
         assert(sign(s.compare(pos1, n1, sv, pos2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const typename S::value_type* str, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2, int x)
 {
     if (pos <= s.size())
         assert(sign(s.compare(pos, n1, str, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos, n1, str, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const S& str, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp

 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s,   typename S::size_type pos1, typename S::size_type n1,
      const S& str, typename S::size_type pos2, typename S::size_type n2, int x)
 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
 #endif
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test_npos(const S& s,   typename S::size_type pos1, typename S::size_type n1,
           const S& str, typename S::size_type pos2, int x)
 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp

 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, sv)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp

if (pos <= s.size())
         S str = s.substr(pos, n);
         LIBCPP_ASSERT(str.__invariants());
         assert(pos <= s.size());
         typename S::size_type rlen = std::min(n, s.size() - pos);
         assert(str.size() == rlen);
         assert(S::traits_type::compare(s.data()+pos, str.data(), rlen) == 0);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!TEST_IS_CONSTANT_EVALUATED_CXX20)
     {
         try
         {
             S str = s.substr(pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i == j);
             assert((v[i] == v[j]) == expected);
             assert((v[i].data() == v[j]) == expected);
             assert((v[i] == v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) == v[j]) == expected);
             assert((v[i] == ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) == v[j]) == expected);
                 assert((v[i] == std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc == abc0def) == false);
     assert((abc == abcdef) == false);
     assert((abc0def == abc) == false);
     assert((abc0def == abcdef) == false);
     assert((abcdef == abc) == false);
     assert((abcdef == abc0def) == false);
 
     assert((abc.data() == abc0def) == false);
     assert((abc0def == abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) == abc0def) == false);
         assert((abc0def == std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/greater.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i > j);
             assert((v[i] > v[j]) == expected);
             assert((v[i].data() > v[j]) == expected);
             assert((v[i] > v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) > v[j]) == expected);
             assert((v[i] > ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) > v[j]) == expected);
                 assert((v[i] > std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc > abc0def) == false);
     assert((abc > abcdef) == false);
     assert((abc0def > abc) == true);
     assert((abc0def > abcdef) == false);
     assert((abcdef > abc) == true);
     assert((abcdef > abc0def) == true);
 
     assert((abc.data() > abc0def) == false);
     assert((abc0def > abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) > abc0def) == false);
         assert((abc0def > std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/greater_equal.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i >= j);
             assert((v[i] >= v[j]) == expected);
             assert((v[i].data() >= v[j]) == expected);
             assert((v[i] >= v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) >= v[j]) == expected);
             assert((v[i] >= ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) >= v[j]) == expected);
                 assert((v[i] >= std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc >= abc0def) == false);
     assert((abc >= abcdef) == false);
     assert((abc0def >= abc) == true);
     assert((abc0def >= abcdef) == false);
     assert((abcdef >= abc) == true);
     assert((abcdef >= abc0def) == true);
 
     assert((abc.data() >= abc0def) == false);
     assert((abc0def >= abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) >= abc0def) == false);
         assert((abc0def >= std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/less.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i < j);
             assert((v[i] < v[j]) == expected);
             assert((v[i].data() < v[j]) == expected);
             assert((v[i] < v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) < v[j]) == expected);
             assert((v[i] < ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) < v[j]) == expected);
                 assert((v[i] < std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc < abc0def) == true);
     assert((abc < abcdef) == true);
     assert((abc0def < abc) == false);
     assert((abc0def < abcdef) == true);
     assert((abcdef < abc) == false);
     assert((abcdef < abc0def) == false);
 
     assert((abc.data() < abc0def) == true);
     assert((abc0def < abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) < abc0def) == true);
         assert((abc0def < std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/less_equal.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i <= j);
             assert((v[i] <= v[j]) == expected);
             assert((v[i].data() <= v[j]) == expected);
             assert((v[i] <= v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) <= v[j]) == expected);
             assert((v[i] <= ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) <= v[j]) == expected);
                 assert((v[i] <= std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc <= abc0def) == true);
     assert((abc <= abcdef) == true);
     assert((abc0def <= abc) == false);
     assert((abc0def <= abcdef) == true);
     assert((abcdef <= abc) == false);
     assert((abcdef <= abc0def) == false);
 
     assert((abc.data() <= abc0def) == true);
     assert((abc0def <= abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) <= abc0def) == true);
         assert((abc0def <= std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/not_equal.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i != j);
             assert((v[i] != v[j]) == expected);
             assert((v[i].data() != v[j]) == expected);
             assert((v[i] != v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) != v[j]) == expected);
             assert((v[i] != ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) != v[j]) == expected);
                 assert((v[i] != std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc != abc0def) == true);
     assert((abc != abcdef) == true);
     assert((abc0def != abc) == true);
     assert((abc0def != abcdef) == true);
     assert((abcdef != abc) == true);
     assert((abcdef != abc0def) == true);
 
     assert((abc.data() != abc0def) == true);
     assert((abc0def != abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX14 || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) != abc0def) == true);
         assert((abc0def != std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.verify.cpp

 int main(int, char**)
 {
 #ifndef __cpp_lib_is_constant_evaluated
   // expected-error@+1 {{no member named 'is_constant_evaluated' in namespace 'std'}}
   bool b = std::is_constant_evaluated();
 #else
   // expected-error-re@+1 {{{{(static_assert|static assertion)}} failed}}
   static_assert(!std::is_constant_evaluated(), "");
-  // expected-warning@-1 0-1 {{'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}}
+  // expected-warning-re@-1 0-1 {{'std::is_constant_evaluated' will always evaluate to {{('true' in a manifestly constant-evaluated expression|true in this context)}}}}
 #endif
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp

 template <bool IsArray>
 TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   {
     std::unique_ptr<VT> s1(newValue<VT>(expect_alive));
     A* p = s1.get();
     std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == (expect_alive * 2));
     s2 = std::move(s1);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     assert(s2.get() == p);
     assert(s1.get() == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     std::unique_ptr<VT, Deleter<VT> > s1(newValue<VT>(expect_alive),
                                          Deleter<VT>(5));
     A* p = s1.get();
     std::unique_ptr<VT, Deleter<VT> > s2(newValue<VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == (expect_alive * 2));
     s2 = std::move(s1);
     assert(s2.get() == p);
     assert(s1.get() == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     assert(s2.get_deleter().state() == 5);
     assert(s1.get_deleter().state() == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     CDeleter<VT> d1(5);
     std::unique_ptr<VT, CDeleter<VT>&> s1(newValue<VT>(expect_alive), d1);
     A* p = s1.get();
     CDeleter<VT> d2(6);
     std::unique_ptr<VT, CDeleter<VT>&> s2(newValue<VT>(expect_alive), d2);
     s2 = std::move(s1);
     assert(s2.get() == p);
     assert(s1.get() == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     assert(d1.state() == 5);
     assert(d2.state() == 5);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     std::unique_ptr<VT> s(newValue<VT>(expect_alive));
     A* p = s.get();
     s = std::move(s);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     assert(s.get() == p);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 template <bool IsArray>
 TEST_CONSTEXPR_CXX23 void test_sfinae() {
   typedef typename std::conditional<IsArray, int[], int>::type VT;
   {
     typedef std::unique_ptr<VT> U;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp

CD2 cd2;
     assert(checkArg<CD2 const&>(u1.get_deleter()));
   }
 }
 
 TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_sfinae</*IsArray*/false>();
     test_noexcept<false>();
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       test_deleter_value_category<false>();
   }
   {
     test_sfinae</*IsArray*/true>();
     test_noexcept<true>();
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       test_deleter_value_category<true>();
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 23
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp

 
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "unique_ptr_test_helper.h"
 
 template <class APtr, class BPtr>
 TEST_CONSTEXPR_CXX23 void testAssign(APtr& aptr, BPtr& bptr) {
   A* p = bptr.get();
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 2);
   aptr = std::move(bptr);
   assert(aptr.get() == p);
   assert(bptr.get() == 0);
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 1);
     assert(B::count == 1);
   }
 }
 
 template <class LHS, class RHS>
 TEST_CONSTEXPR_CXX23 void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) {
   assert(lhs.get_deleter().state() == LHSState);

 
 TEST_CONSTEXPR_CXX23 bool test() {
   test_sfinae();
   {
     std::unique_ptr<B> bptr(new B);
     std::unique_ptr<A> aptr(new A);
     testAssign(aptr, bptr);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
   {
     Deleter<B> del(42);
     std::unique_ptr<B, Deleter<B> > bptr(new B, std::move(del));
     std::unique_ptr<A, Deleter<A> > aptr(new A);
     testAssign(aptr, bptr);
     checkDeleter(aptr, bptr, 42, 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
   {
     CDeleter<A> adel(6);
     CDeleter<B> bdel(42);
     std::unique_ptr<B, CDeleter<B>&> bptr(new B, bdel);
     std::unique_ptr<A, CDeleter<A>&> aptr(new A, adel);
     testAssign(aptr, bptr);
     checkDeleter(aptr, bptr, 42, 42);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 23
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp

 
 // test assignment from null
 template <bool IsArray>
 TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   {
     std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     s2 = NULL;
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 0);
     assert(s2.get() == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
   return true;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp

 // test assignment from null
 
 template <bool IsArray>
 TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   {
     std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     s2 = nullptr;
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 0);
     assert(s2.get() == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
   return true;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp

TEST_CONSTEXPR_CXX23 void test_basic() {
   const int expect_alive = IsArray ? 5 : 1;
   {
     typedef std::unique_ptr<VT> APtr;
     APtr s(newValue<VT>(expect_alive));
     A* p = s.get();
     APtr s2 = std::move(s);
     assert(s2.get() == p);
     assert(s.get() == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     typedef Deleter<VT> MoveDel;
     typedef std::unique_ptr<VT, MoveDel> APtr;
     MoveDel d(5);
     APtr s(newValue<VT>(expect_alive), std::move(d));
     assert(d.state() == 0);
     assert(s.get_deleter().state() == 5);
     A* p = s.get();
     APtr s2 = std::move(s);
     assert(s2.get() == p);
     assert(s.get() == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     assert(s2.get_deleter().state() == 5);
     assert(s.get_deleter().state() == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     typedef NCDeleter<VT> NonCopyDel;
     typedef std::unique_ptr<VT, NonCopyDel&> APtr;
 
     NonCopyDel d;
     APtr s(newValue<VT>(expect_alive), d);
     A* p = s.get();
     APtr s2 = std::move(s);
     assert(s2.get() == p);
     assert(s.get() == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     d.set_state(6);
     assert(s2.get_deleter().state() == d.state());
     assert(s.get_deleter().state() == d.state());
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     sink1<VT>(source1<VT>());
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 0);
     sink2<VT>(source2<VT>());
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 template <class VT>
 TEST_CONSTEXPR_CXX23 void test_noexcept() {
 #if TEST_STD_VER >= 11
   {
     typedef std::unique_ptr<VT> U;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp

TD2 d2;
     assert(checkArg<TD2 const&>(u1.get_deleter()));
   }
 }
 
 TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_sfinae</*IsArray*/false>();
     test_noexcept<false>();
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       test_deleter_value_category<false>();
   }
   {
     test_sfinae</*IsArray*/true>();
     test_noexcept<true>();
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       test_deleter_value_category<true>();
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 23
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp

TEST_CONSTEXPR_CXX23 void checkDeleter(LHS& lhs, RHS& rhs, int LHSVal, int RHSVal) {
   assert(lhs.get_deleter().state() == LHSVal);
   assert(rhs.get_deleter().state() == RHSVal);
 }
 
 template <class LHS, class RHS>
 TEST_CONSTEXPR_CXX23 void checkCtor(LHS& lhs, RHS& rhs, A* RHSVal) {
   assert(lhs.get() == RHSVal);
   assert(rhs.get() == nullptr);
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 1);
     assert(B::count == 1);
   }
 }
 
 TEST_CONSTEXPR_CXX23 void checkNoneAlive() {
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
 }
 
 template <class T>
 struct NCConvertingDeleter {
   TEST_CONSTEXPR_CXX23 NCConvertingDeleter()                      = default;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp

#if TEST_STD_VER >= 11
 
     // Test for explicit
     static_assert(!std::is_convertible<A*, U1>::value, "");
     static_assert(!std::is_convertible<A*, U2>::value, "");
   }
 #endif
   {
     A* p = newValue<ValueT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
 
     std::unique_ptr<ValueT> s(p);
     assert(s.get() == p);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     A* p = newValue<ValueT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
 
     std::unique_ptr<ValueT, NCDeleter<ValueT> > s(p);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     A* p = newValue<ValueT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
 
     std::unique_ptr<ValueT, DefaultCtorDeleter<ValueT> > s(p);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 TEST_CONSTEXPR_CXX23 void test_derived() {
   {
     B* p = new B;
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert(A::count == 1);
       assert(B::count == 1);
     }
     std::unique_ptr<A> s(p);
     assert(s.get() == p);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
   {
     B* p = new B;
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert(A::count == 1);
       assert(B::count == 1);
     }
     std::unique_ptr<A, NCDeleter<A> > s(p);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
 }
 
 #if TEST_STD_VER >= 11
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp

 }
 
 template <bool IsArray>
 TEST_CONSTEXPR_CXX23 void test_basic() {
   typedef typename std::conditional<!IsArray, A, A[]>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   { // MoveConstructible deleter (C-1)
     A* p = newValue<VT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     std::unique_ptr<VT, Deleter<VT> > s(p, Deleter<VT>(5));
     assert(s.get() == p);
     assert(s.get_deleter().state() == 5);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   { // CopyConstructible deleter (C-2)
     A* p = newValue<VT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     CopyDeleter<VT> d(5);
     std::unique_ptr<VT, CopyDeleter<VT> > s(p, d);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 5);
     d.set_state(6);
     assert(s.get_deleter().state() == 5);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   { // Reference deleter (C-3)
     A* p = newValue<VT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     NCDeleter<VT> d(5);
     std::unique_ptr<VT, NCDeleter<VT>&> s(p, d);
     assert(s.get() == p);
     assert(&s.get_deleter() == &d);
     assert(s.get_deleter().state() == 5);
     d.set_state(6);
     assert(s.get_deleter().state() == 6);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   { // Const Reference deleter (C-4)
     A* p = newValue<VT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     NCConstDeleter<VT> d(5);
     std::unique_ptr<VT, NCConstDeleter<VT> const&> s(p, d);
     assert(s.get() == p);
     assert(s.get_deleter().state() == 5);
     assert(&s.get_deleter() == &d);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     { // Void and function pointers (C-6,7)
       typedef typename std::conditional<IsArray, int[], int>::type VT2;
       my_free_called = false;
       {
         int i = 0;
         std::unique_ptr<VT2, void (*)(void*)> s(&i, my_free);
         assert(s.get() == &i);
         assert(s.get_deleter() == my_free);
         assert(!my_free_called);
       }
       assert(my_free_called);
     }
   }
 }
 
 TEST_CONSTEXPR_CXX23 void test_basic_single() {
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
   { // Derived pointers (C-5)
     B* p = new B;
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert(A::count == 1);
       assert(B::count == 1);
     }
     std::unique_ptr<A, Deleter<A> > s(p, Deleter<A>(5));
     assert(s.get() == p);
     assert(s.get_deleter().state() == 5);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
 
     { // Void and function pointers (C-6,7)
       my_free_called = false;
       {
         int i = 0;
         std::unique_ptr<void, void (*)(void*)> s(&i, my_free);

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp

#if TEST_STD_VER >= 11
   {
     using U = std::unique_ptr<VT>;
     U u; ((void)u);
     ASSERT_NOEXCEPT(u.release());
   }
 #endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     A* ap = p.get();
     A* a = p.release();
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     assert(p.get() == nullptr);
     assert(ap == a);
     assert(a != nullptr);
 
     if (IsArray)
       delete[] a;
     else
       delete a;
 
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 0);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
   return true;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp

#if TEST_STD_VER >= 11
     using U = std::unique_ptr<VT>;
     U u;
     ((void)u);
     ASSERT_NOEXCEPT(u.reset((A*)nullptr));
   }
 #endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     A* i = p.get();
     assert(i != nullptr);
     A* new_value = newValue<VT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == (expect_alive * 2));
     p.reset(new_value);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     assert(p.get() == new_value);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     std::unique_ptr<const VT> p(newValue<const VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     const A* i = p.get();
     assert(i != nullptr);
     A* new_value = newValue<VT>(expect_alive);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == (expect_alive * 2));
     p.reset(new_value);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     assert(p.get() == new_value);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 template <bool IsArray>
 TEST_CONSTEXPR_CXX23 void test_reset_nullptr() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
 #if TEST_STD_VER >= 11
   {
     using U = std::unique_ptr<VT>;
     U u;
     ((void)u);
     ASSERT_NOEXCEPT(u.reset(nullptr));
   }
 #endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     A* i = p.get();
     assert(i != nullptr);
     p.reset(nullptr);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 0);
     assert(p.get() == nullptr);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 template <bool IsArray>
 TEST_CONSTEXPR_CXX23 void test_reset_no_arg() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   const int expect_alive = IsArray ? 3 : 1;
 #if TEST_STD_VER >= 11
   {
     using U = std::unique_ptr<VT>;
     U u;
     ((void)u);
     ASSERT_NOEXCEPT(u.reset());
   }
 #endif
   {
     std::unique_ptr<VT> p(newValue<VT>(expect_alive));
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == expect_alive);
     A* i = p.get();
     assert(i != nullptr);
     p.reset();
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 0);
     assert(p.get() == nullptr);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 }
 
 TEST_CONSTEXPR_CXX23 bool test() {
   {
     test_reset_pointer</*IsArray*/ false>();
     test_reset_nullptr<false>();
     test_reset_no_arg<false>();

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 TEST_CONSTEXPR_CXX23 bool test() {
   {
     std::unique_ptr<A> p(new A);
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert(A::count == 1);
       assert(B::count == 0);
     }
     A* i = p.get();
     assert(i != nullptr);
     p.reset(new B);
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert(A::count == 1);
       assert(B::count == 1);
     }
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
   {
     std::unique_ptr<A> p(new B);
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert(A::count == 1);
       assert(B::count == 1);
     }
     A* i = p.get();
     assert(i != nullptr);
     p.reset(new B);
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert(A::count == 1);
       assert(B::count == 1);
     }
   }
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 23
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp

 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 struct TT {
   int state_;
   static int count;
   TEST_CONSTEXPR_CXX23 TT() : state_(-1) {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       ++count;
   }
   TEST_CONSTEXPR_CXX23 explicit TT(int i) : state_(i) {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       ++count;
   }
   TEST_CONSTEXPR_CXX23 TT(const TT& a) : state_(a.state_) {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       ++count;
   }
   TEST_CONSTEXPR_CXX23 TT& operator=(const TT& a) {
     state_ = a.state_;
     return *this;
   }
   TEST_CONSTEXPR_CXX23 ~TT() {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       --count;
   }
 
   friend TEST_CONSTEXPR_CXX23 bool operator==(const TT& x, const TT& y) { return x.state_ == y.state_; }
 };
 
 int TT::count = 0;
 
#endif
     assert(s2.get_deleter().state() == 2);
     s1.swap(s2);
     assert(s1.get() == p2);
     assert(*s1.get() == TT(2));
     assert(s1.get_deleter().state() == 2);
     assert(s2.get() == p1);
     assert(*s2.get() == TT(1));
     assert(s2.get_deleter().state() == 1);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(TT::count == (expect_alive * 2));
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(TT::count == 0);
 }
 
 TEST_CONSTEXPR_CXX23 bool test() {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
 
   return true;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp

 
 // unique_ptr
 
 // test op[](size_t)
 
 #include <memory>
 #include <cassert>
 
-// TODO: Move TEST_IS_CONSTANT_EVALUATED into it's own header
+// TODO: Move TEST_IS_CONSTANT_EVALUATED_CXX23 into it's own header
 #include <type_traits>
 
 #include "test_macros.h"
 
 class A {
   int state_;
   static int next_;
 
 public:
   TEST_CONSTEXPR_CXX23 A() : state_(0) {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       state_ = ++next_;
   }
 
   TEST_CONSTEXPR_CXX23 int get() const { return state_; }
 
   friend TEST_CONSTEXPR_CXX23 bool operator==(const A& x, int y) { return x.state_ == y; }
 
   TEST_CONSTEXPR_CXX23 A& operator=(int i) {
     state_ = i;
     return *this;
   }
 };
 
 int A::next_ = 0;
 
 TEST_CONSTEXPR_CXX23 bool test() {
   std::unique_ptr<A[]> p(new A[3]);
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(p[0] == 1);
     assert(p[1] == 2);
     assert(p[2] == 3);
   }
   p[0] = 3;
   p[1] = 2;
   p[2] = 1;
   assert(p[0] == 3);

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp

 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 TEST_CONSTEXPR_CXX23 bool test() {
   std::default_delete<B> d2;
   std::default_delete<A> d1 = d2;
   A* p                      = new B;
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 1);
     assert(B::count == 1);
   }
 
   d1(p);
 
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(A::count == 0);
     assert(B::count == 0);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 23
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 TEST_CONSTEXPR_CXX23 bool test() {
   std::default_delete<A> d;
   A* p = new A;
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 1);
 
   d(p);
 
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 23
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 TEST_CONSTEXPR_CXX23 bool test() {
   std::default_delete<A[]> d;
   A* p = new A[3];
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 3);
 
   d(p);
 
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 23
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp.pass.cpp

#endif
   {
     A* ptr1 = new A;
     A* ptr2 = new A;
     const std::unique_ptr<A, Deleter<A> > p1(ptr1);
     const std::unique_ptr<A, Deleter<A> > p2(ptr2);
 
     assert(!(p1 == p2));
     assert(p1 != p2);
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert((p1 < p2) == (ptr1 < ptr2));
       assert((p1 <= p2) == (ptr1 <= ptr2));
       assert((p1 > p2) == (ptr1 > ptr2));
       assert((p1 >= p2) == (ptr1 >= ptr2));
 #if TEST_STD_VER > 17
       assert((p1 <=> p2) != std::strong_ordering::equal);
       assert((p1 <=> p2) == (ptr1 <=> ptr2));
 #endif
     }
   }
   // Pointers of different type
   {
     A* ptr1 = new A;
     B* ptr2 = new B;
     const std::unique_ptr<A, Deleter<A> > p1(ptr1);
     const std::unique_ptr<B, Deleter<B> > p2(ptr2);
     assert(!(p1 == p2));
     assert(p1 != p2);
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert((p1 < p2) == (ptr1 < ptr2));
       assert((p1 <= p2) == (ptr1 <= ptr2));
       assert((p1 > p2) == (ptr1 > ptr2));
       assert((p1 >= p2) == (ptr1 >= ptr2));
 #if TEST_STD_VER > 17
     assert((p1 <=> p2) != std::strong_ordering::equal);
     assert((p1 <=> p2) == (ptr1 <=> ptr2));
 #endif
     }
   }
   // Pointers of same array type
   {
     A* ptr1 = new A[3];
     A* ptr2 = new A[3];
     const std::unique_ptr<A[], Deleter<A[]> > p1(ptr1);
     const std::unique_ptr<A[], Deleter<A[]> > p2(ptr2);
     assert(!(p1 == p2));
     assert(p1 != p2);
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert((p1 < p2) == (ptr1 < ptr2));
       assert((p1 <= p2) == (ptr1 <= ptr2));
       assert((p1 > p2) == (ptr1 > ptr2));
       assert((p1 >= p2) == (ptr1 >= ptr2));
 #if TEST_STD_VER > 17
     assert((p1 <=> p2) != std::strong_ordering::equal);
     assert((p1 <=> p2) == (ptr1 <=> ptr2));
 #endif
     }
   }
   // Pointers of different array types
   {
     A* ptr1 = new A[3];
     B* ptr2 = new B[3];
     const std::unique_ptr<A[], Deleter<A[]> > p1(ptr1);
     const std::unique_ptr<B[], Deleter<B[]> > p2(ptr2);
     assert(!(p1 == p2));
     assert(p1 != p2);
-    if (!TEST_IS_CONSTANT_EVALUATED) {
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
       assert((p1 < p2) == (ptr1 < ptr2));
       assert((p1 <= p2) == (ptr1 <= ptr2));
       assert((p1 > p2) == (ptr1 > ptr2));
       assert((p1 >= p2) == (ptr1 >= ptr2));
 #if TEST_STD_VER > 17
     assert((p1 <=> p2) != std::strong_ordering::equal);
     assert((p1 <=> p2) == (ptr1 <=> ptr2));
 #endif
     }
   }
   // Default-constructed pointers of same type
   {
     const std::unique_ptr<A, Deleter<A> > p1;
     const std::unique_ptr<A, Deleter<A> > p2;
     assert(p1 == p2);
 #if TEST_STD_VER > 17
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert((p1 <=> p2) == std::strong_ordering::equal);
 #endif
   }
   // Default-constructed pointers of different type
   {
     const std::unique_ptr<A, Deleter<A> > p1;
     const std::unique_ptr<B, Deleter<B> > p2;
     assert(p1 == p2);
 #if TEST_STD_VER > 17
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert((p1 <=> p2) == std::strong_ordering::equal);
 #endif
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 23
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp

 #include <memory>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
 TEST_CONSTEXPR_CXX23 bool test() {
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     AssertEqualityAreNoexcept<std::unique_ptr<int>, nullptr_t>();
     AssertEqualityAreNoexcept<nullptr_t, std::unique_ptr<int> >();
     AssertComparisonsReturnBool<std::unique_ptr<int>, nullptr_t>();
     AssertComparisonsReturnBool<nullptr_t, std::unique_ptr<int> >();
 #if TEST_STD_VER > 17
     AssertOrderReturn<std::strong_ordering, std::unique_ptr<int>, nullptr_t>();
     AssertOrderReturn<std::strong_ordering, nullptr_t, std::unique_ptr<int>>();
 #endif
   }
 
   const std::unique_ptr<int> p1(new int(1));
   assert(!(p1 == nullptr));
   assert(!(nullptr == p1));
   // A pointer to allocated storage and a nullptr can't be compared at compile-time
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     assert(!(p1 < nullptr));
     assert((nullptr < p1));
     assert(!(p1 <= nullptr));
     assert((nullptr <= p1));
     assert((p1 > nullptr));
     assert(!(nullptr > p1));
     assert((p1 >= nullptr));
     assert(!(nullptr >= p1));

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp

 #include "test_macros.h"
 #include "deleter_types.h"
 
 struct A
 {
     int state_;
     static int count;
     TEST_CONSTEXPR_CXX23 A() : state_(0) {
-      if (!TEST_IS_CONSTANT_EVALUATED)
+      if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
         ++count;
     }
     TEST_CONSTEXPR_CXX23 explicit A(int i) : state_(i) {
-      if (!TEST_IS_CONSTANT_EVALUATED)
+      if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
         ++count;
     }
     TEST_CONSTEXPR_CXX23 A(const A& a) : state_(a.state_) {
-      if (!TEST_IS_CONSTANT_EVALUATED)
+      if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
         ++count;
     }
     TEST_CONSTEXPR_CXX23 A& operator=(const A& a) {
       state_ = a.state_;
       return *this;
     }
     TEST_CONSTEXPR_CXX23 ~A() {
-      if (!TEST_IS_CONSTANT_EVALUATED)
+      if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
         --count;
     }
 
     friend TEST_CONSTEXPR_CXX23 bool operator==(const A& x, const A& y) { return x.state_ == y.state_; }
 };
 
 int A::count = 0;
 
TEST_CONSTEXPR_CXX23 bool test() {
     assert(s2.get_deleter().state() == 2);
     swap(s1, s2);
     assert(s1.get() == p2);
     assert(*s1 == A(2));
     assert(s1.get_deleter().state() == 2);
     assert(s2.get() == p1);
     assert(*s2 == A(1));
     assert(s2.get_deleter().state() == 1);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 2);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
   {
     A* p1 = new A[3];
     std::unique_ptr<A[], Deleter<A[]> > s1(p1, Deleter<A[]>(1));
     A* p2 = new A[3];
     std::unique_ptr<A[], Deleter<A[]> > s2(p2, Deleter<A[]>(2));
     assert(s1.get() == p1);
     assert(s1.get_deleter().state() == 1);
     assert(s2.get() == p2);
     assert(s2.get_deleter().state() == 2);
     swap(s1, s2);
     assert(s1.get() == p2);
     assert(s1.get_deleter().state() == 2);
     assert(s2.get() == p1);
     assert(s2.get_deleter().state() == 1);
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       assert(A::count == 6);
   }
-  if (!TEST_IS_CONSTANT_EVALUATED)
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
     assert(A::count == 0);
 #if TEST_STD_VER >= 11
     {
         // test that unique_ptr's specialized swap is disabled when the deleter
         // is non-swappable. Instead we should pick up the generic swap(T, T)
         // and perform 3 move constructions.
         typedef NonSwappableDeleter<int> D;
         D  d(42);

libcxx/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp

 #include "test_macros.h"
 
 TEST_MSVC_DIAGNOSTIC_IGNORED(6294) // Ill-defined for-loop:  initial condition does not satisfy test.  Loop body not executed.
 
 template <std::size_t N>
 TEST_CONSTEXPR_CXX23 void test_char_pointer_ctor()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     try {
       std::bitset<N> v("xxx1010101010xxxx");
       assert(false);
     }
     catch (std::invalid_argument&) {}
   }
 #endif
 

libcxx/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp

 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <std::size_t N>
 TEST_CONSTEXPR_CXX23 void test_string_ctor() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
     try {
         std::string s("xxx1010101010xxxx");
         std::bitset<N> v(s, s.size()+1, 10);
         assert(false);
     }
     catch (std::out_of_range&)
     {
     }

libcxx/test/support/charconv_test_helpers.h

#endif
         assert(r.ec == std::errc::value_too_large);
     }
 
 private:
     static TEST_CONSTEXPR_CXX23 long long fromchars_impl(char const* p, char const* ep, int base, true_type)
     {
         char* last;
         long long r;
-        if (TEST_IS_CONSTANT_EVALUATED)
+        if (TEST_IS_CONSTANT_EVALUATED_CXX23)
           last = const_cast<char*>(std::from_chars(p, ep, r, base).ptr);
         else
           r = strtoll(p, &last, base);
         assert(last == ep);
 
         return r;
     }
 
     static TEST_CONSTEXPR_CXX23 unsigned long long fromchars_impl(char const* p, char const* ep, int base, false_type)
     {
         char* last;
         unsigned long long r;
-        if (TEST_IS_CONSTANT_EVALUATED)
+        if (TEST_IS_CONSTANT_EVALUATED_CXX23)
           last = const_cast<char*>(std::from_chars(p, ep, r, base).ptr);
         else
           r = strtoull(p, &last, base);
         assert(last == ep);
 
         return r;
     }
 #ifndef TEST_HAS_NO_INT128
     static TEST_CONSTEXPR_CXX23 __int128_t fromchars128_impl(char const* p, char const* ep, int base, true_type)
     {
-        if (!TEST_IS_CONSTANT_EVALUATED) {
+        if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
             char* last;
             __int128_t r = strtoll(p, &last, base);
             if(errno != ERANGE) {
                 assert(last == ep);
                 return r;
             }
         }
 
         // When the value doesn't fit in a long long use from_chars. This is
         // not ideal since it does a round-trip test instead if using an
         // external source.
         __int128_t r;
         std::from_chars_result s = std::from_chars(p, ep, r, base);
         assert(s.ec == std::errc{});
         assert(s.ptr == ep);
 
         return r;
     }
 
     static TEST_CONSTEXPR_CXX23 __uint128_t fromchars128_impl(char const* p, char const* ep, int base, false_type)
     {
-        if (!TEST_IS_CONSTANT_EVALUATED) {
+        if (!TEST_IS_CONSTANT_EVALUATED_CXX23) {
             char* last;
             __uint128_t r = strtoull(p, &last, base);
             if(errno != ERANGE) {
                 assert(last == ep);
                 return r;
             }
         }
 

libcxx/test/support/constexpr_char_traits.h

constexpr_char_traits<CharT>::move(char_type* s1, const char_type* s2, std::size_t n)
     }
     return r;
 }
 
 template <class CharT>
 TEST_CONSTEXPR_CXX14 CharT*
 constexpr_char_traits<CharT>::copy(char_type* s1, const char_type* s2, std::size_t n)
 {
-    if (!TEST_IS_CONSTANT_EVALUATED) // fails in constexpr because we might be comparing unrelated pointers
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX14) // fails in constexpr because we might be comparing unrelated pointers
         assert(s2 < s1 || s2 >= s1+n);
     char_type* r = s1;
     for (; n; --n, ++s1, ++s2)
         assign(*s1, *s2);
     return r;
 }
 
 template <class CharT>

libcxx/test/support/count_new.h

private:
     DisableAllocationGuard& operator=(DisableAllocationGuard const&);
 };
 
 #if TEST_STD_VER >= 20
 
 struct ConstexprDisableAllocationGuard {
     TEST_CONSTEXPR_CXX14 explicit ConstexprDisableAllocationGuard(bool disable = true) : m_disabled(disable)
     {
-        if (!TEST_IS_CONSTANT_EVALUATED) {
+        if (!TEST_IS_CONSTANT_EVALUATED_CXX14) {
             // Don't re-disable if already disabled.
             if (globalMemCounter.disable_allocations == true) m_disabled = false;
             if (m_disabled) globalMemCounter.disableAllocations();
         } else {
             m_disabled = false;
         }
     }
 
     TEST_CONSTEXPR_CXX14 void release() {
-        if (!TEST_IS_CONSTANT_EVALUATED) {
+        if (!TEST_IS_CONSTANT_EVALUATED_CXX14) {
             if (m_disabled) globalMemCounter.enableAllocations();
             m_disabled = false;
         }
     }
 
     TEST_CONSTEXPR_CXX20 ~ConstexprDisableAllocationGuard() {
         release();
     }

libcxx/test/support/test_macros.h

 #if TEST_STD_VER >= 11
 # define TEST_THROW_SPEC(...)
 #else
 # define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 #endif
 
 #if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
 # define TEST_IS_CONSTANT_EVALUATED std::is_constant_evaluated()
-#elif TEST_HAS_BUILTIN(__builtin_is_constant_evaluated)
+#elif TEST_HAS_BUILTIN(__builtin_is_constant_evaluated) && TEST_STD_VER >= 11
 # define TEST_IS_CONSTANT_EVALUATED __builtin_is_constant_evaluated()
 #else
 # define TEST_IS_CONSTANT_EVALUATED false
 #endif
 
 #if TEST_STD_VER >= 14
 # define TEST_CONSTEXPR_CXX14 constexpr
+# define TEST_IS_CONSTANT_EVALUATED_CXX14 TEST_IS_CONSTANT_EVALUATED
 #else
 # define TEST_CONSTEXPR_CXX14
+# define TEST_IS_CONSTANT_EVALUATED_CXX14 false
 #endif
 
 #if TEST_STD_VER >= 17
 # define TEST_CONSTEXPR_CXX17 constexpr
+# define TEST_IS_CONSTANT_EVALUATED_CXX17 TEST_IS_CONSTANT_EVALUATED
 #else
 # define TEST_CONSTEXPR_CXX17
+# define TEST_IS_CONSTANT_EVALUATED_CXX17 false
 #endif
 
 #if TEST_STD_VER >= 20
 # define TEST_CONSTEXPR_CXX20 constexpr
+# define TEST_IS_CONSTANT_EVALUATED_CXX20 TEST_IS_CONSTANT_EVALUATED
 #else
 # define TEST_CONSTEXPR_CXX20
+# define TEST_IS_CONSTANT_EVALUATED_CXX20 false
 #endif
 
 #if TEST_STD_VER >= 23
 #  define TEST_CONSTEXPR_CXX23 constexpr
+# define TEST_IS_CONSTANT_EVALUATED_CXX23 TEST_IS_CONSTANT_EVALUATED
 #else
 #  define TEST_CONSTEXPR_CXX23
+# define TEST_IS_CONSTANT_EVALUATED_CXX23 false
 #endif
 
 #define TEST_ALIGNAS_TYPE(...) TEST_ALIGNAS(TEST_ALIGNOF(__VA_ARGS__))
 
 #if !TEST_HAS_FEATURE(cxx_rtti) && !defined(__cpp_rtti) \
     && !defined(__GXX_RTTI)
 #define TEST_HAS_NO_RTTI
 #endif

libcxx/test/support/unique_ptr_test_helper.h

 #include <type_traits>
 
 #include "test_macros.h"
 #include "deleter_types.h"
 
 struct A {
   static int count;
   TEST_CONSTEXPR_CXX23 A() {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       ++count;
   }
   TEST_CONSTEXPR_CXX23 A(const A&) {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       ++count;
   }
   TEST_CONSTEXPR_CXX23 virtual ~A() {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       --count;
   }
 };
 
 int A::count = 0;
 
 struct B : public A {
   static int count;
   TEST_CONSTEXPR_CXX23 B() {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       ++count;
   }
   TEST_CONSTEXPR_CXX23 B(const B& other) : A(other) {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       ++count;
   }
   TEST_CONSTEXPR_CXX23 virtual ~B() {
-    if (!TEST_IS_CONSTANT_EVALUATED)
+    if (!TEST_IS_CONSTANT_EVALUATED_CXX23)
       --count;
   }
 };
 
 int B::count = 0;
 
 template <class T>
 TEST_CONSTEXPR_CXX23 typename std::enable_if<!std::is_array<T>::value, T*>::type newValue(int num_elements) {