[clang] Implement P2266 Simpler implicit move

[mizvekov]

Summary

This Implements P2266 Simpler implicit move.

Signed-off-by: Matheus Izvekov <[e-mail]>

[aaronpuchert]

For coroutines I have D68845. The current code is wrong, and not trivial to fix. We have never properly implemented P1825 and will probably just go with P2266 unconditionally, because that two-phase lookup is very cumbersome to imlement.

[mizvekov]

In D99005#2639501, @aaronpuchert wrote:

For coroutines I have D68845. The current code is wrong, and not trivial to fix. We have never properly implemented P1825 and will probably just go with P2266 unconditionally, because that two-phase lookup is very cumbersome to imlement.

Okay, once this is properly tested, we can spin a separate patch from this, just taking the coroutine bits unconditionally, and propose a new DR.

[mizvekov]

• Removed special flag, now is enabled on -std=c++2b
• Always enabled for coroutines
• Ran test suite
• Some relevant test files updated to also run c++2b
• Some new tests added

[• Quuxplusone]

Conspicuously missing: tests for decltype(auto) return types, tests for co_return.

Personally I'd rather see these new p2266-related tests go in a separate test file, not appended to the existing file, so as to keep each test file relatively simpler and shorter. (But I don't know that those-in-charge would agree.)

clang/test/CXX/class/class.init/class.copy.elision/p3.cpp

4

These labels seem to be getting unwieldy. I propose that you rename cxx11_14_17 to cxx17 and cxx11_14_17_20 to cxx17_20.

(There are no cases where C++11, '14, '17's behavior differ.)

So then we'll have cxx17, cxx17_20, cxx20, cxx20_2b, and cxx2b.
IMHO it might even be nice to eliminate the overlapping labels; just, when a message is expected in two out of three modes, write two expectations.

B1(B1 &&) = delete;
  // cxx20-note@-1 {{'B1' has been explicitly marked deleted here}}
  // cxx2b-note@-2 {{'B1' has been explicitly marked deleted here}}

What do you think? (This could also be severed into its own earlier commit.)

332

FWIW here I would prefer

template MoveOnly& test_3a<MoveOnly&>(MoveOnly&);
template MoveOnly&& test_3a<MoveOnly>(MoveOnly&&);

with an expected error on the second line. The parameter-ness of w seems like a red herring in your version.

342

I believe this is incorrect; throw x here shouldn't implicit-move because x's scope exceeds the nearest enclosing try-block.

clang/test/CXX/special/class.copy/p33-0x.cpp

3 ↗

(On Diff #332140)

Could you please ensure that this test is updated to be tested in all modes? My interpretation of the old line 1 is it's been locked to run only in '11 mode (not '14 or '17 or '20), which is just bizarre. There's nothing '11-specific about this file that I can see. (And again that change can be severed from the rest of this PR and landed earlier, I hope.)

41 ↗

(On Diff #332140)

I believe this is incorrect; throw x here shouldn't implicit-move (not even in C++2b) because x's scope exceeds the nearest enclosing try-block.

[aaronpuchert]

With my previous comment I meant that it's better if you leave out the co_return bits for now because it's wrong anyway. We can't use PerformMoveOrCopyInitialization. It would just generate merge conflicts.

I'll probably just update my change once the committee made up its mind. I can rebase it on top of this if it needs to be dependent on C++20 vs C++2b.

[mizvekov]

In D99005#2639977, @Quuxplusone wrote:

Conspicuously missing: tests for decltype(auto) return types, tests for co_return.

Though the first comment warns you that this is a work in progress and I just didn't get around to doing it yet ;)

Though decltype I had tested manually, co_return I have just begun testing at all.

I believe the decltype tests should go into the other file relevant to the pertinent section. One problem with leaving them here is that it would be extra noise for the tests for the older standards which don't even support the keyword at all.

Personally I'd rather see these new p2266-related tests go in a separate test file, not appended to the existing file, so as to keep each test file relatively simpler and shorter. (But I don't know that those-in-charge would agree.)

They go into files named after section / paragraph, and I haven't come across examples where they were split yet, but I haven't looked specifically for this.

In D99005#2640121, @aaronpuchert wrote:

With my previous comment I meant that it's better if you leave out the co_return bits for now because it's wrong anyway. We can't use PerformMoveOrCopyInitialization. It would just generate merge conflicts.

I am using PerformMoveOrCopyInitialization with AllowNRVO always false for co_return, which effectively makes it a PerformCopyInitialization (just replacing them instead was one of the WIP cleanups I mentioned).
I am new with this part of the code here, so maybe this is obvious, but why is it broken? Do you have any examples of test cases where this would fail?
Would this patch here cause any regressions?
Right now this is passing the test suite, and seems to be reporting the correct results for the tests you created for D68845.
Remember, here we just want to evaluate the solution proposed for P2266 by testing this at large, in order to build support for it to be accepted into the standard.
Just waiting for it to be accepted first before implementing it would be too late :)

clang/test/CXX/class/class.init/class.copy.elision/p3.cpp

4

I like the idea of shortening the labels. Duplicating the warnings if it can be avoided easily, not so much. DRY is my mantra :D

Though what you said about severing this into an earlier commit, I think something may need to be done about it anyway.
So right now the tests are all over the place about which standard they are running, and none are testing c++2b at all...
I think we might need to gather input on this. Just changing every test to run every standard might be too much, so we could need a less obvious criteria.

332

Sure, sounds good.

342

Err, you are right, my bad, this is an easy fix...

clang/test/CXX/special/class.copy/p33-0x.cpp

3 ↗

(On Diff #332140)

See my earlier comment about doing this systematically.

[mizvekov]

In D99005#2640121, @aaronpuchert wrote:

With my previous comment I meant that it's better if you leave out the co_return bits for now because it's wrong anyway. We can't use PerformMoveOrCopyInitialization. It would just generate merge conflicts.

Okay, I think I see now what you mean.
For example this:

struct task {                                                             
  struct promise_type {
    ...
    void return_value(T &&value) {}
  };                                                                      
};
task<NoCopyNoMove> local2val() {
  NoCopyNoMove value;
  co_return value;
 }

We should expect the test above to work, by binding value to the rvalue reference in task's promise, right?
Hmm, my natural course of action here would have been to figure out what is wrong and fix it.
I thought this would be good to have implemented before the committee decides on it.
@Quuxplusone thoughts? Is coroutine support optional here?

[aaronpuchert]

In D99005#2640415, @mizvekov wrote:

We should expect the test above to work, by binding value to the rvalue reference in task's promise, right?

Precisely, we don't want to do any initialization at all. (There will be an initialization for the parameters in BuildCallExpr.)

Implicit move just means that we're converting the lvalue to an xvalue.

On second thought, since @Quuxplusone's proposal makes things so simple you can just do this right yourself: instead of the initialization just do the cast, as D68845 does it. That's it.

Then let's see what we can get for C++20. If the proposal is accepted and gets DR status for co_return we might not need my change at all.

[mizvekov]

Changed:

• Implemented co_return as per Aaron's suggestion.
• Imported coroutine tests from D68845.
• Test tags shortened: cxxYY_cxxZZ means every version from YY to ZZ, instead of cxxAA_BB_CC_DD.
• Existing test on decltype(auto) updated to also run on c++2b.
• Change one of the test cases to just instantiate the relevant template, as per Arthur.

Still missing:

• Making this run on all tests:
  • A lot of tests are running in only one old standard. Changing everything here would generate too much noise.
• Some simplifications:
  • Aggregate common code for adding the implicit cast.
  • PerformMoveOrCopyInitialization can be changed to PerformCopyInitialization in the cases where AllowNRVO is false.
  • Can easily skip adding the implicit cast if expr was already a xvalue.
  • getCopyElisionCandidate needs refactoring IMHO. It is doing too much in one function, and this patch makes it worse. There are a lot of calls to it sprinkled around in the same sequence. Some problems:
    • On the current code, we want two things out of it: "Can we perform copy elision" AND "Can we perform implicit move". We end up calling it twice for that, with two parameters, instead of once returning both answers.
    • With this patch, now we need to call it even before we have the function return type available, then decide this type based on it, and then call it again to figure out if we can do copy elision. I will try to propose some way to improve that.

[mizvekov]

small cleanup.

[mizvekov]

small cleanup.

[mizvekov]

Splitting off the test changes into: https://reviews.llvm.org/D99225

[mizvekov]

Rebased on top of D99225, running on a bunch of extra tests.

[• Quuxplusone]

Data points: I've run this new Clang in -std=c++2b mode over my employer's (medium-sized, not too crazy) C++17 codebase, and also built Clang with Clang. Neither one required any source-code changes to deal with p2266. (The C++17 codebase did need about 10 identical changes to fix up ambiguous operator== overloads for C++20.)

Could we get someone to check out the Bloomberg codebase?

[mizvekov]

Cleaned up implementation, not WIP anymore, ready for review.

[mizvekov]

So it turns out there was a pre-existing bug where ObjC++ blocks
with dependent return type were not getting copy elision.

My latest refactoring accidentally fixed this in the return statement
sema action, but unfortunately the template instantiator still expects
only FunctionDecl and crashes otherwise.

I am not sure there is an easy way to fix this, as BlockDecl
doesn't even carry a type unlike FunctionDecl, so there is no easy way
to get the return type.

This might require some surgery to fix, so for now I am just
skipping it and putting a FIXME.

[mizvekov]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

1059

@rjmccall Hello! Do you have any tips for fixing this one?

[mizvekov]

small fix

[mizvekov]

some further simplifications

[rjmccall]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

1059

I've always found it annoying that we only store the block type on the BlockExpr and not the BlockDecl, so if you've got a good reason to change that, I'm not opposed.

That said, while I'm not an expert in how we do NRVO variable tracking, the code must have some ability to handle an unknown return type when just processing declarations by delaying some of the bookkeeping/analysis until the end of the function. It's possible but quite uncommon to declare a return type explicitly in a block, so that's the dominant case here. I'm actually surprised we do any of this tracking when we're just instantiating a variable.

[mizvekov]

Small update making some invariants more clear, with some simplifications.

[mizvekov]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

1059

Thanks, your observations have been extremely helpful.

So this whole NRVO tracking thing looks to be in bad shape. This tracker here fails to handle 'auto' types. I don't think this gets fixed up anywhere else.

This is also badly covered by the test suite. The test included with the merge request that introduced this tracking (CodeGenCXX/nrvo.cpp) still passes if you either delete this whole block here, or if you just do Var->setNRVOVariable(D->isNRVOVariable()).

In fact, almost the whole test suite passes with those changes, the only tests which fail are CodeGenCXX/matrix-type-builtins.cpp and CodeGenCXX/matrix-type-operators.cpp respectively.

[rjmccall]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

1059

I'm surprised that this has any impact on matrix types; pinging @fhahn in case he understands what the interaction might be.

It looks like we're assuming that the parse-time analysis of NRVO candidates is correct except for possibly needing adjustment for dependent expressions / return types. The parse-time analysis seems to work by keeping track of NRVO candidates on Scope; since we don't push meaningful Scopes during template instantiation, that won't work, so we have to trust the parse-time analysis. But the parse-time analysis can also be overly conservative, mostly because of if constexpr; that might be enough of a corner case to not merit something better, though. @rsmith is the expert here, though.

At any rate, it should be *correct* to handle non-function cases as if the return type were dependent, the same way it presumably works for functions with deduced return types.

[mizvekov]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

1059

The main thing here is that the NRVO criteria for function return type is ignored if the type is dependent.
But it is not ignored for a non-dependent auto type, "because auto is not a record type", so this evaluates as not a NRVO candidate.

It is strange that we make this distinction between dependent and non-dependent auto here.

This is actually the only case where this function is called where the FnRetType is possibly auto, so it's an understandable oversight if that is the case.

I see we don't have the type deduced here even for functions with a single return statement and no if constexpr or other indirection, where it seems it would have been possible to have just deduced it to some dependent type during parsing.

That said, my (pretty uninformed) guess here is that it should be safe to treat auto the same as dependent, and it is probably the most reasonable choice.
That we are (again my guess) just trying here to weed out some candidates to get better results in some simple greedy algorithm later.

[mizvekov]

• Rebased on top of D99696.

[mizvekov]

• test/SemaCXX/coroutine-rvo: Make MoveOnly trivial, since the temporary is not created anymore and there is no special reason to test a non-trivial type here.

[mizvekov]

rebase

[mizvekov]

rebase

[mizvekov]

rerun pipeline.

[• Quuxplusone]

IMHO we should just land this already. (It's been sitting without major update since mid-April.) It is intended to affect only -std=c++2b mode, and implements a paper (full disclosure: my paper) targeting C++2b that EWG wants implementation experience with. So I have proposed to @mizvekov that he should land this on Monday, unless someone yells "stop" before then.
If this breaks anyone compiling in C++2b mode, then (1) it can always be reverted, and (2) that would be exactly the successful gathering of field experience that we're hoping for.

[mizvekov]

Actually we can land it now. @rsmith gave me the go ahead in private. The windows pipeline passes. The latest debian build failure is some random fortran thing, so we are good.

[sberg]

(In a build prior to https://reviews.llvm.org/rGc60dd3b2626a4d9eefd9f82f9a406b0d28d3fd72 "Revert '[clang] NRVO: Improvements and handling of more cases.'") I see the following (reduced from https://git.libreoffice.org/core/+/649313625b94e6b879848fc19b607b74375100bf/o3tl/qa/compile-temporary.cxx) started to fail under -std=c++2b with this change (and continues to compile fine with -std=c++20):

$ cat test.cc
template <typename T> constexpr T& temporary(T&& x) { return x; }
template <typename T> constexpr T& temporary(T&) = delete;
void f(int*);
int g();
void h()
{
    f(&temporary(int()));
    f(&temporary(g()));
}

$ clang++ -std=c++2b -fsyntax-only test.cc
test.cc:1:62: error: non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'
template <typename T> constexpr T& temporary(T&& x) { return x; }
                                                             ^
test.cc:7:8: note: in instantiation of function template specialization 'temporary<int>' requested here
    f(&temporary(int()));
       ^
test.cc:8:8: error: no matching function for call to 'temporary'
    f(&temporary(g()));
       ^~~~~~~~~
test.cc:2:36: note: candidate function [with T = int] not viable: expects an lvalue for 1st argument
template <typename T> constexpr T& temporary(T&) = delete;
                                   ^
test.cc:1:36: note: candidate template ignored: substitution failure [with T = int]
template <typename T> constexpr T& temporary(T&& x) { return x; }
                                   ^
2 errors generated.

It is not clear to me whether that is an intended change in behavior according to http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2266r1.html "Simpler implicit move", or whether it is a bug in this implementation.

[mizvekov]

In D99005#2818606, @sberg wrote:

(In a build prior to https://reviews.llvm.org/rGc60dd3b2626a4d9eefd9f82f9a406b0d28d3fd72 "Revert '[clang] NRVO: Improvements and handling of more cases.'") I see the following (reduced from https://git.libreoffice.org/core/+/649313625b94e6b879848fc19b607b74375100bf/o3tl/qa/compile-temporary.cxx) started to fail under -std=c++2b with this change (and continues to compile fine with -std=c++20):
It is not clear to me whether that is an intended change in behavior according to http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2266r1.html "Simpler implicit move", or whether it is a bug in this implementation.

Yeah that one is intentional, under P2266 as far as implicit move is concerned, that code behaves similarly to this code under C++20 (which is diagnosed for the same reason):

template <typename T> constexpr T& temporary(T&& x) { return static_cast<T&&>(x); }

If you want this semantics with P2266, you could write:

template <typename T> constexpr T& temporary(T&& x) { return static_cast<T&>(x); }

And the above also works on C++20.

Thank you for reporting this, it's the kind of feedback we needed about real world usage of code that would break under these new rules.

[• Quuxplusone]

@sberg: Thanks for the example! @mizvekov's comments are correct, but I wanted to put some more comments here for posterity. (I'll also try to find a place for this real-world example in the next revision of p2266.)

The code in question is o3tl::temporary, documented as "Cast an rvalue to an lvalue." and implemented as template<class T> T& temporary(T&& x) { return x; }
https://docs.libreoffice.org/o3tl/html/temporary_8hxx_source.html
p2266 proposes to break this code in C++23, by making the expression x an xvalue. EWG was well aware that p2266 would break this exact kind of "laundering" function, which takes an rvalue and launders it into an lvalue without a cast. This breakage was generally (though I'm sure not universally) seen as a good thing. We weren't aware of any specific real-world examples of such "laundering" functions, though, so this is very useful info.
As Matheus says, the best way to fix the code is to add an explicit cast: return static_cast<T&>(x);.

[sberg]

For the record, the one other breakage of a LibreOffice build with this is the handful of places that needed https://git.libreoffice.org/core/+/433ab39b2175bdadb4916373cd2dc8e1aabc08a5%5E%21 "Adapt implicit OString return value construction to C++23 P2266R1": In a nutshell, LO has an OString class with (non-explicit) constructors from any kind of char pointer or array, where the "array of N const char" variant (no. 3 below) is special, as it determines the string length as N - 1 (whereas all the other variants search for the terminating NUL to determine the length). That requires another constructor overload (no. 2 below) for non-const arrays, taking a non-const lvalue reference, which now causes issues when that constructor shall implicitly be used in return statements:

$ cat test.cc
#include <cstddef>

template<typename> struct CharPtrDetector {};
template<> struct CharPtrDetector<char *>
{ using type = int; };
template<> struct CharPtrDetector<char const *>
{ using type = int; };

template<typename> struct NonConstCharArrayDetector {};
template<std::size_t N> struct NonConstCharArrayDetector<char [N]>
{ using type = int; };

template<typename> struct ConstCharArrayDetector {};
template<std::size_t N> struct ConstCharArrayDetector<char const [N]>
{ using type = int; };

struct OString {
    template<typename T>
    OString(T const &, typename CharPtrDetector<T>::type = 0); // #1
    template<typename T>
    OString(T &, typename NonConstCharArrayDetector<T>::type = 0); // #2
    template<typename T>
    OString(T &, typename ConstCharArrayDetector<T>::type = 0); // #3
};

OString good1a() {
    char * p;
    //...
    return p; // use #1
};

OString good1b() {
    char const * p;
    //...
    return p; // use #1
};

OString bad2() {
    char buf[10];
    //...
    return buf; // use #2
}

OString good3() {
    return "foo"; // use #3
}

$ clang++ -std=c++20 -fsyntax-only test.cc

$ clang++ -std=c++2b -fsyntax-only test.cc
test.cc:41:12: error: no viable conversion from returned value of type 'char [10]' to function return type 'OString'
    return buf; // use #2
           ^~~
test.cc:17:8: note: candidate constructor (the implicit copy constructor) not viable: no known conversion from 'char [10]' to 'const OString &' for 1st argument
struct OString {
       ^
test.cc:17:8: note: candidate constructor (the implicit move constructor) not viable: no known conversion from 'char [10]' to 'OString &&' for 1st argument
struct OString {
       ^
test.cc:21:5: note: candidate constructor [with T = char [10]] not viable: expects an lvalue for 1st argument
    OString(T &, typename NonConstCharArrayDetector<T>::type = 0); // #2
    ^
test.cc:19:5: note: candidate template ignored: substitution failure [with T = char [10]]: no type named 'type' in 'CharPtrDetector<char [10]>'
    OString(T const &, typename CharPtrDetector<T>::type = 0); // #1
    ^                                               ~~~~
test.cc:23:5: note: candidate template ignored: substitution failure [with T = char [10]]: no type named 'type' in 'ConstCharArrayDetector<char [10]>'
    OString(T &, typename ConstCharArrayDetector<T>::type = 0); // #3
    ^                                                ~~~~
1 error generated.

[mizvekov]

• Change block capture NRVO semantics to match P2266 in C++2b mode.
• Update cxx_status.

[mizvekov]

.

[mizvekov]

fix ctidy warning.

[sberg]

And, again for the record, with a build of LibreOffice with clang-cl (and -Xclang -std=c++2b) on Windows, at least against the C++ standard library from Visual Studio 2019 version 16.20.2, I ran into two issues in the standard library itself, when using std::getline and std::istream::operator>>:

In file included from C:/lo-clang/core/setup_native/source/win32/customactions/reg_dlls/reg_dlls.cxx:12:
C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\string(66,12): error: non-const lvalue reference to type 'basic_istream<...>' cannot bind to a temporary of type 'basic_istream<...>'
    return _Istr;
           ^~~~~
C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\string(78,12): note: in instantiation of function template specialization 'std::getline<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>' requested here
    return getline(_STD move(_Istr), _Str, _Delim);
           ^
C:/lo-clang/core/setup_native/source/win32/customactions/reg_dlls/reg_dlls.cxx(197,17): note: in instantiation of function template specialization 'std::getline<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>' requested here
    while (std::getline(ss, sToken, L'|'))
                ^
1 error generated.
make[1]: *** [C:/lo-clang/core/solenv/gbuild/LinkTarget.mk:298: C:/lo-clang/core/workdir/CxxObject/setup_native/source/win32/customactions/reg_dlls/reg_dlls.o] Error 1

c:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30037/include/string

and

[build CXX] l10ntools/source/merge.cxx
In file included from C:/lo-clang/core/l10ntools/source/merge.cxx:21:
In file included from C:/lo-clang/core/include\sal/log.hxx:20:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\sstream:11:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\istream:11:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\ostream:11:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\ios:11:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\xlocnum:16:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\streambuf:11:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\xiosbase:12:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\system_error:14:
In file included from C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\stdexcept:12:
C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\xstring(4971,12): error: non-const lvalue reference to type 'basic_istream<...>' cannot bind to a temporary of type 'basic_istream<...>'
    return _Istr;
           ^~~~~
C:/PROGRA~2/MIB055~1/2019/COMMUN~1/VC/Tools/MSVC/1429~1.300/Include\xstring(4977,29): note: in instantiation of function template specialization 'std::operator>><char, std::char_traits<char>, std::allocator<char>>' requested here
    return _STD move(_Istr) >> _Str;
                            ^
C:/lo-clang/core/l10ntools/source/merge.cxx(125,18): note: in instantiation of function template specialization 'std::operator>><char, std::char_traits<char>, std::allocator<char>>' requested here
    aInputStream >> sPoFile;
                 ^
1 error generated.
make[1]: *** [C:/lo-clang/core/solenv/gbuild/LinkTarget.mk:301: C:/lo-clang/core/workdir/CxxObject/l10ntools/source/merge.o] Error 1

In both cases, the reason is that library happens to implement the overload taking basic_istream& by forwarding to the overload taking basic_istream&& (and not the other way around, as libc++ and libstdc++ happen to do), and the fix is to replace

return _Istr;

in the overloads taking basic_istream&& _Istr with

return static_cast<basic_istream<_Elem, _Traits>&>(_Istr);

(No idea if any MSVC standard library developers are around here, who might want to be CC'ed on this.)

[mizvekov]

Thank you again @sberg.

I have talked to the MSVC STL maintainers. They would be open to a pull request for fixing this.
The repo can be found at https://github.com/microsoft/STL
Be my guest if you want to submit that fix yourself.
If not, I can probably do it in the near future.

[sberg]

In D99005#2843201, @mizvekov wrote:

I have talked to the MSVC STL maintainers. They would be open to a pull request for fixing this.
The repo can be found at https://github.com/microsoft/STL
Be my guest if you want to submit that fix yourself.
If not, I can probably do it in the near future.

Thanks a lot for the link. Filed https://github.com/microsoft/STL/pull/2025 "Adapt some return statements to P2266R1 'Simpler implicit move'" now.

[zahiraam]

This change has made this snippet fail.
https://godbolt.org/z/3ehK784hY Pass
https://godbolt.org/z/9q48WvsP7 fails.

[mizvekov]

In D99005#2844332, @zahiraam wrote:

This change has made this snippet fail.
https://godbolt.org/z/3ehK784hY Pass
https://godbolt.org/z/9q48WvsP7 fails.

Hello!
That is expected breakage from the changes proposed in P2266.
With simpler implicit move, we no longer have a fallback second overload resolution where the return expression would be an l-value and would thus bind to that non-const copy constructor.
You can work that around by introducing an explicit cast to lvalue reference, like this: https://godbolt.org/z/EhYbhYjch

But is this example a reduction from a real world code base?
The committee wants feedback and we are interested how hard you believe this change affects you.

[zahiraam]

In D99005#2844365, @mizvekov wrote:

In D99005#2844332, @zahiraam wrote:

This change has made this snippet fail.
https://godbolt.org/z/3ehK784hY Pass
https://godbolt.org/z/9q48WvsP7 fails.

Hello!
That is expected breakage from the changes proposed in P2266.
With simpler implicit move, we no longer have a fallback second overload resolution where the return expression would be an l-value and would thus bind to that non-const copy constructor.
You can work that around by introducing an explicit cast to lvalue reference, like this: https://godbolt.org/z/EhYbhYjch

But is this example a reduction from a real world code base?
The committee wants feedback and we are interested how hard you believe this change affects you.

That's a reduced test from a test suite.

[aaron.ballman]

In D99005#2844365, @mizvekov wrote:

But is this example a reduction from a real world code base?
The committee wants feedback and we are interested how hard you believe this change affects you.

This is an example that also appears to be impacted by this change:

struct C {
    C();
    C(C &c1);
};

void foo()
{
    try {
        C c1;
        throw c1;
    }
    catch (C c2) {
        throw;
    }
}

https://godbolt.org/z/dvEbv7GKo

I'm not certain if this is as expected of an issue, though. In the original example, C carried state that was set up after initialization but was relying on the fallback to the non-idiomatic copy constructor when doing the throw. WDYT?

[aaron.ballman]

In D99005#2843201, @mizvekov wrote:

Thank you again @sberg.

I have talked to the MSVC STL maintainers. They would be open to a pull request for fixing this.
The repo can be found at https://github.com/microsoft/STL
Be my guest if you want to submit that fix yourself.
If not, I can probably do it in the near future.

I'm not certain it's reasonable to wait for MSVC STL to change as that leaves every existing user of older MSVC STLs out in the cold. This is causing some significant regressions at Intel, to the extent that I wonder if this should be temporarily reverted until the MSVC STL headers can be compiled again.

[mizvekov]

In D99005#2859476, @aaron.ballman wrote:

https://godbolt.org/z/dvEbv7GKo

I'm not certain if this is as expected of an issue, though. In the original example, C carried state that was set up after initialization but was relying on the fallback to the non-idiomatic copy constructor when doing the throw. WDYT?

Yeah that is the equivalent scenario for throw, we treat c1 as a temporary there. The same workaround applies, you can static cast to non-const lvalue reference.

As far as the implementation is concerned, it is following the proposal to the letter here.
And as I understand it, although I am not the author of the proposal (which is @Quuxplusone), the committee agrees that this breakage is a good thing.

In D99005#2859652, @aaron.ballman wrote:

I'm not certain it's reasonable to wait for MSVC STL to change as that leaves every existing user of older MSVC STLs out in the cold. This is causing some significant regressions at Intel, to the extent that I wonder if this should be temporarily reverted until the MSVC STL headers can be compiled again.

That does interfere with the wishes of the committee to get implementation experience with this.
I am not saying one way or another, but would leaving this effect on by default, but providing a command line flag to turn it off, be a reasonable option on the table?

[aaron.ballman]

In D99005#2859886, @mizvekov wrote:

In D99005#2859476, @aaron.ballman wrote:

https://godbolt.org/z/dvEbv7GKo

I'm not certain if this is as expected of an issue, though. In the original example, C carried state that was set up after initialization but was relying on the fallback to the non-idiomatic copy constructor when doing the throw. WDYT?

Yeah that is the equivalent scenario for throw, we treat c1 as a temporary there. The same workaround applies, you can static cast to non-const lvalue reference.

Thanks for verifying!

As far as the implementation is concerned, it is following the proposal to the letter here.
And as I understand it, although I am not the author of the proposal (which is @Quuxplusone), the committee agrees that this breakage is a good thing.

I'm less convinced than the committee; I put a high value on existing, working, conforming code continuing to work in newer language modes. However, this is what the standard requires for that language mode, so I can live with it unless the code pattern shows up in some common system header that users can't change themselves, and I haven't run into evidence of that for this particular case yet.

In D99005#2859652, @aaron.ballman wrote:

I'm not certain it's reasonable to wait for MSVC STL to change as that leaves every existing user of older MSVC STLs out in the cold. This is causing some significant regressions at Intel, to the extent that I wonder if this should be temporarily reverted until the MSVC STL headers can be compiled again.

That does interfere with the wishes of the committee to get implementation experience with this.

I would argue it gives the committee valuable implementation experience feedback: the change breaks at least one popular system header.

I am not saying one way or another, but would leaving this effect on by default, but providing a command line flag to turn it off, be a reasonable option on the table?

I don't think it's reasonable to leave this on by default for MSVC compatibility; it's not like std::ifstream is an obscure part of the STL or there's only one version of the STL that's impacted. The suggestions I have for how to move forward are:

• Add a compatibility hack that recognizes using the STL as a system header in a limited way to disable the diagnostics and get the old behavior (we do this on occasion for libstdc++, no reason we couldn't do something similar for MSVC STL). Then old headers still work without needing a flag and new (fixed) headers never see the issue. Someday in the distant future, we can remove the compatibility hack.
• Or, add a command line flag that defaults off for -fms-compatibility and defaults on otherwise. The default can be switched based on the compatibility version being used (perhaps) once the STL has been fixed.

I'd prefer to keep existing code working without requiring users to enable a flag, if at all possible (esp because I don't expect the flag to be needed forever). That said, I still think it makes sense to temporarily revert this while doing that work.

[mizvekov]

In D99005#2860021, @aaron.ballman wrote:

I would argue it gives the committee valuable implementation experience feedback: the change breaks at least one popular system header.

But we already knew that :-)
Reverting the change globally would stop us from finding further affected entities.
But it is a given that because of this STL bug, this is affecting our ability to get that feedback on user code in that ecosystem as well.

I don't think it's reasonable to leave this on by default for MSVC compatibility; it's not like std::ifstream is an obscure part of the STL or there's only one version of the STL that's impacted. The suggestions I have for how to move forward are:

• Add a compatibility hack that recognizes using the STL as a system header in a limited way to disable the diagnostics and get the old behavior (we do this on occasion for libstdc++, no reason we couldn't do something similar for MSVC STL). Then old headers still work without needing a flag and new (fixed) headers never see the issue. Someday in the distant future, we can remove the compatibility hack.
• Or, add a command line flag that defaults off for -fms-compatibility and defaults on otherwise. The default can be switched based on the compatibility version being used (perhaps) once the STL has been fixed.

I find interesting the idea of combining these two options. We can suppress the effect when compiling with fms-compatibility but only on the STL headers themselves.

I'd prefer to keep existing code working without requiring users to enable a flag, if at all possible (esp because I don't expect the flag to be needed forever). That said, I still think it makes sense to temporarily revert this while doing that work.

I'd like to give some time for other stakeholders to give their opinion if this is not too urgent, specially @Quuxplusone and @rsmith.
But thinking of another option, almost as easy as a global revert for this, we could suppress the effect under -fms-compatibility for now, and then implement a more targetted fix where we only suppress this when parsing the STL system headers themselves under fms-compatibility.

[• Quuxplusone]

I'd like to give some time for other stakeholders to give their opinion if this is not too urgent, specially @Quuxplusone and @rsmith.

I have no strong/well-informed opinions here. I have an idea to offer, if there is precedent for it. My idea is, keep it as an error if the rvalue resolution finds nothing, but (1) fall back to an lvalue resolution for error-recovery purposes, and (2) suppress the error in system headers. Then, the usage in MSVC STL will keep working but only because it's in a system header. I seem to recall that there is precedent for diagnostics that are "non-downgradable error in user code, yet still suppressed in system headers." If I'm imagining things, then please do not invent such a facility purely for this feature.

My second choice is to do whatever minimalistic hack suffices to satisfy the customer (Aaron etc. in this case), but only with the understanding that we plan to eliminate that hack as soon as MSVC STL gets updated. My third choice is to revert the whole thing and then land a new version of it that always falls back to lvalue resolution, but with an on-by-default warning (not error) (so this would probably affect a ton of your test cases); then the user can downgrade that warning as a workaround.

[mizvekov]

In D99005#2860598, @Quuxplusone wrote:

I have no strong/well-informed opinions here. I have an idea to offer, if there is precedent for it. My idea is, keep it as an error if the rvalue resolution finds nothing, but (1) fall back to an lvalue resolution for error-recovery purposes, and (2) suppress the error in system headers. Then, the usage in MSVC STL will keep working but only because it's in a system header. I seem to recall that there is precedent for diagnostics that are "non-downgradable error in user code, yet still suppressed in system headers." If I'm imagining things, then please do not invent such a facility purely for this feature.

That would still leave the effect of changing the deduced type of a decltype(auto) returning function. But I am on the same boat here in that I am not sure if you are imagining things as well :)

My second choice is to do whatever minimalistic hack suffices to satisfy the customer (Aaron etc. in this case), but only with the understanding that we plan to eliminate that hack as soon as MSVC STL gets updated. My third choice is to revert the whole thing and then land a new version of it that always falls back to lvalue resolution, but with an on-by-default warning (not error) (so this would probably affect a ton of your test cases); then the user can downgrade that warning as a workaround.

Again, the change in flow where we make the expression an xvalue early and definitively before return type deduction occurs makes things more complicated.

My vote is the second choice, as I think making a workaround where we temporarily do the C++20 thing only in some contexts is far simpler, specially if we don't have to update a ton of test cases to cover it :)

[mizvekov]

@aaron.ballman I created a DR for the option of temporarily disabling the effects of this change under "-fms-compatibility".
https://reviews.llvm.org/D105518

[aaron.ballman]

In D99005#2860494, @mizvekov wrote:

I'd prefer to keep existing code working without requiring users to enable a flag, if at all possible (esp because I don't expect the flag to be needed forever). That said, I still think it makes sense to temporarily revert this while doing that work.

I'd like to give some time for other stakeholders to give their opinion if this is not too urgent, specially @Quuxplusone and @rsmith.

This makes clang-cl basically unusable for a significant portion of people (enough so that I'm asking for a temporary revert) and I don't think we should continue to leave trunk in a broken state while deciding what to do. Our usual community approach is to revert out changes that cause significant breakage because we always want people (such as downstreams) to be able to track against trunk. That said, based on below, hold off on reversion as I may have misunderstood the fix patch (see below) and that may be the quicker and less disruptive approach.

But thinking of another option, almost as easy as a global revert for this, we could suppress the effect under -fms-compatibility for now, and then implement a more targetted fix where we only suppress this when parsing the STL system headers themselves under fms-compatibility.

Ah! I missed that context in the other patch, thank you for this! I'll go comment on the other review so we keep the discussion in one place, but that makes me more comfortable with the approach from that review.

clang/include/clang/Sema/Sema.h

void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
                                 ArrayRef<CapturedParamNameType> Params,
                                 unsigned OpenMPCaptureLevel = 0);
   StmtResult ActOnCapturedRegionEnd(Stmt *S);
   void ActOnCapturedRegionError();
   RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,
                                            SourceLocation Loc,
                                            unsigned NumParams);
 
-  enum CopyElisionSemanticsKind {
-    CES_Strict = 0,
-    CES_AllowParameters = 1,
-    CES_AllowDifferentTypes = 2,
-    CES_AllowExceptionVariables = 4,
-    CES_AllowRValueReferenceType = 8,
-    CES_ImplicitlyMovableCXX11CXX14CXX17 =
-        (CES_AllowParameters | CES_AllowDifferentTypes),
-    CES_ImplicitlyMovableCXX20 =
-        (CES_AllowParameters | CES_AllowDifferentTypes |
-         CES_AllowExceptionVariables | CES_AllowRValueReferenceType),
-  };
-
-  VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E,
-                                   CopyElisionSemanticsKind CESK);
-  bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,
-                              CopyElisionSemanticsKind CESK);
+  struct NRVOResult {
+    const VarDecl *Candidate;
+    bool isCopyElidable;
+  };
+  enum class NRVOMode { Auto, CXX20, CXX2b };
+  NRVOResult getNRVOCandidate(Expr *&E, NRVOMode Mode = NRVOMode::Auto);
+  NRVOResult getNRVOResult(const VarDecl *VD, bool ForceCXX20 = false);
+  void getNRVOResultFnRetType(NRVOResult &Res, QualType ReturnType);
 
   StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
                              Scope *CurScope);
   StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
-  StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
+  StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
+                                     NRVOResult &NRVORes);
 
   StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                              bool IsVolatile, unsigned NumOutputs,
                              unsigned NumInputs, IdentifierInfo **Names,
                              MultiExprArg Constraints, MultiExprArg Exprs,
                              Expr *AsmString, MultiExprArg Clobbers,
                              unsigned NumLabels,
                              SourceLocation RParenLoc);

clang/lib/Sema/Sema.cpp

 // resolve its destructor's exception specification.
 static void checkEscapingByref(VarDecl *VD, Sema &S) {
   QualType T = VD->getType();
   EnterExpressionEvaluationContext scope(
       S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
   SourceLocation Loc = VD->getLocation();
   Expr *VarRef =
       new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
-  ExprResult Result = S.PerformMoveOrCopyInitialization(
-      InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
-      VarRef, /*AllowNRVO=*/true);
+  ExprResult Result = S.PerformCopyInitialization(
+      InitializedEntity::InitializeBlock(Loc, T, false), SourceLocation(),
+      VarRef);
+
   if (!Result.isInvalid()) {
     Result = S.MaybeCreateExprWithCleanups(Result);
     Expr *Init = Result.getAs<Expr>();
     S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
   }
 
   // The destructor's exception specification is needed when IRGen generates
   // block copy/destroy functions. Resolve it here.

clang/lib/Sema/SemaCoroutine.cpp

StmtResult Sema::BuildCoreturnStmt(SourceLocation Loc, Expr *E,
 
   if (E && E->getType()->isPlaceholderType() &&
       !E->getType()->isSpecificPlaceholderType(BuiltinType::Overload)) {
     ExprResult R = CheckPlaceholderExpr(E);
     if (R.isInvalid()) return StmtError();
     E = R.get();
   }
 
-  // Move the return value if we can
-  if (E) {
-    const VarDecl *NRVOCandidate = this->getCopyElisionCandidate(
-        E->getType(), E, CES_ImplicitlyMovableCXX20);
-    if (NRVOCandidate) {
-      InitializedEntity Entity =
-          InitializedEntity::InitializeResult(Loc, E->getType(), NRVOCandidate);
-      ExprResult MoveResult = this->PerformMoveOrCopyInitialization(
-          Entity, NRVOCandidate, E->getType(), E);
-      if (MoveResult.get())
-        E = MoveResult.get();
-    }
-  }
-
-  // FIXME: If the operand is a reference to a variable that's about to go out
-  // of scope, we should treat the operand as an xvalue for this overload
-  // resolution.
   VarDecl *Promise = FSI->CoroutinePromise;
   ExprResult PC;
   if (E && (isa<InitListExpr>(E) || !E->getType()->isVoidType())) {
+    getNRVOCandidate(E, NRVOMode::CXX2b);
     PC = buildPromiseCall(*this, Promise, Loc, "return_value", E);
   } else {
     E = MakeFullDiscardedValueExpr(E).get();
     PC = buildPromiseCall(*this, Promise, Loc, "return_void", None);
   }
   if (PC.isInvalid())
     return StmtError();
 
if (FnRetType->isVoidType()) {
     this->ResultDecl = Res.get();
     return true;
   }
 
   if (GroType->isVoidType()) {
     // Trigger a nice error message.
     InitializedEntity Entity =
         InitializedEntity::InitializeResult(Loc, FnRetType, false);
-    S.PerformMoveOrCopyInitialization(Entity, nullptr, FnRetType, ReturnValue);
+    S.PerformCopyInitialization(Entity, SourceLocation(), ReturnValue);
     noteMemberDeclaredHere(S, ReturnValue, Fn);
     return false;
   }
 
   auto *GroDecl = VarDecl::Create(
       S.Context, &FD, FD.getLocation(), FD.getLocation(),
       &S.PP.getIdentifierTable().get("__coro_gro"), GroType,
       S.Context.getTrivialTypeSourceInfo(GroType, Loc), SC_None);
   GroDecl->setImplicit();
 
   S.CheckVariableDeclarationType(GroDecl);
   if (GroDecl->isInvalidDecl())
     return false;
 
   InitializedEntity Entity = InitializedEntity::InitializeVariable(GroDecl);
-  ExprResult Res = S.PerformMoveOrCopyInitialization(Entity, nullptr, GroType,
-                                                     this->ReturnValue);
+  ExprResult Res =
+      S.PerformCopyInitialization(Entity, SourceLocation(), ReturnValue);
   if (Res.isInvalid())
     return false;
 
   Res = S.ActOnFinishFullExpr(Res.get(), /*DiscardedValue*/ false);
   if (Res.isInvalid())
     return false;
 
   S.AddInitializerToDecl(GroDecl, Res.get(),

clang/lib/Sema/SemaExprCXX.cpp

ExprResult Sema::BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
   if (getLangOpts().CUDA)
     CUDADiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)
         << "throw" << CurrentCUDATarget();
 
   if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
     Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) << "throw";
 
   if (Ex && !Ex->isTypeDependent()) {
+    NRVOResult NRVORes =
+        IsThrownVarInScope ? getNRVOCandidate(Ex) : NRVOResult();
+
     QualType ExceptionObjectTy = Context.getExceptionObjectType(Ex->getType());
     if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
       return ExprError();
 
     // Initialize the exception result.  This implicitly weeds out
     // abstract types or types with inaccessible copy constructors.
 
     // C++0x [class.copymove]p31:
     //   When certain criteria are met, an implementation is allowed to omit the
     //   copy/move construction of a class object [...]
     //
     //     - in a throw-expression, when the operand is the name of a
     //       non-volatile automatic object (other than a function or
     //       catch-clause
     //       parameter) whose scope does not extend beyond the end of the
     //       innermost enclosing try-block (if there is one), the copy/move
     //       operation from the operand to the exception object (15.1) can be
     //       omitted by constructing the automatic object directly into the
     //       exception object
-    const VarDecl *NRVOVariable = nullptr;
-    if (IsThrownVarInScope)
-      NRVOVariable = getCopyElisionCandidate(QualType(), Ex, CES_Strict);
-
-    InitializedEntity Entity = InitializedEntity::InitializeException(
-        OpLoc, ExceptionObjectTy,
-        /*NRVO=*/NRVOVariable != nullptr);
+
+    InitializedEntity Entity =
+        InitializedEntity::InitializeException(OpLoc, ExceptionObjectTy,
+                                               /*NRVO=*/NRVORes.isCopyElidable);
     ExprResult Res = PerformMoveOrCopyInitialization(
-        Entity, NRVOVariable, QualType(), Ex, IsThrownVarInScope);
+        Entity, NRVORes.Candidate, QualType(), Ex, IsThrownVarInScope);
     if (Res.isInvalid())
       return ExprError();
     Ex = Res.get();
   }
 
   // PPC MMA non-pointer types are not allowed as throw expr types.
   if (Ex && Context.getTargetInfo().getTriple().isPPC64())
     CheckPPCMMAType(Ex->getType(), Ex->getBeginLoc());

clang/lib/Sema/SemaStmt.cpp

Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
   if (S->isOpenMPLoopScope())
     return StmtError(Diag(BreakLoc, diag::err_omp_loop_cannot_use_stmt)
                      << "break");
   CheckJumpOutOfSEHFinally(*this, BreakLoc, *S);
 
   return new (Context) BreakStmt(BreakLoc);
 }
 
-/// Determine whether the given expression is a candidate for
-/// copy elision in either a return statement or a throw expression.
+/// Determine whether the given NRVO candidate variable is move-eligible or
+/// copy-elision eligible, without considering function return type.
 ///
-/// \param ReturnType If we're determining the copy elision candidate for
-/// a return statement, this is the return type of the function. If we're
-/// determining the copy elision candidate for a throw expression, this will
-/// be a NULL type.
+/// \param VD The NRVO candidate variable.
 ///
-/// \param E The expression being returned from the function or block, or
-/// being thrown.
+/// \param ForceCXX20 If true, perform the check considering C++20 rules,
+/// as opposed to considering the rules for current language mode.
 ///
-/// \param CESK Whether we allow function parameters or
-/// id-expressions that could be moved out of the function to be considered NRVO
-/// candidates. C++ prohibits these for NRVO itself, but we re-use this logic to
-/// determine whether we should try to move as part of a return or throw (which
-/// does allow function parameters).
-///
-/// \returns The NRVO candidate variable, if the return statement may use the
-/// NRVO, or NULL if there is no such candidate.
-VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType, Expr *E,
-                                       CopyElisionSemanticsKind CESK) {
-  // - in a return statement in a function [where] ...
-  // ... the expression is the name of a non-volatile automatic object ...
-  DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
-  if (!DR || DR->refersToEnclosingVariableOrCapture())
-    return nullptr;
-  VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
+/// \returns A NRVOResult struct, where Candidate, if non-null, is the same
+/// as param VD and is at least move-eligible, without considering function
+/// return type, if applicable.
+Sema::NRVOResult Sema::getNRVOResult(const VarDecl *VD, bool ForceCXX20) {
   if (!VD)
-    return nullptr;
+    return NRVOResult();
 
-  if (isCopyElisionCandidate(ReturnType, VD, CESK))
-    return VD;
-  return nullptr;
+  bool hasCXX11 = getLangOpts().CPlusPlus11 || ForceCXX20,
+       hasCXX20 = getLangOpts().CPlusPlus20 || ForceCXX20;
+  NRVOResult Res{VD, true};
+  if (VD->getKind() != Decl::Var) {
+    // (other than a function ... parameter)
+    if (!hasCXX11 || VD->getKind() != Decl::ParmVar)
+      return NRVOResult();
+    Res.isCopyElidable = false;
+  }
+  // (other than ... a catch-clause parameter)
+  if (VD->isExceptionVariable()) {
+    if (!hasCXX20)
+      return NRVOResult();
+    Res.isCopyElidable = false;
   }
 
-bool Sema::isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,
-                                  CopyElisionSemanticsKind CESK) {
-  QualType VDType = VD->getType();
-  // - in a return statement in a function with ...
-  // ... a class return type ...
-  if (!ReturnType.isNull() && !ReturnType->isDependentType()) {
-    if (!ReturnType->isRecordType())
-      return false;
-    // ... the same cv-unqualified type as the function return type ...
-    // When considering moving this expression out, allow dissimilar types.
-    if (!(CESK & CES_AllowDifferentTypes) && !VDType->isDependentType() &&
-        !Context.hasSameUnqualifiedType(ReturnType, VDType))
-      return false;
-  }
-
-  // ...object (other than a function or catch-clause parameter)...
-  if (VD->getKind() != Decl::Var &&
-      !((CESK & CES_AllowParameters) && VD->getKind() == Decl::ParmVar))
-    return false;
-  if (!(CESK & CES_AllowExceptionVariables) && VD->isExceptionVariable())
-    return false;
-
   // ...automatic...
-  if (!VD->hasLocalStorage()) return false;
+  if (!VD->hasLocalStorage())
+    return NRVOResult();
 
   // Return false if VD is a __block variable. We don't want to implicitly move
   // out of a __block variable during a return because we cannot assume the
   // variable will no longer be used.
   if (VD->hasAttr<BlocksAttr>())
-    return false;
+    return NRVOResult();
 
+  QualType VDType = VD->getType();
   if (VDType->isObjectType()) {
     // C++17 [class.copy.elision]p3:
     // ...non-volatile automatic object...
     if (VDType.isVolatileQualified())
-      return false;
+      return NRVOResult();
   } else if (VDType->isRValueReferenceType()) {
     // C++20 [class.copy.elision]p3:
-    // ...either a non-volatile object or an rvalue reference to a non-volatile object type...
-    if (!(CESK & CES_AllowRValueReferenceType))
-      return false;
+    // ...either a non-volatile object or an rvalue reference to a non-volatile
+    // object type...
+    Res.isCopyElidable = false;
+    if (!hasCXX20)
+      return NRVOResult();
     QualType VDReferencedType = VDType.getNonReferenceType();
-    if (VDReferencedType.isVolatileQualified() || !VDReferencedType->isObjectType())
-      return false;
+    if (VDReferencedType.isVolatileQualified() ||
+        !VDReferencedType->isObjectType())
+      return NRVOResult();
   } else {
-    return false;
+    return NRVOResult();
   }
-
-  if (CESK & CES_AllowDifferentTypes)
-    return true;
-
+  if (!VDType->isDependentType() && VD->hasAttr<AlignedAttr>() &&
+      Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VDType)) {
     // Variables with higher required alignment than their type's ABI
     // alignment cannot use NRVO.
-  if (!VDType->isDependentType() && VD->hasAttr<AlignedAttr>() &&
-      Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VDType))
-    return false;
+    if (!hasCXX11)
+      return NRVOResult();
+    Res.isCopyElidable = false;
+  }
 
-  return true;
+  return Res;
+}
+
+/// Determine whether the given expression might be move-eligible or
+/// copy-elidable in either a (co_)return statement or throw expression.
+///
+/// \param E The expression being returned from the function or block,
+/// being thrown, or being co_returned from a coroutine.
+///
+/// \param Mode The language standard mode to use,
+/// or Auto (default) for the current mode.
+///
+/// \returns A NRVOResult struct, where Candidate, if non-null, means
+/// the expression is at least move eligible, without considering function
+/// return type, if applicable.
+Sema::NRVOResult Sema::getNRVOCandidate(Expr *&E, NRVOMode Mode) {
+  if (!E)
+    return NRVOResult();
+  // - in a return statement in a function [where] ...
+  // ... the expression is the name of a non-volatile automatic object ...
+  DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
+  if (!DR || DR->refersToEnclosingVariableOrCapture())
+    return NRVOResult();
+  VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
+  NRVOResult Res = getNRVOResult(VD, Mode != NRVOMode::Auto);
+  if (Res.Candidate && E->getValueKind() != VK_XValue &&
+      (Mode == NRVOMode::CXX2b || getLangOpts().CPlusPlus2b)) {
+    E = ImplicitCastExpr::Create(Context, VD->getType().getNonReferenceType(),
+                                 CK_NoOp, E, nullptr, VK_XValue,
+                                 FPOptionsOverride());
+  }
+  return Res;
+}
+
+/// Updates given NRVOResult's move-eligible and
+/// copy-elidable statuses, considering the function return type criteria
+/// as applicable to return statements.
+///
+/// \param Res The NRVOResult object to update.
+///
+/// \param ReturnType This is the return type of the function.
+void Sema::getNRVOResultFnRetType(NRVOResult &Res, QualType ReturnType) {
+  if (!Res.Candidate || ReturnType->isDependentType())
+    return;
+  // - in a return statement in a function with ...
+  // ... a class return type ...
+  if (!ReturnType->isRecordType()) {
+    Res = NRVOResult();
+    return;
+  }
+  QualType VDType = Res.Candidate->getType();
+  // ... the same cv-unqualified type as the function return type ...
+  // When considering moving this expression out, allow dissimilar types.
+  if (!VDType->isDependentType() &&
+      !Context.hasSameUnqualifiedType(ReturnType, VDType)) {
+    if (!getLangOpts().CPlusPlus11) {
+      Res = NRVOResult();
+      return;
+    }
+    Res.isCopyElidable = false;
+  }
 }
 
 /// Try to perform the initialization of a potentially-movable value,
 /// which is the operand to a return or throw statement.
 ///
 /// This routine implements C++20 [class.copy.elision]p3, which attempts to
 /// treat returned lvalues as rvalues in certain cases (to prefer move
 /// construction), then falls back to treating them as lvalues if that failed.

 /// is the result of return value.
 ///
 /// This routine implements C++20 [class.copy.elision]p3, which attempts to
 /// treat returned lvalues as rvalues in certain cases (to prefer move
 /// construction), then falls back to treating them as lvalues if that failed.
 ExprResult Sema::PerformMoveOrCopyInitialization(
     const InitializedEntity &Entity, const VarDecl *NRVOCandidate,
     QualType ResultType, Expr *Value, bool AllowNRVO) {
-  ExprResult Res = ExprError();
-  bool NeedSecondOverloadResolution = true;
-
-  if (AllowNRVO) {
-    CopyElisionSemanticsKind CESK = CES_Strict;
-    if (getLangOpts().CPlusPlus20) {
-      CESK = CES_ImplicitlyMovableCXX20;
-    } else if (getLangOpts().CPlusPlus11) {
-      CESK = CES_ImplicitlyMovableCXX11CXX14CXX17;
-    }
-
-    if (!NRVOCandidate) {
-      NRVOCandidate = getCopyElisionCandidate(ResultType, Value, CESK);
-    }
 
+  if (AllowNRVO && !getLangOpts().CPlusPlus2b) {
     if (NRVOCandidate) {
-      NeedSecondOverloadResolution =
-          TryMoveInitialization(*this, Entity, NRVOCandidate, ResultType, Value,
-                                !getLangOpts().CPlusPlus20, false, Res);
+      ExprResult Res;
+      if (!TryMoveInitialization(*this, Entity, NRVOCandidate, ResultType,
+                                 Value, !getLangOpts().CPlusPlus20, false, Res))
+        return Res;
     }
 
-    if (!getLangOpts().CPlusPlus20 && NeedSecondOverloadResolution &&
-        !getDiagnostics().isIgnored(diag::warn_return_std_move,
+    if (!getDiagnostics().isIgnored(diag::warn_return_std_move,
                                     Value->getExprLoc())) {
-      const VarDecl *FakeNRVOCandidate = getCopyElisionCandidate(
-          QualType(), Value, CES_ImplicitlyMovableCXX20);
-      if (FakeNRVOCandidate) {
-        QualType QT = FakeNRVOCandidate->getType();
+      NRVOResult FakeNRVORes = getNRVOCandidate(Value, NRVOMode::CXX20);
+      if (FakeNRVORes.Candidate) {
+        QualType QT = FakeNRVORes.Candidate->getType();
         if (QT->isLValueReferenceType()) {
           // Adding 'std::move' around an lvalue reference variable's name is
           // dangerous. Don't suggest it.
         } else if (QT.getNonReferenceType()
                        .getUnqualifiedType()
                        .isTriviallyCopyableType(Context)) {
           // Adding 'std::move' around a trivially copyable variable is probably
           // pointless. Don't suggest it.
         } else {
           ExprResult FakeRes = ExprError();
           Expr *FakeValue = Value;
-          TryMoveInitialization(*this, Entity, FakeNRVOCandidate, ResultType,
-                                FakeValue, false, true, FakeRes);
+          TryMoveInitialization(*this, Entity, FakeNRVORes.Candidate,
+                                ResultType, FakeValue, false, true, FakeRes);
           if (!FakeRes.isInvalid()) {
             bool IsThrow =
                 (Entity.getKind() == InitializedEntity::EK_Exception);
             SmallString<32> Str;
             Str += "std::move(";
-            Str += FakeNRVOCandidate->getDeclName().getAsString();
+            Str += FakeNRVORes.Candidate->getDeclName().getAsString();
             Str += ")";
             Diag(Value->getExprLoc(), diag::warn_return_std_move)
                 << Value->getSourceRange()
-                << FakeNRVOCandidate->getDeclName() << IsThrow;
+                << FakeNRVORes.Candidate->getDeclName() << IsThrow;
             Diag(Value->getExprLoc(), diag::note_add_std_move)
                 << FixItHint::CreateReplacement(Value->getSourceRange(), Str);
           }
         }
       }
     }
   }
 
   // Either we didn't meet the criteria for treating an lvalue as an rvalue,
   // above, or overload resolution failed. Either way, we need to try
   // (again) now with the return value expression as written.
-  if (NeedSecondOverloadResolution)
-    Res = PerformCopyInitialization(Entity, SourceLocation(), Value);
-
-  return Res;
+  return PerformCopyInitialization(Entity, SourceLocation(), Value);
 }
 
 /// Determine whether the declared return type of the specified function
 /// contains 'auto'.
 static bool hasDeducedReturnType(FunctionDecl *FD) {
   const FunctionProtoType *FPT =
       FD->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();
   return FPT->getReturnType()->isUndeducedType();
 }
 
 /// ActOnCapScopeReturnStmt - Utility routine to type-check return statements
 /// for capturing scopes.
 ///
-StmtResult
-Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
+StmtResult Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc,
+                                         Expr *RetValExp, NRVOResult &NRVORes) {
   // If this is the first return we've seen, infer the return type.
   // [expr.prim.lambda]p4 in C++11; block literals follow the same rules.
   CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction());
   QualType FnRetType = CurCap->ReturnType;
   LambdaScopeInfo *CurLambda = dyn_cast<LambdaScopeInfo>(CurCap);
   bool HasDeducedReturnType =
       CurLambda && hasDeducedReturnType(CurLambda->CallOperator);
 
if (HasDeducedReturnType) {
     }
 
     // Although we'll properly infer the type of the block once it's completed,
     // make sure we provide a return type now for better error recovery.
     if (CurCap->ReturnType.isNull())
       CurCap->ReturnType = FnRetType;
   }
   assert(!FnRetType.isNull());
+  getNRVOResultFnRetType(NRVORes, FnRetType);
 
   if (auto *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {
     if (CurBlock->FunctionType->castAs<FunctionType>()->getNoReturnAttr()) {
       Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr);
       return StmtError();
     }
   } else if (auto *CurRegion = dyn_cast<CapturedRegionScopeInfo>(CurCap)) {
     Diag(ReturnLoc, diag::err_return_in_captured_stmt) << CurRegion->getRegionName();
     return StmtError();
   } else {
     assert(CurLambda && "unknown kind of captured scope");
     if (CurLambda->CallOperator->getType()
             ->castAs<FunctionType>()
             ->getNoReturnAttr()) {
       Diag(ReturnLoc, diag::err_noreturn_lambda_has_return_expr);
       return StmtError();
     }
   }
 
   // Otherwise, verify that this result type matches the previous one.  We are
   // pickier with blocks than for normal functions because we don't have GCC
   // compatibility to worry about here.
-  const VarDecl *NRVOCandidate = nullptr;
   if (FnRetType->isDependentType()) {
     // Delay processing for now.  TODO: there are lots of dependent
     // types we can conclusively prove aren't void.
   } else if (FnRetType->isVoidType()) {
     if (RetValExp && !isa<InitListExpr>(RetValExp) &&
         !(getLangOpts().CPlusPlus &&
           (RetValExp->isTypeDependent() ||
            RetValExp->getType()->isVoidType()))) {
if (FnRetType->isDependentType()) {
     // we have a non-void block with an expression, continue checking
 
     // C99 6.8.6.4p3(136): The return statement is not an assignment. The
     // overlap restriction of subclause 6.5.16.1 does not apply to the case of
     // function return.
 
     // In C++ the return statement is handled via a copy initialization.
     // the C version of which boils down to CheckSingleAssignmentConstraints.
-    NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, CES_Strict);
-    InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
-                                                                   FnRetType,
-                                                      NRVOCandidate != nullptr);
-    ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
+    InitializedEntity Entity = InitializedEntity::InitializeResult(
+        ReturnLoc, FnRetType, NRVORes.isCopyElidable);
+    ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVORes.Candidate,
                                                      FnRetType, RetValExp);
     if (Res.isInvalid()) {
       // FIXME: Cleanup temporaries here, anyway?
       return StmtError();
     }
     RetValExp = Res.get();
     CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc);
-  } else {
-    NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, CES_Strict);
   }
 
   if (RetValExp) {
     ExprResult ER =
         ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
     if (ER.isInvalid())
       return StmtError();
     RetValExp = ER.get();
   }
   auto *Result =
-      ReturnStmt::Create(Context, ReturnLoc, RetValExp, NRVOCandidate);
+      ReturnStmt::Create(Context, ReturnLoc, RetValExp,
+                         NRVORes.isCopyElidable ? NRVORes.Candidate : nullptr);
 
   // If we need to check for the named return value optimization,
   // or if we need to infer the return type,
   // save the return statement in our scope for later processing.
-  if (CurCap->HasImplicitReturnType || NRVOCandidate)
+  if (CurCap->HasImplicitReturnType || NRVORes.isCopyElidable)
     FunctionScopes.back()->Returns.push_back(Result);
 
   if (FunctionScopes.back()->FirstReturnLoc.isInvalid())
     FunctionScopes.back()->FirstReturnLoc = ReturnLoc;
 
   return Result;
 }
 
Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
   return R;
 }
 
 StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
   // Check for unexpanded parameter packs.
   if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
     return StmtError();
 
+  NRVOResult NRVORes = getNRVOCandidate(RetValExp);
+
   if (isa<CapturingScopeInfo>(getCurFunction()))
-    return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp);
+    return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp, NRVORes);
 
   QualType FnRetType;
   QualType RelatedRetType;
   const AttrVec *Attrs = nullptr;
   bool isObjCMethod = false;
 
   if (const FunctionDecl *FD = getCurFunctionDecl()) {
     FnRetType = FD->getReturnType();
if (AutoType *AT = FnRetType->getContainedAutoType()) {
       if (DeduceFunctionTypeFromReturnExpr(FD, ReturnLoc, RetValExp, AT)) {
         FD->setInvalidDecl();
         return StmtError();
       } else {
         FnRetType = FD->getReturnType();
       }
     }
   }
+  getNRVOResultFnRetType(NRVORes, FnRetType);
 
   bool HasDependentReturnType = FnRetType->isDependentType();
 
   ReturnStmt *Result = nullptr;
   if (FnRetType->isVoidType()) {
     if (RetValExp) {
       if (isa<InitListExpr>(RetValExp)) {
         // We simply never allow init lists as the return value of void
if (getLangOpts().CPlusPlus11 && FD && FD->isConstexpr()) {
           IsMethod ? cast<NamedDecl>(getCurMethodDecl()) : cast<NamedDecl>(FD);
       Diag(ReturnLoc, DiagID) << ND << IsMethod;
     }
 
     Result = ReturnStmt::Create(Context, ReturnLoc, /* RetExpr=*/nullptr,
                                 /* NRVOCandidate=*/nullptr);
   } else {
     assert(RetValExp || HasDependentReturnType);
-    const VarDecl *NRVOCandidate = nullptr;
-
     QualType RetType = RelatedRetType.isNull() ? FnRetType : RelatedRetType;
 
     // C99 6.8.6.4p3(136): The return statement is not an assignment. The
     // overlap restriction of subclause 6.5.16.1 does not apply to the case of
     // function return.
 
     // In C++ the return statement is handled via a copy initialization,
     // the C version of which boils down to CheckSingleAssignmentConstraints.
-    if (RetValExp)
-      NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, CES_Strict);
     if (!HasDependentReturnType && !RetValExp->isTypeDependent()) {
       // we have a non-void function with an expression, continue checking
-      InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
-                                                                     RetType,
-                                                      NRVOCandidate != nullptr);
-      ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
-                                                       RetType, RetValExp);
+      InitializedEntity Entity = InitializedEntity::InitializeResult(
+          ReturnLoc, RetType, NRVORes.isCopyElidable);
+      ExprResult Res = PerformMoveOrCopyInitialization(
+          Entity, NRVORes.Candidate, RetType, RetValExp);
       if (Res.isInvalid()) {
         // FIXME: Clean up temporaries here anyway?
         return StmtError();
       }
       RetValExp = Res.getAs<Expr>();
 
       // If we have a related result type, we need to implicitly
       // convert back to the formal result type.  We can't pretend to
if (FnRetType->isVoidType()) {
 
     if (RetValExp) {
       ExprResult ER =
           ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
       if (ER.isInvalid())
         return StmtError();
       RetValExp = ER.get();
     }
-    Result = ReturnStmt::Create(Context, ReturnLoc, RetValExp, NRVOCandidate);
+    Result = ReturnStmt::Create(Context, ReturnLoc, RetValExp,
+                                NRVORes.isCopyElidable ? NRVORes.Candidate
+                                                       : nullptr);
   }
 
   // If we need to check for the named return value optimization, save the
   // return statement in our scope for later processing.
   if (Result->getNRVOCandidate())
     FunctionScopes.back()->Returns.push_back(Result);
 
   if (FunctionScopes.back()->FirstReturnLoc.isInvalid())

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
   // Substitute the nested name specifier, if any.
   if (SubstQualifier(D, Var))
     return nullptr;
 
   SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
                                      StartingScope, InstantiatingVarTemplate);
 
   if (D->isNRVOVariable()) {
-    QualType ReturnType = cast<FunctionDecl>(DC)->getReturnType();
-    if (SemaRef.isCopyElisionCandidate(ReturnType, Var, Sema::CES_Strict))
-      Var->setNRVOVariable(true);
+    QualType ReturnType;
+    if (auto *F = dyn_cast<FunctionDecl>(DC))
+      ReturnType = F->getReturnType();
+    else if (auto *F = dyn_cast<BlockDecl>(DC))
+      goto unimplemented; // FIXME: get the return type here somehow...
+    else
+      assert(false && "Unknown context type");
+
+    Sema::NRVOResult Res = SemaRef.getNRVOResult(Var);
+    SemaRef.getNRVOResultFnRetType(Res, ReturnType);
+    Var->setNRVOVariable(Res.isCopyElidable);
   }
+unimplemented:
 
   Var->setImplicit(D->isImplicit());
 
   if (Var->isStaticLocal())
     SemaRef.CheckStaticLocalForDllExport(Var);
 
   return Var;
 }

clang/lib/Sema/SemaType.cpp

 
 /// getDecltypeForExpr - Given an expr, will return the decltype for
 /// that expression, according to the rules in C++11
 /// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18.
 static QualType getDecltypeForExpr(Sema &S, Expr *E) {
   if (E->isTypeDependent())
     return S.Context.DependentTy;
 
+  Expr *IDExpr = E;
+  if (auto *ImplCastExpr = dyn_cast<ImplicitCastExpr>(E))
+    IDExpr = ImplCastExpr->getSubExpr();
+
   // C++11 [dcl.type.simple]p4:
   //   The type denoted by decltype(e) is defined as follows:
 
   // C++20:
   //     - if E is an unparenthesized id-expression naming a non-type
   //       template-parameter (13.2), decltype(E) is the type of the
   //       template-parameter after performing any necessary type deduction
   // Note that this does not pick up the implicit 'const' for a template
   // parameter object. This rule makes no difference before C++20 so we apply
   // it unconditionally.
-  if (const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
+  if (const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))
     return SNTTPE->getParameterType(S.Context);
 
   //     - if e is an unparenthesized id-expression or an unparenthesized class
   //       member access (5.2.5), decltype(e) is the type of the entity named
   //       by e. If there is no such entity, or if e names a set of overloaded
   //       functions, the program is ill-formed;
   //
   // We apply the same rules for Objective-C ivar and property references.
-  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
+  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
     const ValueDecl *VD = DRE->getDecl();
     if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(VD))
       return TPO->getType().getUnqualifiedType();
     return VD->getType();
-  } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
+  } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(IDExpr)) {
     if (const ValueDecl *VD = ME->getMemberDecl())
       if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
         return VD->getType();
-  } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(E)) {
+  } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
     return IR->getDecl()->getType();
-  } else if (const ObjCPropertyRefExpr *PR = dyn_cast<ObjCPropertyRefExpr>(E)) {
+  } else if (const ObjCPropertyRefExpr *PR =
+                 dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
     if (PR->isExplicitProperty())
       return PR->getExplicitProperty()->getType();
-  } else if (auto *PE = dyn_cast<PredefinedExpr>(E)) {
+  } else if (auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
     return PE->getType();
   }
 
   // C++11 [expr.lambda.prim]p18:
   //   Every occurrence of decltype((x)) where x is a possibly
   //   parenthesized id-expression that names an entity of automatic
   //   storage duration is treated as if x were transformed into an
   //   access to a corresponding data member of the closure type that
   //   would have been declared if x were an odr-use of the denoted
   //   entity.
   using namespace sema;
   if (S.getCurLambda()) {
-    if (isa<ParenExpr>(E)) {
-      if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
+    if (isa<ParenExpr>(IDExpr)) {
+      if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(IDExpr->IgnoreParens())) {
         if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
           QualType T = S.getCapturedDeclRefType(Var, DRE->getLocation());
           if (!T.isNull())
             return S.Context.getLValueReferenceType(T);
         }
       }
     }
   }

clang/test/CXX/class/class.init/class.copy.elision/p3.cpp

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=expected,cxx20_2b %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx20_2b %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17 %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17 %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17 %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=expected,cxx20_2b,cxx2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_20,cxx20_2b %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17,cxx11_20 %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17,cxx11_20 %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17,cxx11_20 %s
 
 namespace test_delete_function {
 struct A1 {
   A1();
   A1(const A1 &);
   A1(A1 &&) = delete; // expected-note {{'A1' has been explicitly marked deleted here}}
 };
 A1 test1() {

 };
 
 extern CopyOnly copyonly;
 extern MoveOnly moveonly;
 
 CopyOnly t1() {
     CopyOnly& r = copyonly;
     return r;
 }
 
 CopyOnly t2() {
     CopyOnly&& r = static_cast<CopyOnly&&>(copyonly);
     return r; // cxx20_2b-error {{call to deleted constructor}}
 }
 
 MoveOnly t3() {
     MoveOnly& r = moveonly;
     return r; // expected-error {{call to implicitly-deleted copy constructor}}
 }
 
 MoveOnly t4() {
     MoveOnly&& r = static_cast<MoveOnly&&>(moveonly);
     return r; // cxx11_17-error {{call to implicitly-deleted copy constructor}}
 }
 
 Target t5() {
     CopyOnly& r = copyonly;
Target t4() {
     return r; // expected-error {{invokes a deleted function}}
 }
 
 } // namespace test_rvalue_ref_to_nonobject
 
 namespace test_simpler_implicit_move {
 
 struct CopyOnly {
-  CopyOnly();
-  CopyOnly(CopyOnly &);
+  CopyOnly(); // cxx2b-note {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
+  // cxx2b-note@-1 {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
+  CopyOnly(CopyOnly &); // cxx2b-note {{candidate constructor not viable: expects an lvalue for 1st argument}}
+  // cxx2b-note@-1 {{candidate constructor not viable: expects an lvalue for 1st argument}}
 };
 struct MoveOnly {
   MoveOnly();
   MoveOnly(MoveOnly &&);
 };
 MoveOnly &&rref();
 
 MoveOnly &&test1(MoveOnly &&w) {
-  return w; // expected-error {{cannot bind to lvalue of type}}
+  return w; // cxx11_20-error {{cannot bind to lvalue of type}}
 }
 
 CopyOnly test2(bool b) {
   static CopyOnly w1;
   CopyOnly w2;
   if (b) {
     return w1;
   } else {
-    return w2;
+    return w2; // cxx2b-error {{no matching constructor for initialization}}
   }
 }
 
-template <class T> T &&test3(T &&x) { return x; } // expected-error {{cannot bind to lvalue of type}}
+template <class T> T &&test3(T &&x) { return x; } // cxx11_20-error {{cannot bind to lvalue of type}}
 template MoveOnly& test3<MoveOnly&>(MoveOnly&);
-template MoveOnly&& test3<MoveOnly>(MoveOnly&&); // expected-note {{in instantiation of function template specialization}}
+template MoveOnly &&test3<MoveOnly>(MoveOnly &&); // cxx11_20-note {{in instantiation of function template specialization}}
 
 MoveOnly &&test4() {
   MoveOnly &&x = rref();
-  return x; // expected-error {{cannot bind to lvalue of type}}
+  return x; // cxx11_20-error {{cannot bind to lvalue of type}}
 }
 
 void test5() try {
   CopyOnly x;
-  throw x;
+  throw x; // cxx2b-error {{no matching constructor for initialization}}
 } catch (...) {
 }
 
 } // namespace test_simpler_implicit_move

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-cxx14.cpp

-// RUN: %clang_cc1 -verify -std=c++2b -verify %s
-// RUN: %clang_cc1 -verify -std=c++20 -verify %s
-// RUN: %clang_cc1 -verify -std=c++14 -verify %s
+// RUN: %clang_cc1 -verify -std=c++2b -verify=expected,cxx2b    %s
+// RUN: %clang_cc1 -verify -std=c++20 -verify=expected,cxx14_20 %s
+// RUN: %clang_cc1 -verify -std=c++14 -verify=expected,cxx14_20 %s
 
 namespace std {
   template<typename T> struct initializer_list {
     const T *p;
     unsigned long n;
     initializer_list(const T *p, unsigned long n);
   };
 }

 auto x3a = i;
 decltype(auto) x3d = i;
 using Int = decltype(x3a);
 using Int = decltype(x3d);
 
 auto x4a = (i);
 decltype(auto) x4d = (i);
 using Int = decltype(x4a);
-using IntLRef = decltype(x4d);
+using IntLRef = decltype(x4d); // cxx2b-note {{previous definition is here}}
 
 auto x5a = f();
 decltype(auto) x5d = f();
 using Int = decltype(x5a);
 using IntRRef = decltype(x5d);
 
 auto x6a = { 1, 2 };
 decltype(auto) x6d = { 1, 2 }; // expected-error {{cannot deduce 'decltype(auto)' from initializer list}}

 auto f2a(int n) { return n; }
 decltype(auto) f2d(int n) { return n; }
 using Int = decltype(f2a(0));
 using Int = decltype(f2d(0));
 
 auto f3a(int n) { return (n); }
 decltype(auto) f3d(int n) { return (n); } // expected-warning {{reference to stack memory}}
 using Int = decltype(f3a(0));
-using IntLRef = decltype(f3d(0));
+using IntLRef = decltype(f3d(0)); // cxx2b-error {{type alias redefinition with different types ('decltype(f3d(0))' (aka 'int &&') vs 'decltype(x4d)' (aka 'int &'))}}
 
 auto f4a(int n) { return f(); }
 decltype(auto) f4d(int n) { return f(); }
 using Int = decltype(f4a(0));
 using IntRRef = decltype(f4d(0));
 
 auto f5aa(int n) { auto x = f(); return x; }
 auto f5ad(int n) { decltype(auto) x = f(); return x; }
 decltype(auto) f5da(int n) { auto x = f(); return x; }
-decltype(auto) f5dd(int n) { decltype(auto) x = f(); return x; } // expected-error {{rvalue reference to type 'int' cannot bind to lvalue}}
+decltype(auto) f5dd(int n) { decltype(auto) x = f(); return x; } // cxx14_20-error {{rvalue reference to type 'int' cannot bind to lvalue}}
 using Int = decltype(f5aa(0));
 using Int = decltype(f5ad(0));
 using Int = decltype(f5da(0));
 
 auto init_list_1() { return { 1, 2, 3 }; } // expected-error {{cannot deduce return type from initializer list}}
 decltype(auto) init_list_2() { return { 1, 2, 3 }; } // expected-error {{cannot deduce return type from initializer list}}

clang/test/CXX/drs/dr3xx.cpp

-// RUN: %clang_cc1 -std=c++2b -verify=expected,cxx20_2b -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx20_2b -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 -verify=expected,cxx98_17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 -verify=expected,cxx98_17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98_17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98_17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2b -verify=expected,cxx20_2b,cxx2b    -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx98_20,cxx20_2b -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
 
 namespace dr300 { // dr300: yes
   template<typename R, typename A> void f(R (&)(A)) {}
   int g(int);
   void h() { f(g); }
 }
 
 namespace dr301 { // dr301: yes

 }
 
 // dr348: na
 
 namespace dr349 { // dr349: no
   struct A {
     template <class T> operator T ***() {
       int ***p = 0;
-      return p; // expected-error {{cannot initialize return object of type 'const int ***' with an lvalue of type 'int ***'}}
+      return p; // cxx98_20-error {{cannot initialize return object of type 'const int ***' with an lvalue of type 'int ***'}}
+      // cxx2b-error@-1 {{cannot initialize return object of type 'const int ***' with an rvalue of type 'int ***'}}
     }
   };
 
   // FIXME: This is valid.
   A a;
   const int *const *const *p1 = a; // expected-note {{in instantiation of}}
 
   struct B {

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4-cxx14.cpp

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b    %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20 %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20 %s
 
 int a;
 int &b = [] (int &r) -> decltype(auto) { return r; } (a);
 int &c = [] (int &r) -> decltype(auto) { return (r); } (a);
 int &d = [] (int &r) -> auto & { return r; } (a);
 int &e = [] (int &r) -> auto { return r; } (a); // expected-error {{cannot bind to a temporary}}
 int &f = [] (int r) -> decltype(auto) { return r; } (a); // expected-error {{cannot bind to a temporary}}
 int &g = [] (int r) -> decltype(auto) { return (r); } (a); // expected-warning {{reference to stack}}
+// cxx2b-error@-1 {{on-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 
 int test_explicit_auto_return()
 {
     struct X {};
     auto L = [](auto F, auto a) { return F(a); };
     auto M = [](auto a) -> auto { return a; }; // OK
-    auto MRef = [](auto b) -> auto& { return b; }; //expected-warning{{reference to stack}}
+    auto MRef = [](auto b) -> auto & { return b; }; //cxx14_20-warning{{reference to stack}}
+    // cxx2b-error@-1 {{non-const lvalue reference to type 'X' cannot bind to a temporary of type 'X'}}
     auto MPtr = [](auto c) -> auto* { return &c; }; //expected-warning{{address of stack}}
     auto MDeclType = [](auto&& d) -> decltype(auto) { return static_cast<decltype(d)>(d); }; //OK
     M(3);
 
     auto &&x = MDeclType(X{});
     auto &&x1 = M(X{});
     auto &&x2 = MRef(X{});//expected-note{{in instantiation of}}
     auto &&x3 = MPtr(X{}); //expected-note{{in instantiation of}}

clang/test/CXX/temp/temp.decls/temp.mem/p5.cpp

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b    %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx98_20 %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_20 %s
 
 struct A {
   template <class T> operator T*();
 };
 
 template <class T> A::operator T*() { return 0; }
 template <> A::operator char*(){ return 0; } // specialization
 template A::operator void*(); // explicit instantiation
template<typename T> operator T*() {
     T x = 1; // expected-note{{variable 'x' declared const here}}
     x = 17; // expected-error{{cannot assign to variable 'x' with const-qualified type 'const int'}}
   }
 
   template<typename T> operator T*() const; // expected-note{{explicit instantiation refers here}}
 
   template<typename T> operator const T*() const {
     T x = T();
-    return x; // expected-error{{cannot initialize return object of type 'const char *' with an lvalue of type 'char'}} \
-    // expected-error{{cannot initialize return object of type 'const int *' with an lvalue of type 'int'}}
+    return x; // cxx98_20-error{{cannot initialize return object of type 'const char *' with an lvalue of type 'char'}} \
+    // cxx98_20-error{{cannot initialize return object of type 'const int *' with an lvalue of type 'int'}} \
+    // cxx2b-error{{cannot initialize return object of type 'const char *' with an rvalue of type 'char'}} \
+    // cxx2b-error{{cannot initialize return object of type 'const int *' with an rvalue of type 'int'}}
   }
 };
 
 template X0::operator const char*() const; // expected-note{{'X0::operator const char *<char>' requested here}}
 template X0::operator const int*(); // expected-note{{'X0::operator const int *<const int>' requested here}}
 template X0::operator float*() const; // expected-error{{explicit instantiation of undefined function template}}
 
 void test_X0(X0 x0, const X0 &x0c) {

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

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx20_2b -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b    -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx11_20,cxx20_2b -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11_20,cxx11    -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
 
 namespace StaticAssertFoldTest {
 
 int x;
 static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
 // cxx20_2b-note@-1 {{cannot modify an object that is visible outside that expression}}
 static_assert(false, "test"); // expected-error {{test}}
 

 
 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 m = m; // expected-error {{constant expression}} expected-note {{read of object outside its lifetime}}
   }
 
   constexpr int &get(int &&n) { return n; }
+  // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
+  // cxx2b-error@-2 {{no return statement in constexpr function}} See PR40598
   constexpr int &&get_rv(int &&n) { return static_cast<int&&>(n); }
   struct S {
     int &&r;
     int &s;
     int t;
     constexpr S() : r(get_rv(0)), s(get(0)), t(r) {} // expected-note {{read of object outside its lifetime}}
-    constexpr S(int) : r(get_rv(0)), s(get(0)), t(s) {} // expected-note {{read of object outside its lifetime}}
+    constexpr S(int) : r(get_rv(0)), s(get(0)), t(s) {}
+    // cxx2b-warning@-1 {{reference 's' is not yet bound to a value when used here}}
+    // cxx2b-note@-2    {{read of uninitialized object is not allowed in a constant expression}}
+    // cxx11_20-note@-3 {{read of object outside its lifetime}}
   };
   constexpr int k1 = S().t; // expected-error {{constant expression}} expected-note {{in call}}
   constexpr int k2 = S(0).t; // expected-error {{constant expression}} expected-note {{in call}}
 
   struct Q {
     int n = 0;
     constexpr int f() const { return 0; }
   };

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

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b %s -fcxx-exceptions -triple=x86_64-linux-gnu
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx20_2b %s -fcxx-exceptions -triple=x86_64-linux-gnu
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14    %s -fcxx-exceptions -triple=x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b    %s -fcxx-exceptions -triple=x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fcxx-exceptions -triple=x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14    %s -fcxx-exceptions -triple=x86_64-linux-gnu
 
 struct S {
   // dummy ctor to make this a literal type
   constexpr S(int);
 
   S();
 
   int arr[10];
namespace null {
   constexpr int test(int *p) {
     return *p = 123; // expected-note {{assignment to dereferenced null pointer}}
   }
   static_assert(test(0), ""); // expected-error {{constant expression}} expected-note {{in call}}
 }
 
 namespace incdec {
   template<typename T> constexpr T &ref(T &&r) { return r; }
+  // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
   template<typename T> constexpr T postinc(T &&r) { return (r++, r); }
   template<typename T> constexpr T postdec(T &&r) { return (r--, r); }
 
+  template int &ref<int>(int &&);
+  // cxx2b-note@-1  {{in instantiation of function template specialization}}
+
+  static_assert(postinc(0) == 1, "");
+  static_assert(postdec(0) == -1, "");
+#if __cplusplus <= 202002L
   static_assert(++ref(0) == 1, "");
   static_assert(ref(0)++ == 0, "");
-  static_assert(postinc(0) == 1, "");
   static_assert(--ref(0) == -1, "");
   static_assert(ref(0)-- == 0, "");
-  static_assert(postdec(0) == -1, "");
+#endif
 
+#if __cplusplus <= 202002L
   constexpr int overflow_int_inc_1 = ref(0x7fffffff)++; // expected-error {{constant}} expected-note {{2147483648}}
   constexpr int overflow_int_inc_1_ok = ref(0x7ffffffe)++;
   constexpr int overflow_int_inc_2 = ++ref(0x7fffffff); // expected-error {{constant}} expected-note {{2147483648}}
   constexpr int overflow_int_inc_2_ok = ++ref(0x7ffffffe);
 
   // inc/dec on short can't overflow because we promote to int first
   static_assert(++ref<short>(0x7fff) == (int)0xffff8000u, "");
   static_assert(--ref<short>(0x8000) == 0x7fff, "");
 
   // inc on bool sets to true
   static_assert(++ref(false), ""); // cxx14-warning {{deprecated}}
   // cxx20_2b-error@-1 {{ISO C++17 does not allow incrementing expression of type bool}}
   static_assert(++ref(true), ""); // cxx14-warning {{deprecated}}
   // cxx20_2b-error@-1 {{ISO C++17 does not allow incrementing expression of type bool}}
+#endif
 
   int arr[10];
+  static_assert(postinc(&arr[0]) == &arr[1], "");
+  static_assert(postdec(&arr[1]) == &arr[0], "");
+#if __cplusplus <= 202002L
   static_assert(++ref(&arr[0]) == &arr[1], "");
   static_assert(++ref(&arr[9]) == &arr[10], "");
   static_assert(++ref(&arr[10]) == &arr[11], ""); // expected-error {{constant}} expected-note {{cannot refer to element 11}}
   static_assert(ref(&arr[0])++ == &arr[0], "");
   static_assert(ref(&arr[10])++ == &arr[10], ""); // expected-error {{constant}} expected-note {{cannot refer to element 11}}
-  static_assert(postinc(&arr[0]) == &arr[1], "");
   static_assert(--ref(&arr[10]) == &arr[9], "");
   static_assert(--ref(&arr[1]) == &arr[0], "");
   static_assert(--ref(&arr[0]) != &arr[0], ""); // expected-error {{constant}} expected-note {{cannot refer to element -1}}
   static_assert(ref(&arr[1])-- == &arr[1], "");
   static_assert(ref(&arr[0])-- == &arr[0], ""); // expected-error {{constant}} expected-note {{cannot refer to element -1}}
-  static_assert(postdec(&arr[1]) == &arr[0], "");
+#endif
 
+  static_assert(postinc(0.0) == 1.0, "");
+  static_assert(postdec(0.0) == -1.0, "");
+#if __cplusplus <= 202002L
   int x;
   static_assert(++ref(&x) == &x + 1, "");
 
   static_assert(++ref(0.0) == 1.0, "");
   static_assert(ref(0.0)++ == 0.0, "");
-  static_assert(postinc(0.0) == 1.0, "");
   static_assert(--ref(0.0) == -1.0, "");
   static_assert(ref(0.0)-- == 0.0, "");
-  static_assert(postdec(0.0) == -1.0, "");
 
   static_assert(++ref(1e100) == 1e100, "");
   static_assert(--ref(1e100) == 1e100, "");
+#endif
 
   union U {
     int a, b;
   };
   constexpr int f(U u) {
     return ++u.b; // expected-note {{increment of member 'b' of union with active member 'a'}}
   }
   constexpr int wrong_member = f({0}); // expected-error {{constant}} expected-note {{in call to 'f({.a = 0})'}}
namespace VirtualFromBase {
   // Virtual f(), not OK.
   constexpr X<X<S2>> xxs2;
   constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2);
   static_assert(q->f() == sizeof(X<S2>), ""); // cxx14-error {{constant expression}} cxx14-note {{virtual function}}
 }
 
 namespace Lifetime {
   constexpr int &get(int &&r) { return r; }
+  // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
+  // cxx2b-error@-2 {{no return statement in constexpr function}} See PR40598
   constexpr int f() {
     int &r = get(123);
-    return r; // expected-note {{read of object outside its lifetime}}
+    return r;
+    // cxx2b-note@-1 {{use of reference outside its lifetime is not allowed in a constant expression}}
+    // cxx14_20-note@-2 {{read of object outside its lifetime}}
   }
   static_assert(f() == 123, ""); // expected-error {{constant expression}} expected-note {{in call}}
 
   constexpr int g() {
     int *p = 0;
     {
       int n = 0;
       p = &n;

clang/test/SemaCXX/coroutine-rvo.cpp

 struct MoveOnly {
   MoveOnly() = default;
   MoveOnly(const MoveOnly&) = delete;
   MoveOnly(MoveOnly &&) = default;
 };
 
 struct NoCopyNoMove {
   NoCopyNoMove() = default;
-  NoCopyNoMove(const NoCopyNoMove &) = delete; // expected-note 4{{'NoCopyNoMove' has been explicitly marked deleted here}}
+  NoCopyNoMove(const NoCopyNoMove &) = delete;
 };
 
 template <typename T>
 struct task {
   struct promise_type {
     auto initial_suspend() { return suspend_never{}; }
     auto final_suspend() noexcept { return suspend_never{}; }
     auto get_return_object() { return task{}; }
     static void unhandled_exception() {}
     void return_value(T &&value) {} // expected-note 4{{passing argument}}
   };
 };
 
 task<NoCopyNoMove> local2val() {
   NoCopyNoMove value;
-  co_return value; // expected-error {{call to deleted constructor of 'NoCopyNoMove'}}
-  // expected-error@-1 {{value reference to type 'NoCopyNoMove' cannot bind to lvalue of type 'NoCopyNoMove'}}
+  co_return value;
 }
 
 task<NoCopyNoMove &> local2ref() {
   NoCopyNoMove value;
-  co_return value; // expected-error {{call to deleted constructor of 'NoCopyNoMove'}}
+  co_return value; // expected-error {{non-const lvalue reference to type 'NoCopyNoMove' cannot bind to a temporary of type 'NoCopyNoMove'}}
 }
 
 // We need the move constructor for construction of the coroutine.
 task<MoveOnly> param2val(MoveOnly value) {
   co_return value;
 }
 
 task<NoCopyNoMove> lvalue2val(NoCopyNoMove &value) {
   co_return value; // expected-error {{rvalue reference to type 'NoCopyNoMove' cannot bind to lvalue of type 'NoCopyNoMove'}}
 }
 
 task<NoCopyNoMove> rvalue2val(NoCopyNoMove &&value) {
-  co_return value; // expected-error {{rvalue reference to type 'NoCopyNoMove' cannot bind to lvalue of type 'NoCopyNoMove'}}
-  // expected-error@-1 {{call to deleted constructor of 'NoCopyNoMove'}}
+  co_return value;
 }
 
 task<NoCopyNoMove &> lvalue2ref(NoCopyNoMove &value) {
   co_return value;
 }
 
 task<NoCopyNoMove &> rvalue2ref(NoCopyNoMove &&value) {
-  co_return value; // expected-error {{call to deleted constructor of 'NoCopyNoMove'}}
+  co_return value; // expected-error {{non-const lvalue reference to type 'NoCopyNoMove' cannot bind to a temporary of type 'NoCopyNoMove'}}
 }
 
 struct To {
   operator MoveOnly() &&;
 };
 task<MoveOnly> conversion_operator() {
   To t;
   co_return t;

clang/test/SemaCXX/coroutines.cpp

 // This file contains references to sections of the Coroutines TS, which can be
 // found at http://wg21.link/coroutines.
 
-// RUN: %clang_cc1 -std=c++2b                 -fsyntax-only -verify=expected,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result
-// RUN: %clang_cc1 -std=c++20                 -fsyntax-only -verify=expected,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result
-// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -fsyntax-only -verify=expected          %s -fcxx-exceptions -fexceptions -Wunused-result
+// RUN: %clang_cc1 -std=c++2b                 -fsyntax-only -verify=expected,cxx20_2b,cxx2b    %s -fcxx-exceptions -fexceptions -Wunused-result
+// RUN: %clang_cc1 -std=c++20                 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result
+// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -fsyntax-only -verify=expected,cxx14_20          %s -fcxx-exceptions -fexceptions -Wunused-result
 
 void no_coroutine_traits_bad_arg_await() {
   co_await a; // expected-error {{include <experimental/coroutine>}}
   // expected-error@-1 {{use of undeclared identifier 'a'}}
 }
 
 void no_coroutine_traits_bad_arg_yield() {
   co_yield a; // expected-error {{include <experimental/coroutine>}}
struct promise_type {
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception();
   };
 };
 
 extern "C" int f(mismatch_gro_type_tag2) {
-  // expected-error@-1 {{cannot initialize return object of type 'int' with an lvalue of type 'void *'}}
+  // cxx2b-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void *'}}
+  // cxx14_20-error@-2 {{cannot initialize return object of type 'int' with an lvalue of type 'void *'}}
   co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
 }
 
 struct mismatch_gro_type_tag3 {};
 template<>
 struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag3> {
   struct promise_type {
     int get_return_object() {}

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b %s
-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b    %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b    %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
 
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx20_2b %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx20_2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
 
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14    %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14    %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14    %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14    %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
 
 auto f(); // expected-note {{previous}}
 int f(); // expected-error {{differ only in their return type}}
 
 auto &g();
 auto g() -> auto &;
 
 auto h() -> auto *;
const auto void_ret_4() {
   return 0; // expected-error {{'auto' in return type deduced as 'int' here but deduced as 'void' in earlier return statement}}
 }
 
 namespace Templates {
   template<typename T> auto f1() {
     return T() + 1;
   }
   template<typename T> auto &f2(T &&v) { return v; }
+  // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
+  // cxx2b-error@-2 {{non-const lvalue reference to type 'double' cannot bind to a temporary of type 'double'}}
+  // cxx2b-note@-3  {{candidate template ignored: substitution failure [with T = double]}}
   int a = f1<int>();
-  const int &b = f2(0);
+  const int &b = f2(0); // cxx2b-note {{in instantiation of function template specialization 'Templates::f2<int>' requested here}}
   double d;
   float &c = f2(0.0); // expected-error {{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'double'}}
+  // cxx2b-note@-1 {{in instantiation of function template specialization 'Templates::f2<double>' requested here}}
 
   template<typename T> auto fwd_decl(); // expected-note {{declared here}}
   int e = fwd_decl<int>(); // expected-error {{cannot be used before it is defined}}
   template<typename T> auto fwd_decl() { return 0; }
   int f = fwd_decl<int>();
   template <typename T>
   auto fwd_decl(); // expected-note {{candidate template ignored: could not match 'auto ()' against 'int ()'}}
   int g = fwd_decl<char>();
 
   auto (*p)() = f1; // expected-error {{incompatible initializer}}
   auto (*q)() = f1<int>; // ok
 
-  typedef decltype(f2(1.2)) dbl; // expected-note {{previous}}
-  typedef float dbl; // expected-error {{typedef redefinition with different types ('float' vs 'decltype(f2(1.2))' (aka 'double &'))}}
+  typedef decltype(f2(1.2)) dbl; // cxx14_20-note {{previous}}
+  // cxx2b-error@-1 {{no matching function for call to 'f2'}}
+  typedef float dbl; // cxx14_20-error {{typedef redefinition with different types ('float' vs 'decltype(f2(1.2))' (aka 'double &'))}}
 
   extern template auto fwd_decl<double>();
   int k1 = fwd_decl<double>();
   extern template int fwd_decl<char>(); // expected-error {{does not refer to a function template}}
   int k2 = fwd_decl<char>();
 
   template <typename T> auto instantiate() { T::error; } // expected-error {{has no members}} \
     // expected-note {{candidate template ignored: could not match 'auto ()' against 'void ()'}}

clang/test/SemaCXX/return-stack-addr.cpp

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected       %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected       %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11 %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b          %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx11_20       %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11_20,cxx11 %s
 
 int* ret_local() {
   int x = 1;
   return &x; // expected-warning {{address of stack memory}}
 }
 
 int* ret_local_array() {
   int x[10];

 
 int* ret_local_array_element_const_index() {
   int x[10];
   return &x[2];  // expected-warning {{address of stack memory}}
 }
 
 int& ret_local_ref() {
   int x = 1;
-  return x;  // expected-warning {{reference to stack memory}}
+  return x; // cxx11_20-warning {{reference to stack memory}}
+  // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 }
 
 int* ret_local_addrOf() {
   int x = 1;
   return &*&x; // expected-warning {{address of stack memory}}
 }
 
 int* ret_local_addrOf_paren() {

 // we're within a lambda-expression.
 void ret_from_lambda() {
   int a;
   int &b = a;
   (void) [&]() -> int& { return a; };
   (void) [&]() -> int& { return b; };
   (void) [=]() mutable -> int& { return a; };
   (void) [=]() mutable -> int& { return b; };
-  (void) [&]() -> int& { int a; return a; }; // expected-warning {{reference to stack}}
-  (void) [=]() -> int& { int a; return a; }; // expected-warning {{reference to stack}}
+  (void) [&]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}}
+  // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
+  (void) [=]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}}
+  // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
   (void) [&]() -> int& { int &a = b; return a; };
   (void) [=]() mutable -> int& { int &a = b; return a; };
 
   (void) [] {
     int a;
     return [&] { // expected-warning {{address of stack memory associated with local variable 'a' returned}}
       return a; // expected-note {{implicitly captured by reference due to use here}}
     };

clang/test/SemaCXX/warn-return-std-move.cpp

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=cxx20_2b -fcxx-exceptions -Wreturn-std-move %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=cxx20_2b -fcxx-exceptions -Wreturn-std-move %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=cxx20_2b,cxx2b -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=cxx20_2b       -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify=cxx11_17       -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=cxx11_17       -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=cxx11_17       -fcxx-exceptions -Wreturn-std-move %s
 
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
 // RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
 
 // definitions for std::move
 namespace std {
 inline namespace foo {

 ConvertFromBase testRParam6(Derived&& d) {
     return d;  // e16
     // cxx11_17-warning@-1{{will be copied despite being returned by name}}
     // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 
 // But if the return type is a reference type, then moving would be wrong.
-Derived& testRetRef1(Derived&& d) { return d; }
-Base& testRetRef2(Derived&& d) { return d; }
+Derived &testRetRef1(Derived &&d) { return d; } // cxx2b-error {{on-const lvalue reference to type 'Derived' cannot bind to a temporary of type 'Derived'}}
+Base &testRetRef2(Derived &&d) { return d; }    // cxx2b-error {{non-const lvalue reference to type 'Base' cannot bind to a temporary of type 'Derived'}}
 #if __cplusplus >= 201402L
 auto&& testRetRef3(Derived&& d) { return d; }
 decltype(auto) testRetRef4(Derived&& d) { return (d); }
 #endif
 
 // As long as we're checking parentheses, make sure parentheses don't disable the warning.
 Base testParens1() {
     Derived d;