[C++20] P1825R0: More implicit moves

[nullptr.cpp]

Summary

Changes in P1825R0:

• implicitly movable entity can be an rvalue reference to non-volatile automatic object.
• operand of throw-expression can be a function or catch-clause parameter (support for function parameter has already been implemented).
• in the first overload resolution, the selected function no need to be a constructor.
• in the first overload resolution, the first parameter of the selected function no need to be an rvalue reference to the object's type.

This patch also removes the diagnostic -Wreturn-std-move-in-c++11.

[• Quuxplusone]

I'd like to see some indication in the code comments, in the commit message, and/or in cxx_status.html, explaining what parts of P1825 are implemented and what parts remain unimplemented after this patch. (My ideal would be to hold this patch up until it completely implements P1825. That way we minimize the number of minor divergences in implementation quality that people will have to memorize: Clang 10 does X, Clang 11 does Y, Clang 12 does Z... let's just jump straight from X to Z if at all humanly possible.)

clang/lib/Sema/SemaStmt.cpp

3091

This looks like a severable bugfix, right? Clang's current behavior diverges from GCC's, when the named return variable is volatile-qualified. https://godbolt.org/z/5EfK99
Personally I think this should be a separate bugfix patch, with regression test, fast-tracked separately from any of the C++20 stuff.

3115–3117

You changed "p32" to "p3:" — I think you meant "p3" without the colon.

3228

FWIW, I really like the idea of this table, but I don't know how to read it in this format. Are the papers/issues listed below the relevant standard, or above it?

My understanding is that CWG1579 is a defect report against C++11 (so, -std=c++11 mode includes the new behavior added in CWG1579), but for example -std=c++17 mode definitely does not include the new behavior for rvalue references added in P1825.

Could you change e.g. "C++11" to "-std=c++11 mode includes the following patches:", for clarity?

3232

For the record, I am the person who added the diagnostic controlled by AffectedByCWG1579, and my opinion is that if removing that diagnostic would simplify the code, you should consider it. We should certainly remove it from Clang at some point — this year? next year? 2025? but it should eventually be removed.

[• Quuxplusone]

clang/lib/Sema/SemaStmt.cpp

3283

FWIW, I don't understand this TODO comment. What's to do, here?

clang/test/SemaCXX/implicit-move.cpp

21 ↗

(On Diff #294024)

if I understand correctly, you can (and should) remove the copy and move constructors from NeedRvalueRef and NoNeedRvalueRef.
Also, I strongly recommend renaming NoNeedRvalueRef to NeedValue (or something along those lines) — it's not that it doesn't need an rvalue ref, it's that it does need a non-ref.

[nullptr.cpp]

Implement whole P1825R0

[nullptr.cpp]

rebase

[nullptr.cpp]

Ping

[• Quuxplusone]

clang/include/clang/Sema/Sema.h

4727–4732

I believe RValue should be spelled Rvalue, throughout.

4735

Unless I'm mistaken, CES_AsIfByStdMove is now a synonym for CES_ImplicitlyMovableCXX20. Could we discuss the pros and cons of simply removing CES_AsIfByStdMove? Is there some difference in connotation here, like maybe we are expecting them to diverge again in C++23 or beyond?

clang/lib/Sema/SemaStmt.cpp

3159

This loop is hard to understand before your patch. I don't think you made it any worse. But, consider whether you could pull out the condition so that this part became something like

FunctionDecl *FD = Step.Function.Function;
if (!IsSuitableConversionForImplicitMove(FD, NRVOCandidate, ConvertingConstructorsOnly)) {
  break;
}
// Promote "AsRvalue" to the heap...

Actually, I don't even understand why continue; is being used in the old code. Doesn't that mean "skip this step and go on to the next step"?

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

59

(1) I would prefer to [additionally?] see a test case using =delete, rather than having the member exist but be private. We expect the same behavior in both cases, right? but =delete is more like the code we hope people are writing in practice.

(2) Is there any simpler way to write the "pre-C++20" and "C++20" versions of this test? It's ugly to repeat the entire class body in both branches of the #if, when the only difference is whether the "expected-note" is present or not.

92

In all of these tests, I don't see any reason to have {} when ; would suffice; and I don't think you need the destructor to be explicitly declared at all; and in fact for NeedRvalueRef and NeedValue, I think just

struct NeedRvalueRef {
    NeedRvalueRef(B&&);
};

would suffice, right?

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

92

I would like to see a copy of this file, titled something like warn-return-std-move-cxx20.cpp, updated to run with -std=c++20 instead of -std=c++14. (Initially I thought that the lines above indicated a flaw in your patch; it took me a while to realize that this test file is compiled only with -std=c++14. In C++20, we expect that ConstructFromBase(Base&&) will be called and the expected-warning will not be printed, right?)

I would also appreciate either seeing an actual test file with all the test cases from http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1155r2.html , or at least hearing (in reply to this comment) that you've tested them all and you believe their behavior is correct.

It looks to me as if every P1155r2 case is handled correctly except for this one:

struct To {
    operator Widget() const &;  // "copy"
    operator Widget() &&;  // "move"
};
Widget nine() {
    To t;
    return t;  // C++17 copies; C++20 should move (but this patch still copies)
}

[• Quuxplusone]

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

22

@rsmith @david_stone (or anyone), what is the status in C++20 of the following test case?

C&& test(C&& c) {
    return c;
}

I know we talked about this in person at CppCon 2018, and concluded that our intention was for this to be legal, but that it wasn't actually legal as-worded, because the returned thingie here is not an object but rather a reference, and therefore none of P1825's wording actually covers it. Is that still the case? Is there an open issue about this? Is there any appetite for Clang to just go ahead and make this legal? (The current patch does not make this legal.)

Relevant reading: https://quuxplusone.github.io/blog/2018/09/25/perfect-backwarding/

[• Quuxplusone]

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

22

Apparently @davidstone has been active more recently than @david_stone... :)

[davidstone]

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

22

Going through the wording in http://eel.is/c++draft/class.copy.elision#3

"An implicitly movable entity is a variable of automatic storage duration that is either a non-volatile object or an rvalue reference to a non-volatile object type."

So we are fine with a reference as the source. However, it then goes on to say

"...overload resolution to select the constructor for the copy or the return_­value overload to call is first performed as if the expression or operand were an rvalue."

There is technically no constructor to call here, which I think means this section does not apply.

I don't believe an issue has been raised for this yet, so I'll email CWG about it.

[• Quuxplusone]

I've found another case that Clang has never handled correctly (and which your patch does not fix)—
https://godbolt.org/z/xd8qGW

struct Widget {};
struct Frodo {
    Frodo(Widget&);
    Frodo(Widget&&) = delete;
};

Frodo twelve() {
    Widget w;
    return w;  // according to the majority of vendors, the first pass should not "fail";
               // it should successfully find the deleted overload and hard-error at that point.
               // This has been the case ever since C++11, AFAIK.
}

This example will be mentioned in my upcoming (not-yet-finished) WG21 paper P2266, as an example of why the two-pass mechanism sucks and should be removed from C++2b.

[nullptr.cpp]

Update

[nullptr.cpp]

clang/include/clang/Sema/Sema.h

4727–4732

There are already names such as RValueReferenceType, so be consistent with existing code.

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

28

[over.match.funcs]p8:

A defaulted move special member function that is defined as deleted is excluded from the set of candidate functions in all contexts.

So in this case still use private.

[• Quuxplusone]

clang/include/clang/Sema/Sema.h

4727–4732

Okay, I see examples both ways and wish there were one standard spelling, but I agree there's no standard at the moment, so whatever.

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

22

I don't know if there's a CWG issue number (yet?) but at least I have drafted a paper, D2266R0, on the subject. @nullptr.cpp could you take a look at this paper and let me know (perhaps by email) what you think about it?

28

If it's user-declared as deleted, then it is not defaulted.
To get a move-constructor that is defaulted as deleted, you'd have to write something like https://godbolt.org/z/KbG76v (Notice how the behavior changes if you explicitly delete it with C(C&&) = delete; instead of implicitly deleting it with C(C&&) = default;.)

[nullptr.cpp]

Add more tests

[nullptr.cpp]

rebase

[nullptr.cpp]

Ping

[nullptr.cpp]

rebase

[• Quuxplusone]

@nullptr.cpp: I may or may not come up with more review comments, but either way I'm a dead end — I don't consider myself authorized to "accept" Clang changes.
You're still going to have to attract the attention of someone with the authority and/or force-of-will to say "okay ship it."

I notice a lack of any explicitly co_return-related tests and/or code in this patch. I'm just going to assume that is fine.

[nullptr.cpp]

In D88220#2495071, @Quuxplusone wrote:

I notice a lack of any explicitly co_return-related tests and/or code in this patch. I'm just going to assume that is fine.

co_return related implicit move is implemented by @aaronpuchert in D68845. Since P1825 mainly focused on removing the unnecessary limitations on implicit move, not coroutines, I think it's better to separate that from this patch.

[nullptr.cpp]

Add test

[nullptr.cpp]

Update

[nullptr.cpp]

Ping

[nullptr.cpp]

Ping

[nullptr.cpp]

Ping

[• Quuxplusone]

either way I'm a dead end — I don't consider myself authorized to "accept" Clang changes.
You're still going to have to attract the attention of someone with the authority and/or force-of-will to say "okay ship it."

Well, it's been a month since I said that. I'll land this tonight, unless someone yells "stop" before then. If it causes any problems, we can revert it easy enough.

[aaronpuchert]

In D88220#2565768, @Quuxplusone wrote:

either way I'm a dead end — I don't consider myself authorized to "accept" Clang changes.
You're still going to have to attract the attention of someone with the authority and/or force-of-will to say "okay ship it."

Well, it's been a month since I said that. I'll land this tonight, unless someone yells "stop" before then. If it causes any problems, we can revert it easy enough.

I think you're much more of an expert on implicit moves than most of us (except @rsmith perhaps). I've done a superficial review and didn't find anything objectionable, also we're early in the release cycle, so I think this approach is fine.

[• Quuxplusone]

In D88220#2566525, @aaronpuchert wrote:

I think you're much more of an expert on implicit moves than most of us

Short answer, yes. ;) My concern was more that I'm much less of an expert on Clang than "most of us." I'd rather trust a Clang expert to learn and implement the couple of pages of P1825, than you should trust a P1825 expert to learn and implement the couple hundred lines of Clang in this patch!

But as it's been months, I'm finally ready to WP:BOLD and let someone revert it later if they need to.

[aaronpuchert]

In D88220#2566628, @Quuxplusone wrote:

My concern was more that I'm much less of an expert on Clang than "most of us."

Understood, but Clang tries to closely follow the C++ standard in its implementation, and I'd say that the APIs used in this change do exactly what one would naively think they do. And we haven't introduced any new functions so we can't even discuss where to put them.

I'm sometimes reading up about implicit moving but the area seemed a bit in flux so I was hoping for things to settle down before I start to remember what might soon be obsolete. Let's hope this settles it.

[amccarth]

The removal of -Wreturn-std-move-in-c++11 breaks a few projects. These projects are specifying the option, which then triggers an unknown-option warning and thus -Wx halts the build.

Would anyone object to allowing the option but silently ignoring it, at least for a transition period? Was there prior notice of this option being deprecated?

[aaronpuchert]

In D88220#2571911, @amccarth wrote:

Would anyone object to allowing the option but silently ignoring it, at least for a transition period?

No objection from me.

Was there prior notice of this option being deprecated?

I don't think we have a way to deprecate warning flags. We could perhaps put something under -Woption-ignored.

@aaron.ballman, what do you think about this?

[aaron.ballman]

In D88220#2573018, @aaronpuchert wrote:

In D88220#2571911, @amccarth wrote:

Would anyone object to allowing the option but silently ignoring it, at least for a transition period?

No objection from me.

Nor from me.

Was there prior notice of this option being deprecated?

I don't think we have a way to deprecate warning flags. We could perhaps put something under -Woption-ignored.

@aaron.ballman, what do you think about this?

We don't have a loud way of deprecating them (that I'm aware of). We usually rely on the release notes to say something, but we didn't do that here. As for using -Woption-ignored... I am not certain we want it directly under that flag, but it may make sense as a subgroup of -Woption-ignored. e.g., I can imagine a use case where someone wants to silence that they're using a deprecated flag (so their -Wx builds continue to compile) but still wants to be warned when they use a option that's ignored for other reasons.

[aaronpuchert]

In D88220#2581538, @aaron.ballman wrote:

We usually rely on the release notes to say something, but we didn't do that here.

Perhaps @nullptr.cpp could add something there? The file is clang/docs/ReleaseNotes.rst.

As for using -Woption-ignored... I am not certain we want it directly under that flag, but it may make sense as a subgroup of -Woption-ignored. e.g., I can imagine a use case where someone wants to silence that they're using a deprecated flag (so their -Wx builds continue to compile) but still wants to be warned when they use a option that's ignored for other reasons.

You're right, the other flags -Woption-ignored warns about seem to have an effect on compilation such that one might want to be warned if they're ignored. Which isn't the case here, I guess.

Also it's probably Ok if people just see that the warning no longer exists and then remove it, or remove it based on the compiler version.

[nullptr.cpp]

In D88220#2583486, @aaronpuchert wrote:

In D88220#2581538, @aaron.ballman wrote:

We usually rely on the release notes to say something, but we didn't do that here.

Perhaps @nullptr.cpp could add something there? The file is clang/docs/ReleaseNotes.rst.

Add by D97364.

[amccarth]

The option is used in the wild, but not as widely as I first believed. We've already fixed a couple projects that were using it. I think the Release Note is the right solution. Thanks for doing that. I withdraw my suggestion to allow and ignore.

[rsmith]

clang/www/cxx_status.html

1206–1210

We have, so far, listed DR papers only in the section of cxx_status for the earliest language they affect (that is: the section for C++XY lists the papers that we implement in C++XY but not in earlier versions). I'm not tied to that approach, but if we want to switch away from that (and list DR papers multiple times) we should do so consistently throughout this page -- also, if we go that way, maybe the earlier reference to the paper should contain a link to the later one?

The preceding paper, P0593R6, is a bit of a special case because while -- per our "DRs apply retroactively as far back as they make sense" policy -- it should apply retroactively all the way back to C++98, it only actually affects Clang's behavior in C++20 mode, as part of P0784R7, which allowed pseudo-destruction in constant expressions. Maybe there's a clearer way to present that change.

[sberg]

This change causes

#include <memory>
std::shared_ptr<int> x1;
std::shared_ptr<int> f() {
    std::shared_ptr<int> & r = x1;
    r.reset(new int);
    return r;
}
int main() {
    std::shared_ptr<int> x2 = f();
    long n = x2.use_count();
    return n;
}

when built with -std=c++20 to erroneously return a use_count of 1 instead of 2 now.

[• Quuxplusone]

Confirmed: yikes. @nullptr.cpp, I'm going to open a new pull request to revert this, to poke the buildbot, just in case reverting it causes new failures. But I certainly don't object if someone wants to be more bold than me in reverting quickly.
Here's a reduced test case: https://godbolt.org/z/dz43W4

struct A {
    A(A&&);
    A(const A&);
};

extern A global;

A f() {
    A& r = global;
    return r;
}

[• Quuxplusone]

To whom it may concern, see D98971. I'm (unwisely?) trying a surgical fix rather than trying to revert the month-old thing. (Let's please discuss anything D98971-specific over there.)

[rsmith]

clang/lib/Sema/SemaStmt.cpp

3226–3227

P1825 was accepted as a Defect Report (see https://wiki.edg.com/bin/view/Wg21cologne2019/StrawPolls); is there a reason we're not applying this retroactively?

[• Quuxplusone]

clang/lib/Sema/SemaStmt.cpp

3226–3227

Move to accept the changes in P1825R0 (Merged wording for P0527R1 and P1155R3) as a Defect Report and apply them to the C++ working paper.

Yipes. @rsmith, is the intent that modern compilers should support

std::unique_ptr<int> from_rvalue(std::unique_ptr<int>&& x) { return x; }

in -std=c++11 mode? Are Clang, GCC, MSVC, EDG all on the same page here? If so, awesome. I just find it a priori unlikely that we got informed consensus on that.

[rsmith]

clang/lib/Sema/SemaStmt.cpp

3226–3227

Yes, the intent is that P1825 should be applied all the way back to C++11. See the CWG discussion here: https://wiki.edg.com/bin/view/Wg21cologne2019/CoreWorkingGroup#D1825R0_Merged_wording_for_P_AN1 -- in which we concluded that the entire paper should be treated as a DR.

Regarding implementation consensus: MSVC already implements the changes in all language modes (since v19.24). It looks like the intent is for GCC to do the same in GCC 12 onwards (https://github.com/gcc-mirror/gcc/commit/1722e2013f05f1f1f99379dbaa0c0df356da731f). I'm not sure what EDG's plans are.

I think for us the question is whether we can get away with doing this without any kind of transition period. If extending this all the way back to C++11 is disruptive in practice for existing code, we may need to take a more measured approach, such as phasing the introduction of this over a couple of Clang releases with warnings for things that will change behavior, but if not, I think we should just do it (and there's no better way to find out how disruptive this is than doing it...). We might actually need to implement P2266 as well, in order to avoid regressions such as the one that Jason mentioned in that GCC commit message; I suppose we'll find out.

I wonder whether we can extend this back to C++98 (and thereby have the same rules regardless of language standard). If someone is using rvalue references in C++98 (which we allow as an extension) it seems to make sense for the new behavior to apply to them. Are there cases where the new rules would affect the meaning of a standard C++98 program (ie, one that has no move constructors, no rvalue reference parameters, and so on)?

[• Quuxplusone]

clang/lib/Sema/SemaStmt.cpp

3226–3227

From Godbolt: MSVC implements all parts of p1825 in C++17 mode.
From that patch, and Godbolt: GCC trunk implements some subtle variation of p1155 (but specifically no part of p0527) in C++17 mode.

Are there cases where the new rules would affect the meaning of a standard C++98 program (ie, one that has no move constructors, no rvalue reference parameters, and so on)?

Yes, Jason Merrill's example is specifically about p1155's effect on a pathological C++98 type, which I call AutoSharePtr in my C++Now 2021 talk "The Complete Guide to return x". I will start recommending that people watch that talk, as soon as it hits YouTube. :) https://godbolt.org/z/T374o518W

[mizvekov]

clang/lib/Sema/SemaStmt.cpp

3226–3227

The most churn from this change should be caused by updating the tests.
Fortunately, we did this cleanup just a while back which should help a lot: D99225, which covers everything NRVO related in clang.

@rsmith we have a working implementation of P2266: D99005 (which depends on D99696 due to shared cleanups).
What we miss on that is implementing warnings to older standards about those changes, which we need to reevaluate anyway due to how much stuff is being changed and DR'd here.

By the way, also about what Jason Merril said in that commit: "Discussion on the CWG reflector ... settled on the model of doing only a single overload resolution, with the variable treated as an xvalue that can bind to non-const lvalue references."

^ That is what I implemented, if by any chance I understood correctly, here: D100000 (which depends on the P2266 DR above)
I am not set on any differences between my approach and the one Jason implemented, I mostly care about reducing this to a single overload resolution as welll...
So any input on that ^ would be very much appreciated.

clang/include/clang/Basic/DiagnosticGroups.td

 def OpenCLUnsupportedRGBA: DiagGroup<"opencl-unsupported-rgba">;
 def UnderalignedExceptionObject : DiagGroup<"underaligned-exception-object">;
 def DeprecatedObjCIsaUsage : DiagGroup<"deprecated-objc-isa-usage">;
 def ExplicitInitializeCall : DiagGroup<"explicit-initialize-call">;
 def Packed : DiagGroup<"packed">;
 def Padded : DiagGroup<"padded">;
 
 def PessimizingMove : DiagGroup<"pessimizing-move">;
-def ReturnStdMoveInCXX11 : DiagGroup<"return-std-move-in-c++11">;
 def ReturnStdMove : DiagGroup<"return-std-move">;
 
 def PointerArith : DiagGroup<"pointer-arith">;
 def PoundWarning : DiagGroup<"#warnings">;
 def PoundPragmaMessage : DiagGroup<"#pragma-messages">,
                          DiagCategory<"#pragma message Directive">;
 def : DiagGroup<"pointer-to-int-cast">;
 def : DiagGroup<"redundant-decls">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_pessimizing_move_on_initialization : Warning<
   InGroup<PessimizingMove>, DefaultIgnore;
 def note_remove_move : Note<"remove std::move call here">;
 
 def warn_return_std_move : Warning<
   "local variable %0 will be copied despite being %select{returned|thrown}1 by name">,
   InGroup<ReturnStdMove>, DefaultIgnore;
 def note_add_std_move : Note<
   "call 'std::move' explicitly to avoid copying">;
-def warn_return_std_move_in_cxx11 : Warning<
-  "prior to the resolution of a defect report against ISO C++11, "
-  "local variable %0 would have been copied despite being returned by name, "
-  "due to its not matching the function return type%diff{ ($ vs $)|}1,2">,
-  InGroup<ReturnStdMoveInCXX11>, DefaultIgnore;
-def note_add_std_move_in_cxx11 : Note<
-  "call 'std::move' explicitly to avoid copying on older compilers">;
 
 def warn_string_plus_int : Warning<
   "adding %0 to a string does not append to the string">,
   InGroup<StringPlusInt>;
 def warn_string_plus_char : Warning<
   "adding %0 to a string pointer does not append to the string">,
   InGroup<StringPlusChar>;
 def note_string_plus_scalar_silence : Note<

clang/include/clang/Sema/Sema.h

RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,
                                            SourceLocation Loc,
                                            unsigned NumParams);
 
   enum CopyElisionSemanticsKind {
     CES_Strict = 0,
     CES_AllowParameters = 1,
     CES_AllowDifferentTypes = 2,
     CES_AllowExceptionVariables = 4,
-    CES_FormerDefault = (CES_AllowParameters),
-    CES_Default = (CES_AllowParameters | CES_AllowDifferentTypes),
-    CES_AsIfByStdMove = (CES_AllowParameters | CES_AllowDifferentTypes |
-                         CES_AllowExceptionVariables),
+    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);
 
   StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
                              Scope *CurScope);
   StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
   StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);

clang/lib/Sema/SemaCoroutine.cpp

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) {
-    auto NRVOCandidate = this->getCopyElisionCandidate(E->getType(), E, CES_AsIfByStdMove);
+    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();
     }

clang/lib/Sema/SemaStmt.cpp

if (!(CESK & CES_AllowExceptionVariables) && VD->isExceptionVariable())
     return false;
 
   // ...automatic...
   if (!VD->hasLocalStorage()) return false;
 
   // 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;
+  if (VD->hasAttr<BlocksAttr>())
+    return false;
 
   // ...non-volatile...
   if (VD->getType().isVolatileQualified())
     return false;
 
+  // C++20 [class.copy.elision]p3:
+  // ...rvalue reference to a non-volatile...
+  if (VD->getType()->isRValueReferenceType() &&
+      (!(CESK & CES_AllowRValueReferenceType) ||
+       VD->getType().getNonReferenceType().isVolatileQualified()))
+    return false;
+
   if (CESK & CES_AllowDifferentTypes)
     return true;
 
   // Variables with higher required alignment than their type's ABI
   // alignment cannot use NRVO.
   if (!VD->getType()->isDependentType() && VD->hasAttr<AlignedAttr>() &&
       Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VD->getType()))
     return false;
 
   return true;
 }
 
 /// Try to perform the initialization of a potentially-movable value,
 /// which is the operand to a return or throw statement.
 ///
-/// This routine implements C++14 [class.copy]p32, 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.
+/// 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.
 ///
-/// \param ConvertingConstructorsOnly If true, follow [class.copy]p32 and reject
-/// resolutions that find non-constructors, such as derived-to-base conversions
-/// or `operator T()&&` member functions. If false, do consider such
+/// \param ConvertingConstructorsOnly If true, follow [class.copy.elision]p3 and
+/// reject resolutions that find non-constructors, such as derived-to-base
+/// conversions or `operator T()&&` member functions. If false, do consider such
 /// conversion sequences.
 ///
 /// \param Res We will fill this in if move-initialization was possible.
 /// If move-initialization is not possible, such that we must fall back to
 /// treating the operand as an lvalue, we will leave Res in its original
 /// invalid state.
 ///
 /// \returns Whether we need to do the second overload resolution. If the first
if (!Seq &&
     return NeedSecondOverloadResolution;
   }
 
   for (const InitializationSequence::Step &Step : Seq.steps()) {
     if (Step.Kind != InitializationSequence::SK_ConstructorInitialization &&
         Step.Kind != InitializationSequence::SK_UserConversion)
       continue;
 
     FunctionDecl *FD = Step.Function.Function;
     if (ConvertingConstructorsOnly) {
       if (isa<CXXConstructorDecl>(FD)) {
+        // C++11 [class.copy]p32:
         // C++14 [class.copy]p32:
-        // [...] If the first overload resolution fails or was not performed,
-        // or if the type of the first parameter of the selected constructor
+        // C++17 [class.copy.elision]p3:
+        // [...] if the type of the first parameter of the selected constructor
         // is not an rvalue reference to the object's type (possibly
         // cv-qualified), overload resolution is performed again, considering
         // the object as an lvalue.
         const RValueReferenceType *RRefType =
             FD->getParamDecl(0)->getType()->getAs<RValueReferenceType>();
         if (!RRefType)
           break;
         if (!S.Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
                                               NRVOCandidate->getType()))
           break;
       } else {
         continue;
       }
     } else {
       if (isa<CXXConstructorDecl>(FD)) {
         // Check that overload resolution selected a constructor taking an
         // rvalue reference. If it selected an lvalue reference, then we
         // didn't need to cast this thing to an rvalue in the first place.
-        if (!isa<RValueReferenceType>(FD->getParamDecl(0)->getType()))
+        if (IsDiagnosticsCheck &&
+            !isa<RValueReferenceType>(FD->getParamDecl(0)->getType()))
           break;
       } else if (isa<CXXMethodDecl>(FD)) {
         // Check that overload resolution selected a conversion operator
         // taking an rvalue reference.
         if (cast<CXXMethodDecl>(FD)->getRefQualifier() != RQ_RValue)
           break;
       } else {
         continue;
static bool TryMoveInitialization(Sema &S, const InitializedEntity &Entity,
   }
 
   return NeedSecondOverloadResolution;
 }
 
 /// Perform the initialization of a potentially-movable value, which
 /// is the result of return value.
 ///
-/// This routine implements C++14 [class.copy]p32, 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) {
-  // C++14 [class.copy]p32:
-  // When the criteria for elision of a copy/move operation are met, but not for
-  // an exception-declaration, and the object to be copied is designated by an
-  // lvalue, or when the expression in a return statement is a (possibly
-  // parenthesized) id-expression that names an object with automatic storage
-  // duration declared in the body or parameter-declaration-clause of the
-  // innermost enclosing function or lambda-expression, overload resolution to
-  // select the constructor for the copy is first performed as if the object
-  // were designated by an rvalue.
+/// 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) {
-    bool AffectedByCWG1579 = false;
+    CopyElisionSemanticsKind CESK = CES_Strict;
+    if (getLangOpts().CPlusPlus20) {
+      CESK = CES_ImplicitlyMovableCXX20;
+    } else if (getLangOpts().CPlusPlus11) {
+      CESK = CES_ImplicitlyMovableCXX11CXX14CXX17;
+    }
 
     if (!NRVOCandidate) {
-      NRVOCandidate = getCopyElisionCandidate(ResultType, Value, CES_Default);
-      if (NRVOCandidate &&
-          !getDiagnostics().isIgnored(diag::warn_return_std_move_in_cxx11,
-                                      Value->getExprLoc())) {
-        const VarDecl *NRVOCandidateInCXX11 =
-            getCopyElisionCandidate(ResultType, Value, CES_FormerDefault);
-        AffectedByCWG1579 = (!NRVOCandidateInCXX11);
-      }
+      NRVOCandidate = getCopyElisionCandidate(ResultType, Value, CESK);
     }
 
     if (NRVOCandidate) {
-      NeedSecondOverloadResolution = TryMoveInitialization(
-          *this, Entity, NRVOCandidate, ResultType, Value, true, false, Res);
+      NeedSecondOverloadResolution =
+          TryMoveInitialization(*this, Entity, NRVOCandidate, ResultType, Value,
+                                !getLangOpts().CPlusPlus20, false, Res);
     }
 
-    if (!NeedSecondOverloadResolution && AffectedByCWG1579) {
-      QualType QT = NRVOCandidate->getType();
-      if (QT.getNonReferenceType().getUnqualifiedType().isTriviallyCopyableType(
-              Context)) {
-        // Adding 'std::move' around a trivially copyable variable is probably
-        // pointless. Don't suggest it.
-      } else {
-        // Common cases for this are returning unique_ptr<Derived> from a
-        // function of return type unique_ptr<Base>, or returning T from a
-        // function of return type Expected<T>. This is totally fine in a
-        // post-CWG1579 world, but was not fine before.
-        assert(!ResultType.isNull());
-        SmallString<32> Str;
-        Str += "std::move(";
-        Str += NRVOCandidate->getDeclName().getAsString();
-        Str += ")";
-        Diag(Value->getExprLoc(), diag::warn_return_std_move_in_cxx11)
-            << Value->getSourceRange() << NRVOCandidate->getDeclName()
-            << ResultType << QT;
-        Diag(Value->getExprLoc(), diag::note_add_std_move_in_cxx11)
-            << FixItHint::CreateReplacement(Value->getSourceRange(), Str);
-      }
-    } else if (NeedSecondOverloadResolution &&
-               !getDiagnostics().isIgnored(diag::warn_return_std_move,
-                                           Value->getExprLoc())) {
-      const VarDecl *FakeNRVOCandidate =
-          getCopyElisionCandidate(QualType(), Value, CES_AsIfByStdMove);
+    if (!getLangOpts().CPlusPlus20 && NeedSecondOverloadResolution &&
+      const VarDecl *FakeNRVOCandidate = getCopyElisionCandidate(
+          QualType(), Value, CES_ImplicitlyMovableCXX20);
       if (FakeNRVOCandidate) {
         QualType QT = FakeNRVOCandidate->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)) {
if (!getLangOpts().CPlusPlus20 && NeedSecondOverloadResolution &&
         }
       }
     }
   }
 
   // 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;
 }
 
 /// Determine whether the declared return type of the specified function
 /// contains 'auto'.
 static bool hasDeducedReturnType(FunctionDecl *FD) {

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

-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=expected %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=expected %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx20 %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_14_17 %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_14_17 %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_14_17 %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() {
   A1 a;
   return a; // expected-error {{call to deleted constructor of 'test_delete_function::A1'}}
 }
 
 struct A2 {
   A2();
   A2(const A2 &);
 
 private:
   A2(A2 &&); // expected-note {{declared private here}}
 };
 A2 test2() {
   A2 a;
   return a; // expected-error {{calling a private constructor of class 'test_delete_function::A2'}}
 }
 
 struct C {};
 
 struct B1 {
   B1(C &);
   B1(C &&) = delete; // expected-note {{'B1' has been explicitly marked deleted here}}
 };
 B1 test3() {
   C c;
   return c; // expected-error {{conversion function from 'test_delete_function::C' to 'test_delete_function::B1' invokes a deleted function}}
 }
 
 struct B2 {
   B2(C &);
 
 private:
   B2(C &&); // expected-note {{declared private here}}
 };
 B2 test4() {
   C c;
   return c; // expected-error {{calling a private constructor of class 'test_delete_function::B2'}}
 }
 } // namespace test_delete_function
+
+// In C++20, implicitly movable entity can be rvalue reference to non-volatile
+// automatic object.
+namespace test_implicitly_movable_rvalue_ref {
+struct A1 {
+  A1(A1 &&);
+  A1(const A1 &) = delete; // cxx11_14_17-note {{'A1' has been explicitly marked deleted here}}
+};
+A1 test1(A1 &&a) {
+  return a; // cxx11_14_17-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::A1'}}
+}
+
+struct A2 {
+  A2(A2 &&);
+
+private:
+  A2(const A2 &); // cxx11_14_17-note {{declared private here}}
+};
+A2 test2(A2 &&a) {
+  return a; // cxx11_14_17-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::A2'}}
+}
+
+struct B1 {
+  B1(const B1 &);
+  B1(B1 &&) = delete; // cxx20-note {{'B1' has been explicitly marked deleted here}}
+};
+B1 test3(B1 &&b) {
+  return b; // cxx20-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::B1'}}
+}
+
+struct B2 {
+  B2(const B2 &);
+
+private:
+  B2(B2 &&); // cxx20-note {{declared private here}}
+};
+B2 test4(B2 &&b) {
+  return b; // cxx20-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::B2'}}
+}
+} // namespace test_implicitly_movable_rvalue_ref
+
+// In C++20, operand of throw-expression can be function parameter or
+// catch-clause parameter.
+namespace test_throw_parameter {
+void func();
+
+struct A1 {
+  A1(const A1 &);
+  A1(A1 &&) = delete; // cxx20-note {{'A1' has been explicitly marked deleted here}}
+};
+void test1() {
+  try {
+    func();
+  } catch (A1 a) {
+    throw a; // cxx20-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
+  }
+}
+
+struct A2 {
+  A2(const A2 &);
+
+private:
+  A2(A2 &&); // cxx20-note {{declared private here}}
+};
+void test2() {
+  try {
+    func();
+  } catch (A2 a) {
+    throw a; // cxx20-error {{calling a private constructor of class 'test_throw_parameter::A2'}}
+  }
+}
+} // namespace test_throw_parameter
+
+// In C++20, during the first overload resolution, the selected function no
+// need to be a constructor.
+namespace test_non_ctor_conversion {
+class C {};
+
+struct A1 {
+  operator C() &&;
+  operator C() const & = delete; // cxx11_14_17-note {{'operator C' has been explicitly marked deleted here}}
+};
+C test1() {
+  A1 a;
+  return a; // cxx11_14_17-error {{conversion function from 'test_non_ctor_conversion::A1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
+}
+
+struct A2 {
+  operator C() &&;
+
+private:
+  operator C() const &; // cxx11_14_17-note {{declared private here}}
+};
+C test2() {
+  A2 a;
+  return a; // cxx11_14_17-error {{'operator C' is a private member of 'test_non_ctor_conversion::A2'}}
+}
+
+struct B1 {
+  operator C() const &;
+  operator C() && = delete; // cxx20-note {{'operator C' has been explicitly marked deleted here}}
+};
+C test3() {
+  B1 b;
+  return b; // cxx20-error {{conversion function from 'test_non_ctor_conversion::B1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
+}
+
+struct B2 {
+  operator C() const &;
+
+private:
+  operator C() &&; // cxx20-note {{declared private here}}
+};
+C test4() {
+  B2 b;
+  return b; // cxx20-error {{'operator C' is a private member of 'test_non_ctor_conversion::B2'}}
+}
+} // namespace test_non_ctor_conversion
+
+// In C++20, during the first overload resolution, the first parameter of the
+// selected function no need to be an rvalue reference to the object's type.
+namespace test_ctor_param_rvalue_ref {
+struct A1;
+struct A2;
+struct B1;
+struct B2;
+
+struct NeedRvalueRef {
+  NeedRvalueRef(A1 &&);
+  NeedRvalueRef(A2 &&);
+  NeedRvalueRef(B1 &&);
+  NeedRvalueRef(B2 &&);
+};
+struct NeedValue {
+  NeedValue(A1); // cxx11_14_17-note 2 {{passing argument to parameter here}}
+  NeedValue(A2);
+  NeedValue(B1); // cxx20-note 2 {{passing argument to parameter here}}
+  NeedValue(B2);
+};
+
+struct A1 {
+  A1();
+  A1(A1 &&);
+  A1(const A1 &) = delete; // cxx11_14_17-note 3 {{'A1' has been explicitly marked deleted here}}
+};
+NeedValue test_1_1() {
+  // not rvalue reference
+  // same type
+  A1 a;
+  return a; // cxx11_14_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+}
+class DerivedA1 : public A1 {};
+A1 test_1_2() {
+  // rvalue reference
+  // not same type
+  DerivedA1 a;
+  return a; // cxx11_14_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+}
+NeedValue test_1_3() {
+  // not rvalue reference
+  // not same type
+  DerivedA1 a;
+  return a; // cxx11_14_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+}
+
+struct A2 {
+  A2();
+  A2(A2 &&);
+
+private:
+  A2(const A2 &); // cxx11_14_17-note 3 {{declared private here}}
+};
+NeedValue test_2_1() {
+  // not rvalue reference
+  // same type
+  A2 a;
+  return a; // cxx11_14_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+}
+class DerivedA2 : public A2 {};
+A2 test_2_2() {
+  // rvalue reference
+  // not same type
+  DerivedA2 a;
+  return a; // cxx11_14_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+}
+NeedValue test_2_3() {
+  // not rvalue reference
+  // not same type
+  DerivedA2 a;
+  return a; // cxx11_14_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+}
+
+struct B1 {
+  B1();
+  B1(const B1 &);
+  B1(B1 &&) = delete; // cxx20-note 3 {{'B1' has been explicitly marked deleted here}}
+};
+NeedValue test_3_1() {
+  // not rvalue reference
+  // same type
+  B1 b;
+  return b; // cxx20-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+}
+class DerivedB1 : public B1 {};
+B1 test_3_2() {
+  // rvalue reference
+  // not same type
+  DerivedB1 b;
+  return b; // cxx20-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+}
+NeedValue test_3_3() {
+  // not rvalue reference
+  // not same type
+  DerivedB1 b;
+  return b; // cxx20-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+}
+
+struct B2 {
+  B2();
+  B2(const B2 &);
+
+private:
+  B2(B2 &&); // cxx20-note 3 {{declared private here}}
+};
+NeedValue test_4_1() {
+  // not rvalue reference
+  // same type
+  B2 b;
+  return b; // cxx20-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+}
+class DerivedB2 : public B2 {};
+B2 test_4_2() {
+  // rvalue reference
+  // not same type
+  DerivedB2 b;
+  return b; // cxx20-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+}
+NeedValue test_4_3() {
+  // not rvalue reference
+  // not same type
+  DerivedB2 b;
+  return b; // cxx20-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+}
+} // namespace test_ctor_param_rvalue_ref

clang/test/SemaCXX/P1155.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=cxx20 %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=cxx11_14_17 %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=cxx11_14_17 %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=cxx11_14_17 %s
+// cxx20-no-diagnostics
+
+// Throwing
+namespace test_throwing {
+class Widget {
+public:
+  Widget(Widget &&);
+  Widget(const Widget &) = delete;
+};
+
+void seven(Widget w) {
+  throw w; // Clang already do this implicit move before -std=c++20
+}
+} // namespace test_throwing
+
+// Non-constructor conversion
+namespace test_non_constructor_conversion {
+class Widget {};
+
+struct To {
+  operator Widget() const & = delete; // cxx11_14_17-note {{'operator Widget' has been explicitly marked deleted here}}
+  operator Widget() &&;
+};
+
+Widget nine() {
+  To t;
+  return t; // cxx11_14_17-error {{conversion function from 'test_non_constructor_conversion::To' to 'test_non_constructor_conversion::Widget' invokes a deleted function}}
+}
+} // namespace test_non_constructor_conversion
+
+// By-value sinks
+namespace test_by_value_sinks {
+class Widget {
+public:
+  Widget();
+  Widget(Widget &&);
+  Widget(const Widget &) = delete; // cxx11_14_17-note {{'Widget' has been explicitly marked deleted here}}
+};
+
+struct Fowl {
+  Fowl(Widget); // cxx11_14_17-note {{passing argument to parameter here}}
+};
+
+Fowl eleven() {
+  Widget w;
+  return w; // cxx11_14_17-error {{call to deleted constructor of 'test_by_value_sinks::Widget'}}
+}
+} // namespace test_by_value_sinks
+
+// Slicing
+namespace test_slicing {
+class Base {
+public:
+  Base();
+  Base(Base &&);
+  Base(Base const &) = delete; // cxx11_14_17-note {{'Base' has been explicitly marked deleted here}}
+};
+
+class Derived : public Base {};
+
+Base thirteen() {
+  Derived result;
+  return result; // cxx11_14_17-error {{call to deleted constructor of 'test_slicing::Base'}}
+}
+} // namespace test_slicing

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

-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -Wreturn-std-move-in-c++11 -std=c++14 -verify %s
-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -Wreturn-std-move-in-c++11 -std=c++14 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++20 -verify=cxx20 %s
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++17 -verify=expected %s
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++14 -verify=expected %s
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++11 -verify=expected %s
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++17 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++14 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++11 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
 
 // definitions for std::move
 namespace std {
 inline namespace foo {
 template <class T> struct remove_reference { typedef T type; };
-template <class T> struct remove_reference<T&> { typedef T type; };
-template <class T> struct remove_reference<T&&> { typedef T type; };
+template <class T> struct remove_reference<T &> { typedef T type; };
+template <class T> struct remove_reference<T &&> { typedef T type; };
 
 template <class T> typename remove_reference<T>::type &&move(T &&t);
 } // namespace foo
 } // namespace std
 
 struct Instrument {
     Instrument() {}
     Instrument(Instrument&&) { /* MOVE */ }

 Base test2() {
     Derived d2;
     return d2;  // e1
     // expected-warning@-1{{will be copied despite being returned by name}}
     // expected-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d2)"
 }
 ConstructFromDerived test3() {
-    Derived d3;
-    return d3;  // e2-cxx11
-    // expected-warning@-1{{would have been copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying on older compilers}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d3)"
+  return d3; // ok
 }
 ConstructFromBase test4() {
     Derived d4;
     return d4;  // e3
     // expected-warning@-1{{will be copied despite being returned by name}}
     // expected-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d4)"
 }
 ConvertFromDerived test5() {
     Derived d5;
     return d5;  // e4
     // expected-warning@-1{{will be copied despite being returned by name}}
     // expected-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d5)"
 }

 Derived testParam1(Derived d) { return d; }
 Base testParam2(Derived d) {
     return d;  // e6
     // expected-warning@-1{{will be copied despite being returned by name}}
     // expected-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConstructFromDerived testParam3(Derived d) {
-    return d;  // e7-cxx11
-    // expected-warning@-1{{would have been copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying on older compilers}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
+  return d; // ok
 }
 ConstructFromBase testParam4(Derived d) {
     return d;  // e8
     // expected-warning@-1{{will be copied despite being returned by name}}
     // expected-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConvertFromDerived testParam5(Derived d) {
ConvertFromBase testRParam6(Derived&& d) {
     // expected-warning@-1{{will be copied despite being returned by name}}
     // expected-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; }
+#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;
     return (d);  // e17
     // expected-warning@-1{{will be copied despite being returned by name}}
     // expected-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:15}:"std::move(d)"
 }
 ConstructFromDerived testParens2() {
-    Derived d;
-    return (d);  // e18-cxx11
-    // expected-warning@-1{{would have been copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:15}:"std::move(d)"
+  return (d); // ok
 }
 
-
 // If the target is a catch-handler parameter, do apply the diagnostic.
 void throw_derived();
 Derived testEParam1() {
     try { throw_derived(); } catch (Derived d) { return d; }  // e19
     // expected-warning@-1{{will be copied despite being returned by name}}
     // expected-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
     __builtin_unreachable();

 void ok_throw5(Derived &d) { throw std::move(d); }
 void ok_throw6(Derived &d) { throw static_cast<Derived &&>(d); }
 void ok_throw7(TriviallyCopyable d) { throw d; }
 void ok_throw8(OnlyCopyable d) { throw d; }
 
 namespace test_delete {
 struct Base {
   Base();
-  Base(Base &&) = delete;
+  Base(Base &&) = delete; // cxx20-note {{'Base' has been explicitly marked deleted here}}
   Base(Base const &);
 };
 
 struct Derived : public Base {};
 
 Base test_ok() {
   Derived d;
-  return d;
+  return d; // cxx20-error {{call to deleted constructor of 'test_delete::Base'}}
 }
 } // namespace test_delete

clang/www/cxx_status.html

<tr>
     <th>Available in Clang?</th>
  </tr>
      <tr>
       <td rowspan="2">Rvalue references</td>
       <td><a href="https://wg21.link/n2118">N2118</a></td>
       <td class="full" align="center">Clang 2.9</td>
       <tr> <!-- from Kona 2019-->
         <td><a href="https://wg21.link/p1825r0">P1825R0</a> (<a href="#dr">DR</a>)</td>
-        <td class="none" align="center">No</td>
+        <td class="unreleased" align="center">Clang 13</td>
       </tr>
     </tr>
     <tr>
       <td>&nbsp;&nbsp;&nbsp;&nbsp;Rvalue references for <code>*this</code></td>
       <td><a href="https://wg21.link/n2439">N2439</a></td>
       <td class="full" align="center">Clang 2.9</td>
     </tr>
     <tr>
<tr>
       <td class="full" align="center">Clang 10</td>
     </tr>
     <!-- Prague 2019 papers -->
     <tr>
       <td>Pseudo-destructors end object lifetimes</td>
       <td><a href="https://wg21.link/p0593r6">P0593R6</a> (<a href="#dr">DR</a>)</td>
       <td class="unreleased" align="center">Clang 11</td>
     </tr>
+    <tr>
+      <td>More implicit moves</td>
+      <td><a href="https://wg21.link/p1825r0">P1825R0</a> (<a href="#dr">DR</a>)</td>
+      <td class="unreleased" align="center">Clang 13</td>
+    </tr>
 </table>
 
 <p>
 <span id="p0482">(11): Prior to Clang 8, this feature is not enabled by
 <tt>-std=c++20</tt>, but can be enabled with <tt>-fchar8_t</tt>.
 </span>
 </p>
 </details>