[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

1300

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

3230–3232

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

3239–3246

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

clang/lib/Parse/ParseExpr.cpp

241

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

1514–1517

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

clang/lib/Sema/SemaDecl.cpp

15446–15457

There are a bunch of white spaces only changes there

clang/lib/Sema/SemaDeclCXX.cpp

18248–18292

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

1300

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

3239–3246

I removed InConstantEvaluated

clang/lib/Parse/ParseStmt.cpp

1514–1517

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

18248–18292

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

1579–1580

To be consistent with other tautological warnings

8886

clang/include/clang/Sema/Sema.h

1300

Right, thanks for clarifying, i missed that

clang/lib/Parse/ParseDecl.cpp

2517

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

clang/lib/Parse/ParseStmt.cpp

1514–1517

I missed that, makes sense!

clang/lib/Sema/SemaDeclCXX.cpp

18248–18292

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

2517

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

18248–18292

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

7146

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

34

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

34

__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

34

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

34

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

34

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

34

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

- Clang's ``-Wfortify-source`` now diagnoses ``snprintf`` call that is known to
   result in string truncation.
   (`#64871: <https://github.com/llvm/llvm-project/issues/64871>`_).
   Also clang no longer emits false positive warnings about the output length of
   ``%g`` format specifier and about ``%o, %x, %X`` with ``#`` flag.
 - Clang now emits ``-Wcast-qual`` for functional-style cast expressions.
 - Clang no longer emits irrelevant notes about unsatisfied constraint expressions
   on the left-hand side of ``||`` when the right-hand side constraint is satisfied.
   (`#54678: <https://github.com/llvm/llvm-project/issues/54678>`_).
+- 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.
 - Fix crash on use of a variadic overloaded operator.

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/Parse/Parser.h

private:
   void ParseDirectNewDeclarator(Declarator &D);
   ExprResult ParseCXXNewExpression(bool UseGlobal, SourceLocation Start);
   ExprResult ParseCXXDeleteExpression(bool UseGlobal,
                                             SourceLocation Start);
 
   //===--------------------------------------------------------------------===//
   // C++ if/switch/while/for condition expression.
   struct ForRangeInfo;
-  Sema::ConditionResult ParseCXXCondition(StmtResult *InitStmt,
-                                          SourceLocation Loc,
-                                          Sema::ConditionKind CK,
-                                          bool MissingOK,
-                                          ForRangeInfo *FRI = nullptr,
-                                          bool EnterForConditionScope = false);
+  Sema::ConditionResult ParseCXXCondition(
+      StmtResult *InitStmt, SourceLocation Loc, Sema::ConditionKind CK,
+      bool MissingOK, ForRangeInfo *FRI = nullptr,
+      bool EnterForConditionScope = false, SourceLocation ConstexprLoc = {});
   DeclGroupPtrTy ParseAliasDeclarationInInitStatement(DeclaratorContext Context,
                                                       ParsedAttributes &Attrs);
 
   //===--------------------------------------------------------------------===//
   // C++ Coroutines
 
   ExprResult ParseCoyieldExpression();
 
private:
   void ParseCompoundStatementLeadingPragmas();
   void DiagnoseLabelAtEndOfCompoundStatement();
   bool ConsumeNullStmt(StmtVector &Stmts);
   StmtResult ParseCompoundStatementBody(bool isStmtExpr = false);
   bool ParseParenExprOrCondition(StmtResult *InitStmt,
                                  Sema::ConditionResult &CondResult,
                                  SourceLocation Loc, Sema::ConditionKind CK,
                                  SourceLocation &LParenLoc,
-                                 SourceLocation &RParenLoc);
+                                 SourceLocation &RParenLoc,
+                                 SourceLocation ConstexprLoc = {});
   StmtResult ParseIfStatement(SourceLocation *TrailingElseLoc);
   StmtResult ParseSwitchStatement(SourceLocation *TrailingElseLoc);
   StmtResult ParseWhileStatement(SourceLocation *TrailingElseLoc);
   StmtResult ParseDoStatement();
   StmtResult ParseForStatement(SourceLocation *TrailingElseLoc);
   StmtResult ParseGotoStatement();
   StmtResult ParseContinueStatement();
   StmtResult ParseBreakStatement();

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 {
bool isDiscardedStatementContext() const {
                   ExpressionEvaluationContext::ImmediateFunctionContext &&
               InDiscardedStatement);
     }
   };
 
   /// A stack of expression evaluation contexts.
   SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
 
+  /// Source location of the start of `constexpr` in constexpr-if
+  /// used for diagnostics
+  SourceLocation ConstexprIfLoc;
+
   // Set of failed immediate invocations to avoid double diagnosing.
   llvm::SmallPtrSet<ConstantExpr *, 4> FailedImmediateInvocations;
 
   /// Emit a warning for all pending noderef expressions that we recorded.
   void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
 
   /// Compute the mangling number context for a lambda expression or
   /// block literal. Also return the extra mangling decl if any.

clang/lib/AST/ExprConstant.cpp

if (Info.InConstantContext || Arg->HasSideEffects(Info.Ctx)) {
       // 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->getCallRange().getBegin(),
-                    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/ParseExpr.cpp

 ///
 /// \verbatim
 ///       constraint-expression: C++2a[temp.constr.decl]p1
 ///         logical-or-expression
 /// \endverbatim
 ExprResult Parser::ParseConstraintExpression() {
   EnterExpressionEvaluationContext ConstantEvaluated(
       Actions, Sema::ExpressionEvaluationContext::Unevaluated);
   ExprResult LHS(ParseCastExpression(AnyCastExpr));
   ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::LogicalOr));
   if (Res.isUsable() && !Actions.CheckConstraintExpression(Res.get())) {
     Actions.CorrectDelayedTyposInExpr(Res);
     return ExprError();
   }
   return Res;
 }
 
case tok::lesslessless: {  // p-e: p-e '<<<' argument-expression-list '>>>'
       auto RunSignatureHelp = [&]() -> QualType {
         QualType PreferredType = Actions.ProduceCallSignatureHelp(
             LHS.get(), ArgExprs, PT.getOpenLocation());
         CalledSignatureHelp = true;
         return PreferredType;
       };
       if (OpKind == tok::l_paren || !LHS.isInvalid()) {
         if (Tok.isNot(tok::r_paren)) {
+          // FIXME: arguments in consteval functions are constant expression
+          // regardless of the evaluation context of callsite. However, we
+          // cannot know whether the called function is constevasl before the
+          // declaration is resolved.
+          bool IsRuntimeEvaluated =
+              Actions.ExprEvalContexts.back().IsRuntimeEvaluated;
+          Actions.ExprEvalContexts.back().IsRuntimeEvaluated = false;
           if (ParseExpressionList(ArgExprs, [&] {
                 PreferredType.enterFunctionArgument(Tok.getLocation(),
                                                     RunSignatureHelp);
               })) {
             (void)Actions.CorrectDelayedTyposInExpr(LHS);
             // If we got an error when parsing expression list, we don't call
             // the CodeCompleteCall handler inside the parser. So call it here
             // to make sure we get overload suggestions even when we are in the
             // middle of a parameter.
             if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
               RunSignatureHelp();
             LHS = ExprError();
           } else if (LHS.isInvalid()) {
             for (auto &E : ArgExprs)
               Actions.CorrectDelayedTyposInExpr(E);
           }
+          Actions.ExprEvalContexts.back().IsRuntimeEvaluated =
+              IsRuntimeEvaluated;
         }
       }
 
       // Match the ')'.
       if (LHS.isInvalid()) {
         SkipUntil(tok::r_paren, StopAtSemi);
       } else if (Tok.isNot(tok::r_paren)) {
         bool HadDelayedTypo = false;

clang/lib/Parse/ParseExprCXX.cpp

 ///
 /// \param EnterForConditionScope If true, enter a continue/break scope at the
 /// appropriate moment for a 'for' loop.
 ///
 /// \returns The parsed condition.
 Sema::ConditionResult
 Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc,
                           Sema::ConditionKind CK, bool MissingOK,
-                          ForRangeInfo *FRI, bool EnterForConditionScope) {
+                          ForRangeInfo *FRI, bool EnterForConditionScope,
+                          SourceLocation ConstexprLoc) {
   // Helper to ensure we always enter a continue/break scope if requested.
   struct ForConditionScopeRAII {
     Scope *S;
     void enter(bool IsConditionVariable) {
       if (S) {
         S->AddFlags(Scope::BreakScope | Scope::ContinueScope);
         S->setIsConditionVarScope(IsConditionVariable);
       }
if (InitStmt && Tok.is(tok::semi)) {
         Diag(SemiLoc, diag::warn_empty_init_statement)
             << (CK == Sema::ConditionKind::Switch)
             << FixItHint::CreateRemoval(SemiLoc);
       }
       ConsumeToken();
       *InitStmt = Actions.ActOnNullStmt(SemiLoc);
       return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
     }
+    bool InitStmtIsExprStmt = false;
+    if (InitStmt) {
+      RevertingTentativeParsingAction PA(*this);
+      SkipUntil(tok::r_paren, tok::semi, StopBeforeMatch);
+      InitStmtIsExprStmt = Tok.is(tok::semi);
+    }
+
+    ExprResult Expr; // expression
+    {
+      EnterExpressionEvaluationContext Consteval(
+          Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated,
+          /*LambdaContextDecl=*/nullptr,
+          Sema::ExpressionEvaluationContextRecord::EK_Other,
+          /*ShouldEnter=*/CK == Sema::ConditionKind::ConstexprIf &&
+              !InitStmtIsExprStmt);
+      SourceLocation OuterConstexprIfLoc = Actions.ConstexprIfLoc;
+      Actions.ConstexprIfLoc = ConstexprLoc;
 
       // Parse the expression.
-    ExprResult Expr = ParseExpression(); // expression
+      Expr = ParseExpression(); // expression
+      Actions.ConstexprIfLoc = OuterConstexprIfLoc;
+    }
     if (Expr.isInvalid())
       return Sema::ConditionError();
 
     if (InitStmt && Tok.is(tok::semi)) {
       WarnOnInit();
       *InitStmt = Actions.ActOnExprStmt(Expr.get());
       ConsumeToken();
       return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc,
   Decl *DeclOut = Dcl.get();
 
   // '=' assignment-expression
   // If a '==' or '+=' is found, suggest a fixit to '='.
   bool CopyInitialization = isTokenEqualOrEqualTypo();
   if (CopyInitialization)
     ConsumeToken();
 
+  Sema::ExpressionEvaluationContext NewEEC =
+      Actions.ExprEvalContexts.back().Context;
+  bool RuntimeEvaluated = Actions.ExprEvalContexts.back().IsRuntimeEvaluated;
+  if (DS.getTypeQualifiers() == DeclSpec::TQ_const)
+    RuntimeEvaluated = false;
+
+  if (CK == Sema::ConditionKind::ConstexprIf || DS.hasConstexprSpecifier()) {
+    RuntimeEvaluated = false;
+    NewEEC = Sema::ExpressionEvaluationContext::ConstantEvaluated;
+  }
+  EnterExpressionEvaluationContext Initializer(Actions, NewEEC, DeclOut);
+  Actions.ExprEvalContexts.back().IsRuntimeEvaluated = RuntimeEvaluated;
+  SourceLocation OuterConstexprIfLoc = Actions.ConstexprIfLoc;
+  Actions.ConstexprIfLoc = ConstexprLoc;
+
   ExprResult InitExpr = ExprError();
   if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
     Diag(Tok.getLocation(),
          diag::warn_cxx98_compat_generalized_initializer_lists);
     InitExpr = ParseBraceInitializer();
   } else if (CopyInitialization) {
     PreferredType.enterVariableInit(Tok.getLocation(), DeclOut);
     InitExpr = ParseAssignmentExpression();
Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc,
   }
 
   if (!InitExpr.isInvalid())
     Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
   else
     Actions.ActOnInitializerError(DeclOut);
 
   Actions.FinalizeDeclaration(DeclOut);
+  Actions.ConstexprIfLoc = OuterConstexprIfLoc;
   return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
 }
 
 /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
 /// This should only be called when the current token is known to be part of
 /// simple-type-specifier.
 ///
 ///       simple-type-specifier:

clang/lib/Parse/ParseStmt.cpp

 /// or expression (depending on whether we're in C++ or C mode).  This function
 /// goes out of its way to recover well.  It returns true if there was a parser
 /// error (the right paren couldn't be found), which indicates that the caller
 /// should try to recover harder.  It returns false if the condition is
 /// successfully parsed.  Note that a successful parse can still have semantic
 /// errors in the condition.
 /// Additionally, it will assign the location of the outer-most '(' and ')',
 /// to LParenLoc and RParenLoc, respectively.
-bool Parser::ParseParenExprOrCondition(StmtResult *InitStmt,
-                                       Sema::ConditionResult &Cond,
-                                       SourceLocation Loc,
-                                       Sema::ConditionKind CK,
-                                       SourceLocation &LParenLoc,
-                                       SourceLocation &RParenLoc) {
+bool Parser::ParseParenExprOrCondition(
+    StmtResult *InitStmt, Sema::ConditionResult &Cond, SourceLocation Loc,
+    Sema::ConditionKind CK, SourceLocation &LParenLoc,
+    SourceLocation &RParenLoc, SourceLocation ConstexprLoc) {
   BalancedDelimiterTracker T(*this, tok::l_paren);
   T.consumeOpen();
   SourceLocation Start = Tok.getLocation();
 
   if (getLangOpts().CPlusPlus) {
-    Cond = ParseCXXCondition(InitStmt, Loc, CK, false);
+    Cond = ParseCXXCondition(InitStmt, Loc, CK, false, nullptr, false,
+                             ConstexprLoc);
   } else {
     ExprResult CondExpr = ParseExpression();
 
     // If required, convert to a boolean value.
     if (CondExpr.isInvalid())
       Cond = Sema::ConditionError();
     else
       Cond = Actions.ActOnCondition(getCurScope(), Loc, CondExpr.get(), CK,

 StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
   assert(Tok.is(tok::kw_if) && "Not an if stmt!");
   SourceLocation IfLoc = ConsumeToken();  // eat the 'if'.
 
   bool IsConstexpr = false;
   bool IsConsteval = false;
   SourceLocation NotLocation;
   SourceLocation ConstevalLoc;
+  SourceLocation ConstexprLoc;
 
   if (Tok.is(tok::kw_constexpr)) {
     Diag(Tok, getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_constexpr_if
                                         : diag::ext_constexpr_if);
     IsConstexpr = true;
-    ConsumeToken();
+    ConstexprLoc = ConsumeToken();
   } else {
     if (Tok.is(tok::exclaim)) {
       NotLocation = ConsumeToken();
     }
 
     if (Tok.is(tok::kw_consteval)) {
       Diag(Tok, getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_consteval_if
                                           : diag::ext_consteval_if);
StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
 
   // Parse the condition.
   StmtResult InitStmt;
   Sema::ConditionResult Cond;
   SourceLocation LParen;
   SourceLocation RParen;
   std::optional<bool> ConstexprCondition;
   if (!IsConsteval) {
 
     if (ParseParenExprOrCondition(&InitStmt, Cond, IfLoc,
                                   IsConstexpr ? Sema::ConditionKind::ConstexprIf
                                               : Sema::ConditionKind::Boolean,
-                                  LParen, RParen))
+                                  LParen, RParen, ConstexprLoc))
       return StmtError();
 
     if (IsConstexpr)
       ConstexprCondition = Cond.getKnownValue();
   }
 
   bool IsBracedThen = Tok.is(tok::l_brace);
 
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 (const auto *CO = dyn_cast<ConditionalOperator>(E)) {
     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
if (SourcePrecision > 0 && TargetPrecision > 0 &&
                 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);
       }
     }
   }
if (E->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects,
       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)
if (TargetRange.Width == LikelySourceRange.Width &&
     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)) &&
static void AnalyzeImplicitConversions(
   // 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))
static void AnalyzeImplicitConversions(
 
   // 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

Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D,
 
   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::ActOnPureSpecifier(Decl *D, SourceLocation ZeroLoc) {
   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,
   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,
+                                                          const CallExpr *CE) {
+  if (S.inTemplateInstantiation() || CE->getBeginLoc().isMacroID())
+    return;
+  if (const FunctionDecl *FD = CE->getDirectCallee()) {
+    bool IsBuiltin =
+        FD->getBuiltinID() == Builtin::BI__builtin_is_constant_evaluated;
+    SourceLocation ConstexprIfLoc = S.ConstexprIfLoc;
+
+    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
+            << FixItHint::CreateRemoval(ConstexprIfLoc);
+    }
+  }
+}
+
 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;
 
   // Diagnose uses of the C++20 "ADL-only template-id call" feature in earlier
   // language modes.
   if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn);
       ULE && ULE->hasExplicitTemplateArgs() &&
       ULE->decls_begin() == ULE->decls_end()) {
     Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus20
                                ? diag::warn_cxx17_compat_adl_only_template_id
                                : diag::ext_adl_only_template_id)
         << ULE->getName();
   }
 
   if (LangOpts.OpenMP)
     Call = ActOnOpenMPCall(Call, Scope, LParenLoc, ArgExprs, RParenLoc,
                            ExecConfig);
   if (LangOpts.CPlusPlus) {
-    if (const auto *CE = dyn_cast<CallExpr>(Call.get()))
+    if (const auto *CE = dyn_cast<CallExpr>(Call.get())) {
       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()) {
     // AND defined.
     if (!Method->getDescribedFunctionTemplate() && !Method->isTemplated()) {
       Diag(TRC->getBeginLoc(), diag::err_constrained_non_templated_function);
     }
   }
 
   // Enter a new evaluation context to insulate the lambda from any
   // cleanups from the enclosing full-expression.
+  bool InImmediateFunctionContext = isImmediateFunctionContext();
   PushExpressionEvaluationContext(
-      LSI->CallOperator->isConsteval()
+      LSI->CallOperator->isConsteval() || InImmediateFunctionContext
           ? ExpressionEvaluationContext::ImmediateFunctionContext
           : ExpressionEvaluationContext::PotentiallyEvaluated);
   ExprEvalContexts.back().InImmediateFunctionContext =
-      LSI->CallOperator->isConsteval();
+      LSI->CallOperator->isConsteval() || InImmediateFunctionContext;
   ExprEvalContexts.back().InImmediateEscalatingFunctionContext =
       getLangOpts().CPlusPlus20 && LSI->CallOperator->isImmediateEscalating();
 }
 
 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
                             bool IsInstantiation) {
   LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(FunctionScopes.back());
 

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

static_assert(IgnoredRejected() == 0, ""); // expected-error {{not an integral constant expression}} \
                                              // ref-error {{not an integral constant expression}} \
                                              // ref-note {{in call to 'IgnoredRejected()'}}
 #endif
 
 
 #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

void test_consteval() {
   static_assert([] {
     if not consteval {
       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}}
 }
 }
 
 namespace GH64949 {
 struct f {
   int g; // expected-note 2{{subobject declared here}}
   constexpr ~f() {}

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/fixit-tautological-meta-constant.cpp

+// RUN: %clang_cc1 -std=c++2b -Wno-unused-value -fdiagnostics-parseable-fixits -fsyntax-only %s 2>&1 | FileCheck %s
+namespace std {
+constexpr inline bool
+  is_constant_evaluated() noexcept {
+    if consteval { return true; } else { return false; }
+  }
+} // namespace std
+
+constexpr void cexpr() {
+  if constexpr (std::is_constant_evaluated()) {}
+  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:6-[[@LINE-1]]:16}:""
+  // CHECK-NOT: fix-it:"{{.*}}":{[[@LINE-2]]:6-[[@LINE-2]]:16}:""
+  constexpr int a = std::is_constant_evaluated();
+  // CHECK-NOT: fix-it:"{{.*}}":{[[@LINE-1]]:{{.*}}-[[@LINE-1]]:{{.*}}}:""
+
+  if constexpr (const int ce = __builtin_is_constant_evaluated()) {}
+  // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:6-[[@LINE-1]]:16}:""
+  // CHECK-NOT: fix-it:"{{.*}}":{[[@LINE-2]]:6-[[@LINE-2]]:16}:""
+  constexpr int b = std::is_constant_evaluated();
+  // CHECK-NOT: fix-it:"{{.*}}":{[[@LINE-1]]:{{.*}}-[[@LINE-1]]:{{.*}}}:""
+}

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 -Wno-unused-value -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;}
+  }();
+  auto lamda = []() {
+    if consteval {return 8;}
+    else {return 4;}
+  };
+  constexpr auto cexpr_lambda = []() {
+    if consteval {}
+    return __builtin_is_constant_evaluated();
+  };
+  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 {
+      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}}
+  }
+};
+
+namespace condition {
+void f() {
+  if constexpr (int a = __builtin_is_constant_evaluated(); // expected-warning {{always evaluate to false}}
+                true) {}
+  if constexpr (const int a = __builtin_is_constant_evaluated();
+                true) {}
+  if constexpr (constexpr int a = __builtin_is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+                true) {}
+  if constexpr (;const int b = __builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+  if constexpr (;constexpr int b = __builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+
+  if (int a = __builtin_is_constant_evaluated(); // expected-warning {{always evaluate to false}}
+      true) {}
+  if (const int a = __builtin_is_constant_evaluated();
+      true) {}
+  if (constexpr int a = __builtin_is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+      true) {}
+  if (;int b = __builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to false}}
+  if (;const int b = __builtin_is_constant_evaluated()) {}
+  if (;constexpr int b = __builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+
+  if constexpr (__builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+  if (__builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to false}}
+
+  if constexpr (__builtin_is_constant_evaluated(); true) {} // expected-warning {{always evaluate to false}}
+  // False
+  if constexpr (({__builtin_is_constant_evaluated();2;3;}); true) {}
+
+  if (__builtin_is_constant_evaluated(); true) {} // expected-warning {{always evaluate to false}}
+  if constexpr (;__builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+  if (;__builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to false}}
+}
+
+constexpr void g() {
+  if constexpr (int a = __builtin_is_constant_evaluated();
+                true) {}
+  if constexpr (const int a = __builtin_is_constant_evaluated();
+                true) {}
+  if constexpr (constexpr int a = __builtin_is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+                true) {}
+  if constexpr (;const int b = __builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+  if constexpr (;constexpr int b = __builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+
+  if (int a = __builtin_is_constant_evaluated();
+      true) {}
+  if (const int a = __builtin_is_constant_evaluated();
+      true) {}
+  if (constexpr int a = __builtin_is_constant_evaluated(); // expected-warning {{always evaluate to true}}
+      true) {}
+  if (;int b = __builtin_is_constant_evaluated()) {}
+  if (;const int b = __builtin_is_constant_evaluated()) {}
+  if (;constexpr int b = __builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+
+  if constexpr (__builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+  if (__builtin_is_constant_evaluated()) {}
+
+  if constexpr (__builtin_is_constant_evaluated(); true) {}
+  if constexpr (({__builtin_is_constant_evaluated();2;3;}); true) {}
+
+  if (__builtin_is_constant_evaluated(); true) {}
+  if constexpr (;__builtin_is_constant_evaluated()) {} // expected-warning {{always evaluate to true}}
+  if (;__builtin_is_constant_evaluated()) {}
+}
+}
+
+namespace Arguments {
+  int nonc(int n) { return n;}
+  constexpr int cexpr(int n) { return n;}
+  consteval int ceval(int n) { return n; }
+  void f() {
+    // FIXME: These are tauologically-false;
+    int a1 = nonc(__builtin_is_constant_evaluated());
+    const int b1 = nonc(__builtin_is_constant_evaluated());
+    int a2 = cexpr(__builtin_is_constant_evaluated());
+
+    // ok
+    const int b2 = cexpr(__builtin_is_constant_evaluated());
+    constexpr int c2 = cexpr(__builtin_is_constant_evaluated()); // expected-warning {{always evaluate to true}}
+
+    // FIXME: These are tautologically-true;
+    int a3 = ceval(__builtin_is_constant_evaluated());
+    const int b3 = ceval(__builtin_is_constant_evaluated());
+
+    // ok
+    constexpr int c3 = ceval(__builtin_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 {
+// __builtin_is_constant_evaluated() in this function always evaluates to false in pre-C++11 mode
+// because this function is not constexpr-qualified.
+// The following macro use clarifies this and avoids warnings from compilers.
+#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/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/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;
 }