[clang] Apply P1825 as Defect Report from C++11 up to C++20.

[mizvekov]

Summary

This extends the effects of P1825 to all C++ standards from C++11 up to C++20.

According to Motion 23 from Cologne 2019, P1825R0 was accepted as a Defect Report, so we retroactively apply this all the way back to C++11.

Note that we also remove implicit moves from C++98 as an extension
altogether, since the expanded first overload resolution from P1825
can cause some meaning changes in C++98.
For example it can change which copy constructor is picked when both const
and non-const ones are available.

This also rips out warn_return_std_move since there are no cases where it would be worthwhile to suggest it.

This also fixes a bug with bailing into the second overload resolution
when encountering a non-rvref qualified conversion operator.
This was unnoticed until now, so two new test cases cover these.

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

[mizvekov]

set parent revision.

[mizvekov]

rebase.

[• Quuxplusone]

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

58–60

Personally, I don't think the world will accept applying P0527 unconditionally in pre-C++20 modes. But I guess we'll find out. :P

[lebedev.ri]

Patch is missing description

[mizvekov]

In D104500#2827629, @lebedev.ri wrote:

Patch is missing description

Yes sorry for the noise, I do that sometimes just to let the bots test my patch before it is fully ready for review.
If you have any tips for me so I can upload a diff and have it tested, without having to create the DR for it, would appreciate.

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

58–60

Indeed :)
By the way, I have not found a counter example of strict C++98 code (not using extensions) breaking with implicit moves enabled.
So it looks like we can have one mode for everything here.

[mizvekov]

rip out warn_return_std_move completely.

[mizvekov]

lint.

[mizvekov]

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

58–60

Oh never mind I was wrong :)

Found your example: https://godbolt.org/z/T374o518W

Too bad we had not put it in our test suite.

[mizvekov]

Don't apply implicit moves to C++98, and add tests which demonstrate incompatibilities this would cause.

[mizvekov]

format.

[mizvekov]

tests: improve consistency of expcted messages..

[mizvekov]

.

[mizvekov]

remove unnecessary qualification.

[mizvekov]

Simplify checking first overload reslution result.

[rsmith]

clang/lib/Sema/SemaStmt.cpp

3532

Looks like you lost a word in this comment.

3540–3543

Is the removal of this check for an rvalue ref qualifier a bugfix? If so, please add a test. I suppose it would look something like this:

struct B;
struct A { A(B&) = delete; };
struct B { operator A(); };
A f() { B b; return b; }

... which would be ambiguous if we don't implicitly convert to xvalue, but if we do, it selects a conversion function that is not rvalue-ref-qualified.

[mizvekov]

clang/lib/Sema/SemaStmt.cpp

3540–3543

Yeah you are right. I was reading that section of the standard again in bed to try to get some sleep, and it suddenly clicked me that we were just supposed to be doing that first overload resolution with the expression as an xvalue and that is it. There was no reason to be anything else in there.
I just could not resist the urge to get up and fix it thought :)
I'll leave the test case for tomorrow though!

[mizvekov]

This introduces two new test cases that cover the bug fixed by the previous diff:

• The one suggested by rsmith in the comments above.
• Another one that shows that when both const and non-const lvref conversion operators where available, we would not pick the const one on the first overload resolution, and end up picking the non-const one on the second.

Trying to think of explanations of how we got this bug in the first place,
I think it boils down to the fact that the first overload resolution was
jerry-rigged into (trying to, unsuccessfully) bailing out in cases where it
would have succceeded without the xvalueness of the expression mattering, and
so the second overload would have hopefully done the same operation, without
affecting the meaning of the program.

The reason for this was diagnostics, it was necessary to get information on whether
casting the expression to rvref would have helped in order to implement the std-move
suggestions. As specified in the standard, the first overload resolution would often
just succeed where it would not have made a difference if the cast was there or not.

[mizvekov]

clang/lib/Sema/SemaStmt.cpp

3544

If there was a IsDiagnosticsCheck && check here just as there is above for the constructor case, this bug could have been confined to a diagnostic issue only.

[mizvekov]

format

[rsmith]

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

434

The "{{is ambiguous}}" here is not part of the expected-error and will be ignored. If you want to ignore the text in between those two strings, you can do that with // cxx98-error-re {{conversion {{.*}} is ambiguous}} or similar. (The -re enables regular expression checking, and the nested {{...}} switches to regular expression matching rather than literal matching.)

[mizvekov]

• fix test diagnostic expectation using regular expressions.

[jyknight]

This commit seems to have broken libc++ in C++98 mode, as it appears to have depended upon the implicit-move extension.

Reproduction is simple. Build this with -stdlib=libc++ -std=c++98:

#include <set>
void foo (std::set<int> *s) {
   s->insert(5);
}

(https://godbolt.org/z/vKWKhE34x)

The root cause appears to be that libc++ emulates unique_ptr in c++98 mode, and this emulation stopped working. E.g. this no longer works (compiled with same flags):

#include <memory>
std::unique_ptr<int> foo() {
  std::unique_ptr<int> x;
  return x;
}

To simplify further, removing the stdlib headers: returning a type with a move constructor but no copy constructor used to work, and now doesn't (with -std=c++98).

struct uncopyable {
  uncopyable() = default;
  uncopyable(uncopyable const&) = delete;
  uncopyable(uncopyable&&) = default;
};
uncopyable bar() {
  uncopyable x;
  return x;
}

Now, of course, the above is invalid c++98, because rvalue references aren't even a thing there...but clang _does_ implement rvalue references in c++98 mode, and libc++ depends on it.

So -- I think either libc++ needs to stop depending on this nonstandard functionality, or we need to keep implementing it in Clang. I don't know which option would be more desirable.

CC+=ldionne, for libc++ expertise.

[mizvekov]

In D104500#2863368, @jyknight wrote:

This commit seems to have broken libc++ in C++98 mode, as it appears to have depended upon the implicit-move extension.

The root cause appears to be that libc++ emulates unique_ptr in c++98 mode, and this emulation stopped working.

Thank you for the report!

It's not that hard, right now, to put that support back in.
But with C++11 up to C++20 sharing the same code, this is a lot of burden to have yet another implicit move mechanism just for C++98.

AFAIK, rvalue references in C++98 is a clang-only thing, none of the other C++ compilers implement this extension.
And this was also never officially supported, it is a best effort kind of deal.

And I think libc++ is in the process of ditching support for C++98 completely, though I might be mistaken about the extent here.

[• Quuxplusone]

In D104500#2864909, @mizvekov wrote:

In D104500#2863368, @jyknight wrote:

This commit seems to have broken libc++ in C++98 mode, as it appears to have depended upon the implicit-move extension.
The root cause appears to be that libc++ emulates unique_ptr in c++98 mode, and this emulation stopped working.

It's not that hard, right now, to put that support back in.
But with C++11 up to C++20 sharing the same code, this is a lot of burden to have yet another implicit move mechanism just for C++98.

@mizvekov, I don't understand what you mean by "yet another" mechanism. This is just asking to restore Clang's C++98/03 extension (that supports move constructors even in C++03). It's asking to remove special-case code you added, right? Find the line where you're saying "oh but if it's C++03 then don't do the usual rvalue lookup," and remove that.

My naive guess is line 3459:

if (getLangOpts().CPlusPlus11 && !getLangOpts().CPlusPlus2b &&
    NRInfo.isMoveEligible()) {

should maybe be just

if (!getLangOpts().CPlusPlus2b && NRInfo.isMoveEligible()) {

Could you look into that?

And I think libc++ is in the process of ditching support for C++98 completely, though I might be mistaken about the extent here.

Nope, untrue. I've been making some patches to ditch libc++'s _LIBCPP_CXX03_LANG macro, but I'm doing that precisely because the only compiler we support in C++03 mode is Clang, and on Clang we can actually use rvalue references and variadic templates and so on, even in C++03 mode. That is, this extension (that was broken by this patch) is actually the only reason libc++ works in C++03 mode at all! So it's important to preserve the extension. (And presumably there might be clients relying on the extension, besides just libc++.)

[mizvekov]

In D104500#2865849, @Quuxplusone wrote:

@mizvekov, I don't understand what you mean by "yet another" mechanism. This is just asking to restore Clang's C++98/03 extension (that supports move constructors even in C++03). It's asking to remove special-case code you added, right? Find the line where you're saying "oh but if it's C++03 then don't do the usual rvalue lookup," and remove that.

My naive guess is line 3459:

if (getLangOpts().CPlusPlus11 && !getLangOpts().CPlusPlus2b &&
    NRInfo.isMoveEligible()) {

should maybe be just

if (!getLangOpts().CPlusPlus2b && NRInfo.isMoveEligible()) {

Could you look into that?

With that change, you get the full P1825 implicit move in C++98, which modifies the semantics of pure C++98 programs.
Like I said in the commit message, this can change which copy constructor is picked, between non-const and const ones.

To continue supporting C++98, we would need to keep the old C++11 implicit move code around.

And I think libc++ is in the process of ditching support for C++98 completely, though I might be mistaken about the extent here.

Nope, untrue. I've been making some patches to ditch libc++'s _LIBCPP_CXX03_LANG macro, but I'm doing that precisely because the only compiler we support in C++03 mode is Clang, and on Clang we can actually use rvalue references and variadic templates and so on, even in C++03 mode. That is, this extension (that was broken by this patch) is actually the only reason libc++ works in C++03 mode at all! So it's important to preserve the extension. (And presumably there might be clients relying on the extension, besides just libc++.)

Well I thought that meant exactly that libc++ does not support C++98, it only works on clang because it provides so much of C++11 as an extension.

I did not remove this just on my own whim by the way, the information I had and the reason the patch was approved as is, is because as I said, those extensions were considered best effort and not officially supported.
@rsmith thoughts?

[rsmith]

In D104500#2865917, @mizvekov wrote:

In D104500#2865849, @Quuxplusone wrote:

@mizvekov, I don't understand what you mean by "yet another" mechanism. This is just asking to restore Clang's C++98/03 extension (that supports move constructors even in C++03). It's asking to remove special-case code you added, right? Find the line where you're saying "oh but if it's C++03 then don't do the usual rvalue lookup," and remove that.

My naive guess is line 3459:

if (getLangOpts().CPlusPlus11 && !getLangOpts().CPlusPlus2b &&
    NRInfo.isMoveEligible()) {

should maybe be just

if (!getLangOpts().CPlusPlus2b && NRInfo.isMoveEligible()) {

Could you look into that?

With that change, you get the full P1825 implicit move in C++98, which modifies the semantics of pure C++98 programs.
Like I said in the commit message, this can change which copy constructor is picked, between non-const and const ones.

To continue supporting C++98, we would need to keep the old C++11 implicit move code around.

And I think libc++ is in the process of ditching support for C++98 completely, though I might be mistaken about the extent here.

Nope, untrue. I've been making some patches to ditch libc++'s _LIBCPP_CXX03_LANG macro, but I'm doing that precisely because the only compiler we support in C++03 mode is Clang, and on Clang we can actually use rvalue references and variadic templates and so on, even in C++03 mode. That is, this extension (that was broken by this patch) is actually the only reason libc++ works in C++03 mode at all! So it's important to preserve the extension. (And presumably there might be clients relying on the extension, besides just libc++.)

Well I thought that meant exactly that libc++ does not support C++98, it only works on clang because it provides so much of C++11 as an extension.

I did not remove this just on my own whim by the way, the information I had and the reason the patch was approved as is, is because as I said, those extensions were considered best effort and not officially supported.
@rsmith thoughts?

I wonder if we can restore the extension behavior for the types that want it, while still using the C++98 rules for the rest of the cases? Perhaps we could use the new C++11-to-C++20 logic even in C++98 if the return type declares a move constructor?

[mizvekov]

In D104500#2866079, @rsmith wrote:

I wonder if we can restore the extension behavior for the types that want it, while still using the C++98 rules for the rest of the cases? Perhaps we could use the new C++11-to-C++20 logic even in C++98 if the return type declares a move constructor?

Well if we want to keep supporting it, then my plan would be:

It comes back, but it's not exactly the same "C++98 implicit moves" that you used to know, it now has a few cybernetic enhancements:

• As far as the rules of what id-expressions are considered move eligible, we keep the same ones as C++20 has. The old one used to apply only to the subset where we can do copy elision.
• We jerry rig the first overload resolution, by iterating the construction steps and aborting it in case we pick a constructor or conversion operator which does not take an rvalue reference.

I think this way would be a balance where we don't add back too much code, but at the same time we keep compatibility with pure C++98 programs. I think this is in line with the idea of best effort.

Though if I may suggest, if we ever hope to sunset C++98, then to stop providing these C++11 extensions would be a good first step...

[ldionne]

In D104500#2865917, @mizvekov wrote:

Well I thought that meant exactly that libc++ does not support C++98, it only works on clang because it provides so much of C++11 as an extension.

I did not remove this just on my own whim by the way, the information I had and the reason the patch was approved as is, is because as I said, those extensions were considered best effort and not officially supported.
@rsmith thoughts?

I don't know what the state of those extensions is from Clang's perspective, however one thing is clear - we use those extensions in libc++ very heavily. If any such extension is removed, libc++ will stop working in C++03 mode, which effectively means that most of the code compiled with Clang is going to break. That's a pretty serious problem.

In D104500#2866103, @mizvekov wrote:

Though if I may suggest, if we ever hope to sunset C++98, then to stop providing these C++11 extensions would be a good first step...

Yes, I agree those extensions are terrible. However, libc++ has supported C++11 library features with an approximative C++03 language mode ever since it was created. Removing support for something as fundamental as std::unique_ptr in C++03 mode is likely going to break a huge number of things, so we can't really do that. If there is a desire to sunset C++03, I could get behind that, but it would be an effort on its own and I don't think reducing what C++11 features we implement in C++03 mode would be part of that.

In the summary, you say:

Note that we also remove implicit moves from C++98 as an extension altogether, since the expanded first overload resolution from P1825 can cause some meaning changes in C++98. For example it can change which copy constructor is picked when both const and non-const ones are available.

So basically, you decided to downright remove the extension because it caused some code to change meaning? However, in doing so, all the code that was previously moving implicitly will now perform a copy instead (unless the copy constructor is deleted, in which case the code breaks, as in libc++). That's a pretty big behavior change. Is that accurate, or am I misunderstanding something?

[mizvekov]

In D104500#2867404, @ldionne wrote:

I don't know what the state of those extensions is from Clang's perspective, however one thing is clear - we use those extensions in libc++ very heavily. If any such extension is removed, libc++ will stop working in C++03 mode, which effectively means that most of the code compiled with Clang is going to break. That's a pretty serious problem.

That was not clear from the clang side, we had those extensions as non officially supported.
Now since another project under the same umbrella depends on it, it makes sense to continue supporting this, at least until we agree on something else.

So basically, you decided to downright remove the extension because it caused some code to change meaning? However, in doing so, all the code that was previously moving implicitly will now perform a copy instead (unless the copy constructor is deleted, in which case the code breaks, as in libc++). That's a pretty big behavior change. Is that accurate, or am I misunderstanding something?

Well, considering from my perspective, which had those extensions as not officially supported and "best effort" only, it would make sense not to provide an extension which can break pure C++98 programs.
The options where:

1. DR P1825 down to C++11 as the comittee decided, but get almost no benefit from implementation complexity because we would still have to keep most of the code around, but this time only for C++98 (which is not even supposed to have it).
2. Leave C++98 without implicit moves. This gives following benefits:
   • Drop huge amount of code, almost no new code.
   • Pure C++98 programs don't get broken.
   • Less work, I can spend more time doing other things.
3. DR P1825 down to C++98. This gives almost all the benefits from the option above, except that has risk of breaking valid C++98 code.
4. Invent yet another implicit move rule.

We tried 2, and failed here.
Number 3 would be cool if we could get away with it, but I don't know if we should take the chances.
So I present my take on option 4: https://reviews.llvm.org/D105756

clang/include/clang/Sema/Sema.h

struct NamedReturnInfo {
 
     enum Status : uint8_t { None, MoveEligible, MoveEligibleAndCopyElidable };
     Status S;
 
     bool isMoveEligible() const { return S != None; };
     bool isCopyElidable() const { return S == MoveEligibleAndCopyElidable; }
   };
   NamedReturnInfo getNamedReturnInfo(Expr *&E, bool ForceCXX2b = false);
-  NamedReturnInfo getNamedReturnInfo(const VarDecl *VD,
-                                     bool ForceCXX20 = false);
+  NamedReturnInfo getNamedReturnInfo(const VarDecl *VD);
   const VarDecl *getCopyElisionCandidate(NamedReturnInfo &Info,
                                          QualType ReturnType);
 
   ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
                                              const NamedReturnInfo &NRInfo,
                                              Expr *Value);
 
   StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,

clang/lib/Sema/SemaStmt.cpp

Sema::NamedReturnInfo Sema::getNamedReturnInfo(Expr *&E, bool ForceCXX2b) {
   // - in a return statement in a function [where] ...
   // ... the expression is the name of a non-volatile automatic object ...
   const auto *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
   if (!DR || DR->refersToEnclosingVariableOrCapture())
     return NamedReturnInfo();
   const auto *VD = dyn_cast<VarDecl>(DR->getDecl());
   if (!VD)
     return NamedReturnInfo();
-  NamedReturnInfo Res = getNamedReturnInfo(VD, /*ForceCXX20=*/ForceCXX2b);
+  NamedReturnInfo Res = getNamedReturnInfo(VD);
   if (Res.Candidate && !E->isXValue() &&
       (ForceCXX2b || getLangOpts().CPlusPlus2b)) {
     E = ImplicitCastExpr::Create(Context, VD->getType().getNonReferenceType(),
                                  CK_NoOp, E, nullptr, VK_XValue,
                                  FPOptionsOverride());
   }
   return Res;
 }
 
-/// Updates the status in the given NamedReturnInfo object to disallow
-/// copy elision, and optionally also implicit move.
-///
-/// \param Info The NamedReturnInfo object to update.
-///
-/// \param CanMove If true, disallow only copy elision.
-/// If false, also disallow implcit move.
-static void disallowNRVO(Sema::NamedReturnInfo &Info, bool CanMove) {
-  Info.S = std::min(Info.S, CanMove ? Sema::NamedReturnInfo::MoveEligible
-                                    : Sema::NamedReturnInfo::None);
-}
-
 /// Determine whether the given NRVO candidate variable is move-eligible or
 /// copy-elidable, without considering function return type.
 ///
 /// \param VD The NRVO candidate variable.
 ///
-/// \param ForceCXX20 Overrides detection of current language mode
-/// and uses the rules for C++20.
-///
 /// \returns An aggregate which contains the Candidate and isMoveEligible
 /// and isCopyElidable methods. If Candidate is non-null, it means
 /// isMoveEligible() would be true under the most permissive language standard.
-Sema::NamedReturnInfo Sema::getNamedReturnInfo(const VarDecl *VD,
-                                               bool ForceCXX20) {
-  bool hasCXX11 = getLangOpts().CPlusPlus11 || ForceCXX20;
-  bool hasCXX20 = getLangOpts().CPlusPlus20 || ForceCXX20;
+Sema::NamedReturnInfo Sema::getNamedReturnInfo(const VarDecl *VD) {
   NamedReturnInfo Info{VD, NamedReturnInfo::MoveEligibleAndCopyElidable};
 
   // C++20 [class.copy.elision]p3:
   // - in a return statement in a function with ...
   // (other than a function ... parameter)
   if (VD->getKind() == Decl::ParmVar)
-    disallowNRVO(Info, hasCXX11);
+    Info.S = Sema::NamedReturnInfo::MoveEligible;
   else if (VD->getKind() != Decl::Var)
     return NamedReturnInfo();
 
   // (other than ... a catch-clause parameter)
   if (VD->isExceptionVariable())
-    disallowNRVO(Info, hasCXX20);
+    Info.S = Sema::NamedReturnInfo::MoveEligible;
 
   // ...automatic...
   if (!VD->hasLocalStorage())
     return NamedReturnInfo();
 
   // 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 NamedReturnInfo();
 
   QualType VDType = VD->getType();
   if (VDType->isObjectType()) {
     // C++17 [class.copy.elision]p3:
     // ...non-volatile automatic object...
     if (VDType.isVolatileQualified())
       return NamedReturnInfo();
   } 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...
     QualType VDReferencedType = VDType.getNonReferenceType();
     if (VDReferencedType.isVolatileQualified() ||
         !VDReferencedType->isObjectType())
       return NamedReturnInfo();
-    disallowNRVO(Info, hasCXX20);
+    Info.S = Sema::NamedReturnInfo::MoveEligible;
   } else {
     return NamedReturnInfo();
   }
 
   // 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))
-    disallowNRVO(Info, hasCXX11);
+    Info.S = Sema::NamedReturnInfo::MoveEligible;
 
   return Info;
 }
 
 /// Updates given NamedReturnInfo's move-eligible and
 /// copy-elidable statuses, considering the function
 /// return type criteria as applicable to return statements.
 ///
if (!ReturnType->isDependentType()) {
     if (!ReturnType->isRecordType())
       return invalidNRVO();
 
     QualType VDType = Info.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))
-      disallowNRVO(Info, getLangOpts().CPlusPlus11);
+      Info.S = Sema::NamedReturnInfo::MoveEligible;
   }
   return Info.isCopyElidable() ? Info.Candidate : nullptr;
 }
 
 /// 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.
 ///
-/// \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
 /// overload resolution fails, or if the first overload resolution succeeds but
 /// the selected constructor/operator doesn't match the additional criteria, we
 /// need to do the second overload resolution.
 static bool TryMoveInitialization(Sema &S, const InitializedEntity &Entity,
                                   const VarDecl *NRVOCandidate, Expr *&Value,
-                                  bool ConvertingConstructorsOnly,
-                                  bool IsDiagnosticsCheck, ExprResult &Res) {
+                                  ExprResult &Res) {
   ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack, Value->getType(),
                             CK_NoOp, Value, VK_XValue, FPOptionsOverride());
 
   Expr *InitExpr = &AsRvalue;
 
   InitializationKind Kind = InitializationKind::CreateCopy(
       Value->getBeginLoc(), Value->getBeginLoc());
 
   InitializationSequence Seq(S, Entity, Kind, InitExpr);
+  if (!Seq && Seq.getFailedOverloadResult() != OR_Deleted)
+    return true;
 
   bool NeedSecondOverloadResolution = true;
-  if (!Seq &&
-      (IsDiagnosticsCheck || Seq.getFailedOverloadResult() != OR_Deleted)) {
-    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:
-        // 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 (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;
-      }
-    }
 
     NeedSecondOverloadResolution = false;
     // Promote "AsRvalue" to the heap, since we now need this
     // expression node to persist.
     Value =
         ImplicitCastExpr::Create(S.Context, Value->getType(), CK_NoOp, Value,
                                  nullptr, VK_XValue, FPOptionsOverride());
 

 /// 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 NamedReturnInfo &NRInfo,
                                       Expr *Value) {
 
-  if (NRInfo.Candidate && !getLangOpts().CPlusPlus2b) {
-    if (NRInfo.isMoveEligible()) {
-      ExprResult Res;
-      if (!TryMoveInitialization(*this, Entity, NRInfo.Candidate, Value,
-                                 !getLangOpts().CPlusPlus20, false, Res))
-        return Res;
-    }
-    if (!getDiagnostics().isIgnored(diag::warn_return_std_move,
-                                    Value->getExprLoc())) {
-      QualType QT = NRInfo.Candidate->getType();
-      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, NRInfo.Candidate, FakeValue, false,
-                              true, FakeRes);
-        if (!FakeRes.isInvalid()) {
-          bool IsThrow = (Entity.getKind() == InitializedEntity::EK_Exception);
-          SmallString<32> Str;
-          Str += "std::move(";
-          Str += NRInfo.Candidate->getDeclName().getAsString();
-          Str += ")";
-          Diag(Value->getExprLoc(), diag::warn_return_std_move)
-              << Value->getSourceRange() << NRInfo.Candidate->getDeclName()
-              << IsThrow;
-          Diag(Value->getExprLoc(), diag::note_add_std_move)
-              << FixItHint::CreateReplacement(Value->getSourceRange(), Str);
-        }
-      }
-    }
-  }
+  if (!getLangOpts().CPlusPlus2b && NRInfo.isMoveEligible()) {
+    if (!TryMoveInitialization(*this, Entity, NRInfo.Candidate, Value, Res))
 
   // 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.
   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,
                                          NamedReturnInfo &NRInfo) {
   // 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());

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,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
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=expected,cxx2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_20 %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,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() {

 }
 } // 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_17-note {{'A1' has been explicitly marked deleted here}}
+  A1(const A1 &) = delete;
 };
 A1 test1(A1 &&a) {
-  return a; // cxx11_17-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::A1'}}
+  return a;
 }
 
 struct A2 {
   A2(A2 &&);
 
 private:
-  A2(const A2 &); // cxx11_17-note {{declared private here}}
+  A2(const A2 &);
 };
 A2 test2(A2 &&a) {
-  return a; // cxx11_17-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::A2'}}
+  return a;
 }
 
 struct B1 {
   B1(const B1 &);
-  B1(B1 &&) = delete; // cxx20_2b-note {{'B1' has been explicitly marked deleted here}}
+  B1(B1 &&) = delete; // expected-note {{'B1' has been explicitly marked deleted here}}
 };
 B1 test3(B1 &&b) {
-  return b; // cxx20_2b-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::B1'}}
+  return b; // expected-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::B1'}}
 }
 
 struct B2 {
   B2(const B2 &);
 
 private:
-  B2(B2 &&); // cxx20_2b-note {{declared private here}}
+  B2(B2 &&); // expected-note {{declared private here}}
 };
 B2 test4(B2 &&b) {
-  return b; // cxx20_2b-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::B2'}}
+  return b; // expected-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_2b-note {{'A1' has been explicitly marked deleted here}}
-  // expected-note@-1 {{'A1' has been explicitly marked deleted here}}
+  A1(A1 &&) = delete; // expected-note 2{{'A1' has been explicitly marked deleted here}}
 };
 void test1() {
   try {
     func();
   } catch (A1 a) {
-    throw a; // cxx20_2b-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
+    throw a; // expected-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
   }
 }
 
 struct A2 {
   A2(const A2 &);
 
 private:
-  A2(A2 &&); // cxx20_2b-note {{declared private here}}
+  A2(A2 &&); // expected-note {{declared private here}}
 };
 void test2() {
   try {
     func();
   } catch (A2 a) {
-    throw a; // cxx20_2b-error {{calling a private constructor of class 'test_throw_parameter::A2'}}
+    throw a; // expected-error {{calling a private constructor of class 'test_throw_parameter::A2'}}
   }
 }
 
 void test3(A1 a) try {
   func();
 } catch (...) {
   throw a; // expected-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
 }
 } // 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_17-note {{'operator C' has been explicitly marked deleted here}}
+  operator C() const & = delete;
 };
 C test1() {
   A1 a;
-  return a; // cxx11_17-error {{conversion function from 'test_non_ctor_conversion::A1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
+  return a;
 }
 
 struct A2 {
   operator C() &&;
 
 private:
-  operator C() const &; // cxx11_17-note {{declared private here}}
+  operator C() const &;
 };
 C test2() {
   A2 a;
-  return a; // cxx11_17-error {{'operator C' is a private member of 'test_non_ctor_conversion::A2'}}
+  return a;
 }
 
 struct B1 {
   operator C() const &;
-  operator C() && = delete; // cxx20_2b-note {{'operator C' has been explicitly marked deleted here}}
+  operator C() && = delete; // expected-note {{'operator C' has been explicitly marked deleted here}}
 };
 C test3() {
   B1 b;
-  return b; // cxx20_2b-error {{conversion function from 'test_non_ctor_conversion::B1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
+  return b; // expected-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_2b-note {{declared private here}}
+  operator C() &&; // expected-note {{declared private here}}
 };
 C test4() {
   B2 b;
-  return b; // cxx20_2b-error {{'operator C' is a private member of 'test_non_ctor_conversion::B2'}}
+  return b; // expected-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_17-note 2 {{passing argument to parameter here}}
+  NeedValue(A1);
   NeedValue(A2);
-  NeedValue(B1); // cxx20_2b-note 2 {{passing argument to parameter here}}
+  NeedValue(B1); // expected-note 2 {{passing argument to parameter here}}
   NeedValue(B2);
 };
 
 struct A1 {
   A1();
   A1(A1 &&);
-  A1(const A1 &) = delete; // cxx11_17-note 3 {{'A1' has been explicitly marked deleted here}}
+  A1(const A1 &) = delete;
 };
 NeedValue test_1_1() {
   // not rvalue reference
   // same type
   A1 a;
-  return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+  return a;
 }
 class DerivedA1 : public A1 {};
 A1 test_1_2() {
   // rvalue reference
   // not same type
   DerivedA1 a;
-  return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+  return a;
 }
 NeedValue test_1_3() {
   // not rvalue reference
   // not same type
   DerivedA1 a;
-  return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+  return a;
 }
 
 struct A2 {
   A2();
   A2(A2 &&);
 
 private:
-  A2(const A2 &); // cxx11_17-note 3 {{declared private here}}
+  A2(const A2 &);
 };
 NeedValue test_2_1() {
   // not rvalue reference
   // same type
   A2 a;
-  return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+  return a;
 }
 class DerivedA2 : public A2 {};
 A2 test_2_2() {
   // rvalue reference
   // not same type
   DerivedA2 a;
-  return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+  return a;
 }
 NeedValue test_2_3() {
   // not rvalue reference
   // not same type
   DerivedA2 a;
-  return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+  return a;
 }
 
 struct B1 {
   B1();
   B1(const B1 &);
-  B1(B1 &&) = delete; // cxx20_2b-note 3 {{'B1' has been explicitly marked deleted here}}
+  B1(B1 &&) = delete; // expected-note 3 {{'B1' has been explicitly marked deleted here}}
 };
 NeedValue test_3_1() {
   // not rvalue reference
   // same type
   B1 b;
-  return b; // cxx20_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+  return b; // expected-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_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+  return b; // expected-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_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+  return b; // expected-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
 }
 
 struct B2 {
   B2();
   B2(const B2 &);
 
 private:
-  B2(B2 &&); // cxx20_2b-note 3 {{declared private here}}
+  B2(B2 &&); // expected-note 3 {{declared private here}}
 };
 NeedValue test_4_1() {
   // not rvalue reference
   // same type
   B2 b;
-  return b; // cxx20_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+  return b; // expected-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_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+  return b; // expected-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_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+  return b; // expected-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
 }
 } // namespace test_ctor_param_rvalue_ref
 
 namespace test_lvalue_ref_is_not_moved_from {
 
 struct Target {};
   // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable}}
   // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}}
-  // cxx11_17-note@-3 {{candidate constructor (the implicit copy constructor) not viable}}
-  // cxx11_17-note@-4 {{candidate constructor (the implicit move constructor) not viable}}
 
 struct CopyOnly {
-  CopyOnly(CopyOnly&&) = delete; // cxx20_2b-note {{has been explicitly marked deleted here}}
+  CopyOnly(CopyOnly&&) = delete; // expected-note {{has been explicitly marked deleted here}}
   CopyOnly(CopyOnly&);
-  operator Target() && = delete; // cxx20_2b-note {{has been explicitly marked deleted here}}
+  operator Target() && = delete; // expected-note {{has been explicitly marked deleted here}}
   operator Target() &;
 };
 
 struct MoveOnly {
   MoveOnly(MoveOnly&&); // expected-note {{copy constructor is implicitly deleted because}}
-    // cxx11_17-note@-1 {{copy constructor is implicitly deleted because}}
   operator Target() &&; // expected-note {{candidate function not viable}}
-    // cxx11_17-note@-1 {{candidate function not viable}}
 };
 
 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}}
+    return r; // expected-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}}
+    return r;
 }
 
 Target t5() {
     CopyOnly& r = copyonly;
     return r;
 }
 
 Target t6() {
     CopyOnly&& r = static_cast<CopyOnly&&>(copyonly);
-    return r; // cxx20_2b-error {{invokes a deleted function}}
+    return r; // expected-error {{invokes a deleted function}}
 }
 
 Target t7() {
     MoveOnly& r = moveonly;
     return r; // expected-error {{no viable conversion}}
 }
 
 Target t8() {
     MoveOnly&& r = static_cast<MoveOnly&&>(moveonly);
-    return r; // cxx11_17-error {{no viable conversion}}
+    return r;
 }
 
 } // namespace test_lvalue_ref_is_not_moved_from
 
 namespace test_rvalue_ref_to_nonobject {
 
 struct CopyOnly {};
 struct MoveOnly {};
if (b) {
     return w2; // cxx2b-error {{no matching constructor for initialization}}
   }
 }
 
 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 &&); // cxx11_20-note {{in instantiation of function template specialization}}
 
 MoveOnly &&test4() {
   MoveOnly &&x = rref();
   return x; // cxx11_20-error {{cannot bind to lvalue of type}}
 }
 
 void test5() try {
   CopyOnly x;
   throw x; // cxx2b-error {{no matching constructor for initialization}}
 } catch (...) {
 }
 
 } // namespace test_simpler_implicit_move

clang/test/SemaCXX/P1155.cpp

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=cxx20_2b %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=cxx20_2b %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
-// cxx20_2b-no-diagnostics
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify %s
+// expected-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
+  throw w;
 }
 } // namespace test_throwing
 
 // Non-constructor conversion
 namespace test_non_constructor_conversion {
 class Widget {};
 
 struct To {
-  operator Widget() const & = delete; // cxx11_17-note {{'operator Widget' has been explicitly marked deleted here}}
+  operator Widget() const & = delete;
   operator Widget() &&;
 };
 
 Widget nine() {
   To t;
-  return t; // cxx11_17-error {{conversion function from 'test_non_constructor_conversion::To' to 'test_non_constructor_conversion::Widget' invokes a deleted function}}
+  return t;
 }
 } // namespace test_non_constructor_conversion
 
 // By-value sinks
 namespace test_by_value_sinks {
 class Widget {
 public:
   Widget();
   Widget(Widget &&);
-  Widget(const Widget &) = delete; // cxx11_17-note {{'Widget' has been explicitly marked deleted here}}
+  Widget(const Widget &) = delete;
 };
 
 struct Fowl {
-  Fowl(Widget); // cxx11_17-note {{passing argument to parameter here}}
+  Fowl(Widget);
 };
 
 Fowl eleven() {
   Widget w;
-  return w; // cxx11_17-error {{call to deleted constructor of 'test_by_value_sinks::Widget'}}
+  return w;
 }
 } // namespace test_by_value_sinks
 
 // Slicing
 namespace test_slicing {
 class Base {
 public:
   Base();
   Base(Base &&);
-  Base(Base const &) = delete; // cxx11_17-note {{'Base' has been explicitly marked deleted here}}
+  Base(Base const &) = delete;
 };
 
 class Derived : public Base {};
 
 Base thirteen() {
   Derived result;
-  return result; // cxx11_17-error {{call to deleted constructor of 'test_slicing::Base'}}
+  return result;
 }
 } // namespace test_slicing

clang/test/SemaCXX/conversion-function.cpp

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected          -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected          -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1            -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected                -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected                -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx98_11,cxx11 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_11,cxx98 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
 
 class X {
 public:
   operator bool();
   operator int() const;
 
   bool f() {
     return operator bool();
void f(Yb& a) {
   int i = a; // OK. calls XB::operator int();
   char ch = a;  // OK. calls Yb::operator char();
 }
 
 // Test conversion + copy construction.
 class AutoPtrRef { };
 
 class AutoPtr {
-  AutoPtr(AutoPtr &); // cxx98_14-note{{declared private here}}
+  AutoPtr(AutoPtr &);
 
 public:
   AutoPtr();
   AutoPtr(AutoPtrRef);
 
   operator AutoPtrRef();
 };
 
 AutoPtr make_auto_ptr();
 
 AutoPtr test_auto_ptr(bool Cond) {
   AutoPtr p1( make_auto_ptr() );
 
   AutoPtr p;
   if (Cond)
-    return p; // cxx98_14-error{{calling a private constructor}}
+    return p;
 
   return AutoPtr();
 }
 
 struct A1 {
   A1(const char *);
   ~A1();
 
 private:
-  A1(const A1&); // cxx98_14-note 2 {{declared private here}}
+  A1(const A1&); // cxx98_11-note 2 {{declared private here}}
 };
 
 A1 f() {
   // FIXME: redundant diagnostics!
-  return "Hello"; // cxx98_14-error {{calling a private constructor}}
-#if __cplusplus <= 199711L
-  // expected-warning@-2 {{an accessible copy constructor}}
-#else
-  // cxx98_14-warning@-4 {{copying parameter of type 'A1' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}}
-#endif
+  return "Hello"; // cxx98_11-error {{calling a private constructor}}
+  // cxx98-warning@-1 {{an accessible copy constructor}}
+  // cxx11-warning@-2 {{copying parameter of type 'A1' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}}
 }
 
 namespace source_locations {
   template<typename T>
   struct sneaky_int {
     typedef int type;
   };
 

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

-// 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 {
-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> typename remove_reference<T>::type &&move(T &&t);
-} // namespace foo
-} // namespace std
-
-struct Instrument {
-    Instrument() {}
-    Instrument(Instrument&&) { /* MOVE */ }
-    Instrument(const Instrument&) { /* COPY */ }
-};
-struct ConvertFromBase { Instrument i; };
-struct ConvertFromDerived { Instrument i; };
-struct Base {
-    Instrument i;
-    operator ConvertFromBase() const& { return ConvertFromBase{i}; }
-    operator ConvertFromBase() && { return ConvertFromBase{std::move(i)}; }
-};
-struct Derived : public Base {
-    operator ConvertFromDerived() const& { return ConvertFromDerived{i}; }
-    operator ConvertFromDerived() && { return ConvertFromDerived{std::move(i)}; }
-};
-struct ConstructFromBase {
-    Instrument i;
-    ConstructFromBase(const Base& b): i(b.i) {}
-    ConstructFromBase(Base&& b): i(std::move(b.i)) {}
-};
-struct ConstructFromDerived {
-    Instrument i;
-    ConstructFromDerived(const Derived& d): i(d.i) {}
-    ConstructFromDerived(Derived&& d): i(std::move(d.i)) {}
-};
-
-struct TrivialInstrument {
-    int i = 42;
-};
-struct ConvertFromTrivialBase { TrivialInstrument i; };
-struct ConvertFromTrivialDerived { TrivialInstrument i; };
-struct TrivialBase {
-    TrivialInstrument i;
-    operator ConvertFromTrivialBase() const& { return ConvertFromTrivialBase{i}; }
-    operator ConvertFromTrivialBase() && { return ConvertFromTrivialBase{std::move(i)}; }
-};
-struct TrivialDerived : public TrivialBase {
-    operator ConvertFromTrivialDerived() const& { return ConvertFromTrivialDerived{i}; }
-    operator ConvertFromTrivialDerived() && { return ConvertFromTrivialDerived{std::move(i)}; }
-};
-struct ConstructFromTrivialBase {
-    TrivialInstrument i;
-    ConstructFromTrivialBase(const TrivialBase& b): i(b.i) {}
-    ConstructFromTrivialBase(TrivialBase&& b): i(std::move(b.i)) {}
-};
-struct ConstructFromTrivialDerived {
-    TrivialInstrument i;
-    ConstructFromTrivialDerived(const TrivialDerived& d): i(d.i) {}
-    ConstructFromTrivialDerived(TrivialDerived&& d): i(std::move(d.i)) {}
-};
-
-Derived test1() {
-    Derived d1;
-    return d1;  // ok
-}
-Base test2() {
-    Derived d2;
-    return d2;  // e1
-    // 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]]:14}:"std::move(d2)"
-}
-ConstructFromDerived test3() {
-  Derived d3;
-  return d3; // ok
-}
-ConstructFromBase test4() {
-    Derived d4;
-    return d4;  // e3
-    // 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]]:14}:"std::move(d4)"
-}
-ConvertFromDerived test5() {
-    Derived d5;
-    return d5;  // e4
-    // 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]]:14}:"std::move(d5)"
-}
-ConvertFromBase test6() {
-    Derived d6;
-    return d6;  // e5
-    // 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]]:14}:"std::move(d6)"
-}
-
-// These test cases should not produce the warning.
-Derived ok1() { Derived d; return d; }
-Base ok2() { Derived d; return static_cast<Derived&&>(d); }
-ConstructFromDerived ok3() { Derived d; return static_cast<Derived&&>(d); }
-ConstructFromBase ok4() { Derived d; return static_cast<Derived&&>(d); }
-ConvertFromDerived ok5() { Derived d; return static_cast<Derived&&>(d); }
-ConvertFromBase ok6() { Derived d; return static_cast<Derived&&>(d); }
-
-// If the target is an lvalue reference, assume it's not safe to move from.
-Derived ok_plvalue1(Derived& d) { return d; }
-Base ok_plvalue2(Derived& d) { return d; }
-ConstructFromDerived ok_plvalue3(const Derived& d) { return d; }
-ConstructFromBase ok_plvalue4(Derived& d) { return d; }
-ConvertFromDerived ok_plvalue5(Derived& d) { return d; }
-ConvertFromBase ok_plvalue6(Derived& d) { return d; }
-
-Derived ok_lvalue1(Derived *p) { Derived& d = *p; return d; }
-Base ok_lvalue2(Derived *p) { Derived& d = *p; return d; }
-ConstructFromDerived ok_lvalue3(Derived *p) { const Derived& d = *p; return d; }
-ConstructFromBase ok_lvalue4(Derived *p) { Derived& d = *p; return d; }
-ConvertFromDerived ok_lvalue5(Derived *p) { Derived& d = *p; return d; }
-ConvertFromBase ok_lvalue6(Derived *p) { Derived& d = *p; return d; }
-
-// If the target is a global, assume it's not safe to move from.
-static Derived global_d;
-Derived ok_global1() { return global_d; }
-Base ok_global2() { return global_d; }
-ConstructFromDerived ok_global3() { return global_d; }
-ConstructFromBase ok_global4() { return global_d; }
-ConvertFromDerived ok_global5() { return global_d; }
-ConvertFromBase ok_global6() { return global_d; }
-
-// If the target's copy constructor is trivial, assume the programmer doesn't care.
-TrivialDerived ok_trivial1(TrivialDerived d) { return d; }
-TrivialBase ok_trivial2(TrivialDerived d) { return d; }
-ConstructFromTrivialDerived ok_trivial3(TrivialDerived d) { return d; }
-ConstructFromTrivialBase ok_trivial4(TrivialDerived d) { return d; }
-ConvertFromTrivialDerived ok_trivial5(TrivialDerived d) { return d; }
-ConvertFromTrivialBase ok_trivial6(TrivialDerived d) { return d; }
-
-// If the target is a parameter, do apply the diagnostic.
-Derived testParam1(Derived d) { return d; }
-Base testParam2(Derived d) {
-    return d;  // e6
-    // 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)"
-}
-ConstructFromDerived testParam3(Derived d) {
-  return d; // ok
-}
-ConstructFromBase testParam4(Derived d) {
-    return d;  // e8
-    // 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)"
-}
-ConvertFromDerived testParam5(Derived d) {
-    return d;  // e9
-    // 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)"
-}
-ConvertFromBase testParam6(Derived d) {
-    return d;  // e10
-    // 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)"
-}
-
-// If the target is an rvalue reference parameter, do apply the diagnostic.
-Derived testRParam1(Derived&& d) {
-    return d;  // e11
-    // 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)"
-}
-Base testRParam2(Derived&& d) {
-    return d;  // e12
-    // 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)"
-}
-ConstructFromDerived testRParam3(Derived&& d) {
-    return d;  // e13
-    // 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)"
-}
-ConstructFromBase testRParam4(Derived&& d) {
-    return d;  // e14
-    // 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)"
-}
-ConvertFromDerived testRParam5(Derived&& d) {
-    return d;  // e15
-    // 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)"
-}
-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; } // cxx2b-error {{non-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;
-    return (d);  // e17
-    // 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]]:15}:"std::move(d)"
-}
-ConstructFromDerived testParens2() {
-  Derived 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
-    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
-    // cxx11_17-note@-2{{to avoid copying}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
-    __builtin_unreachable();
-}
-Base testEParam2() {
-    try { throw_derived(); } catch (Derived d) { return d; }  // e20
-    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
-    // cxx11_17-note@-2{{to avoid copying}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
-    __builtin_unreachable();
-}
-ConstructFromDerived testEParam3() {
-    try { throw_derived(); } catch (Derived d) { return d; }  // e21
-    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
-    // cxx11_17-note@-2{{to avoid copying}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
-    __builtin_unreachable();
-}
-ConstructFromBase testEParam4() {
-    try { throw_derived(); } catch (Derived d) { return d; }  // e22
-    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
-    // cxx11_17-note@-2{{to avoid copying}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
-    __builtin_unreachable();
-}
-ConvertFromDerived testEParam5() {
-    try { throw_derived(); } catch (Derived d) { return d; }  // e23
-    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
-    // cxx11_17-note@-2{{to avoid copying}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
-    __builtin_unreachable();
-}
-ConvertFromBase testEParam6() {
-    try { throw_derived(); } catch (Derived d) { return d; }  // e24
-    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
-    // cxx11_17-note@-2{{to avoid copying}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
-    __builtin_unreachable();
-}
-
-// If the exception variable is an lvalue reference, we cannot be sure
-// that we own it; it is extremely contrived, but possible, for this to
-// be a reference to an exception object that was thrown via
-// `std::rethrow_exception(xp)` in Thread A, and meanwhile somebody else
-// has got a copy of `xp` in Thread B, so that moving out of this object
-// in Thread A would be observable (and racy) with respect to Thread B.
-// Therefore assume it's not safe to move from.
-Derived ok_REParam1() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-Base ok_REParam2() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-ConstructFromDerived ok_REParam3() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-ConstructFromBase ok_REParam4() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-ConvertFromDerived ok_REParam5() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-ConvertFromBase ok_REParam6() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-
-Derived ok_CEParam1() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-Base ok_CEParam2() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-ConstructFromDerived ok_CEParam3() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-ConstructFromBase ok_CEParam4() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-ConvertFromDerived ok_CEParam5() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-ConvertFromBase ok_CEParam6() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-
-// If rvalue overload resolution would find a copy constructor anyway,
-// or if the copy constructor actually selected is trivial, then don't warn.
-struct TriviallyCopyable {};
-struct OnlyCopyable {
-    OnlyCopyable() = default;
-    OnlyCopyable(const OnlyCopyable&) {}
-};
-
-TriviallyCopyable ok_copy1() { TriviallyCopyable c; return c; }
-OnlyCopyable ok_copy2() { OnlyCopyable c; return c; }
-TriviallyCopyable ok_copyparam1(TriviallyCopyable c) { return c; }
-OnlyCopyable ok_copyparam2(OnlyCopyable c) { return c; }
-
-void test_throw1(Derived&& d) {
-    throw d;  // e25
-    // cxx11_17-warning@-1{{will be copied despite being thrown by name}}
-    // cxx11_17-note@-2{{to avoid copying}}
-    // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:11-[[@LINE-3]]:12}:"std::move(d)"
-}
-
-void ok_throw1() {
-  Derived d;
-  throw d;
-}
-void ok_throw2(Derived d) { throw d; }
-void ok_throw3(Derived &d) { throw d; }
-void ok_throw4(Derived d) { throw std::move(d); }
-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; // cxx20_2b-note {{'Base' has been explicitly marked deleted here}}
-  Base(Base const &);
-};
-
-struct Derived : public Base {};
-
-Base test_ok() {
-  Derived d;
-  return d; // cxx20_2b-error {{call to deleted constructor of 'test_delete::Base'}}
-}
-} // namespace test_delete

clang/test/SemaObjCXX/block-capture.mm

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx20_2b,cxx2b %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx20_2b       %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx98_11       %s
-// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fobjc-arc -fblocks -Wno-c++11-extensions -verify=cxx98_2b,cxx98_11       %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b       %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b       %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fobjc-arc -fblocks -Wno-c++11-extensions -verify=cxx98_2b       %s
 
 #define TEST(T) void test_##T() { \
   __block T x;                    \
   (void)^(void) { (void)x; };     \
 }
 
 struct CopyOnly {
   CopyOnly();           // cxx2b-note {{not viable}}
struct NoCopyNoMove {
   NoCopyNoMove();
   NoCopyNoMove(NoCopyNoMove &) = delete;
   NoCopyNoMove(NoCopyNoMove &&) = delete; // cxx98_2b-note {{marked deleted here}}
 };
 TEST(NoCopyNoMove); // cxx98_2b-error {{call to deleted constructor}}
 
 struct ConvertingRVRef {
   ConvertingRVRef();
-  ConvertingRVRef(ConvertingRVRef &) = delete; // cxx98_11-note {{marked deleted here}}
+  ConvertingRVRef(ConvertingRVRef &) = delete;
 
   struct X {};
   ConvertingRVRef(X &&);
   operator X() const & = delete;
   operator X() &&;
 };
-TEST(ConvertingRVRef); // cxx98_11-error {{call to deleted constructor}}
+TEST(ConvertingRVRef);
 
 struct ConvertingCLVRef {
   ConvertingCLVRef();
   ConvertingCLVRef(ConvertingCLVRef &);
 
   struct X {};
-  ConvertingCLVRef(X &&); // cxx20_2b-note {{passing argument to parameter here}}
+  ConvertingCLVRef(X &&); // cxx98_2b-note {{passing argument to parameter here}}
   operator X() const &;
-  operator X() && = delete; // cxx20_2b-note {{marked deleted here}}
+  operator X() && = delete; // cxx98_2b-note {{marked deleted here}}
 };
-TEST(ConvertingCLVRef); // cxx20_2b-error {{invokes a deleted function}}
+TEST(ConvertingCLVRef); // cxx98_2b-error {{invokes a deleted function}}
 
 struct SubSubMove {};
 struct SubMove : SubSubMove {
   SubMove();
-  SubMove(SubMove &) = delete; // cxx98_11-note {{marked deleted here}}
+  SubMove(SubMove &) = delete;
 
   SubMove(SubSubMove &&);
 };
-TEST(SubMove); // cxx98_11-error {{call to deleted constructor}}
+TEST(SubMove);