[clang] WIP: Implement simpler alternative to two-phase lookup for NRVO

[mizvekov]

Summary

WIP, not ready for review.

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

[mizvekov]

.

[mizvekov]

.

[mizvekov]

Initial implementation, still WIP.

[mizvekov]

.

[mizvekov]

Patch now in workable state. Is Missing a few cleanups in the implementation.

Updates coroutine implicit move tests, as now they can finally match C++20 behavior and don't need P2266 retroactively applied.

There are some test result changes.
These all match current GCC behaviour though: We are now broken in the same way as GCC is for these.
TBD what to do about these. The ambiguous overload resolution one might be easy to solve,
the other ones have to be studied more carefully.

clang/include/clang/AST/Expr.h

public:
   ///
   /// C++11 divides the concept of "r-value" into pure r-values
   /// ("pr-values") and so-called expiring values ("x-values"), which
   /// identify specific objects that can be safely cannibalized for
   /// their resources.
   bool isLValue() const { return getValueKind() == VK_LValue; }
   bool isPRValue() const { return getValueKind() == VK_PRValue; }
   bool isXValue() const { return getValueKind() == VK_XValue; }
+  bool isYValue() const { return getValueKind() == VK_YValue; }
   bool isGLValue() const { return getValueKind() != VK_PRValue; }
 
   enum LValueClassification {
     LV_Valid,
     LV_NotObjectType,
     LV_IncompleteVoidType,
     LV_DuplicateVectorComponents,
     LV_InvalidExpression,

clang/include/clang/Basic/Specifiers.h

enum ExprValueKind {
 
     /// An l-value expression is a reference to an object with
     /// independent storage.
     VK_LValue,
 
     /// An x-value expression is a reference to an object with
     /// independent storage but which can be "moved", i.e.
     /// efficiently cannibalized for its resources.
-    VK_XValue
+    VK_XValue,
+
+    // Is just like an x-value, but will bind to a
+    // l-value reference, at a lower rank.
+    VK_YValue,
   };
 
   /// A further classification of the kind of object referenced by an
   /// l-value or x-value.
   enum ExprObjectKind {
     /// An ordinary object is located at an address in memory.
     OK_Ordinary,
 

clang/include/clang/Sema/Overload.h

public:
     unsigned IsLvalueReference : 1;
 
     /// Whether we're binding to a function lvalue.
     unsigned BindsToFunctionLvalue : 1;
 
     /// Whether we're binding to an rvalue.
     unsigned BindsToRvalue : 1;
 
+    /// Whether this is a non-volatile const qualified
+    /// reference binding to an yvalue.
+    unsigned NonVolatileConstBindsToYvalue : 1;
+
     /// Whether this binds an implicit object argument to a
     /// non-static member function without a ref-qualifier.
     unsigned BindsImplicitObjectArgumentWithoutRefQualifier : 1;
 
     /// Whether this binds a reference to an object with a different
     /// Objective-C lifetime qualifier.
     unsigned ObjCLifetimeConversionBinding : 1;
 

clang/include/clang/Sema/Sema.h

RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,
                                            unsigned NumParams);
 
   struct NamedReturnInfo {
     const VarDecl *Candidate;
 
     enum Status : uint8_t { None, MoveEligible, MoveEligibleAndCopyElidable };
     Status S;
 
-    bool isMoveEligible() const { return S != None; };
+    bool isMoveEligible() const { return S >= MoveEligible; };
     bool isCopyElidable() const { return S == MoveEligibleAndCopyElidable; }
   };
-  NamedReturnInfo getNamedReturnInfo(Expr *&E, bool ForceCXX2b = false);
-  NamedReturnInfo getNamedReturnInfo(const VarDecl *VD);
-  const VarDecl *getCopyElisionCandidate(NamedReturnInfo &Info,
-                                         QualType ReturnType);
-
-  ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
-                                             const NamedReturnInfo &NRInfo,
-                                             Expr *Value);
+  NamedReturnInfo getNamedReturnInfo(const VarDecl *VD, QualType ReturnType,
+                                     bool Parenthesized);
+  enum class NRVOExprContext { Returned, Co_Returned, Thrown };
+  const VarDecl *getCopyElisionCandidate(Expr *&E, NRVOExprContext C,
+                                         QualType ReturnType = QualType());
 
   StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
                              Scope *CurScope);
   StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
-  StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
-                                     NamedReturnInfo &NRInfo);
+  StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
 
   StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                              bool IsVolatile, unsigned NumOutputs,
                              unsigned NumInputs, IdentifierInfo **Names,
                              MultiExprArg Constraints, MultiExprArg Exprs,
                              Expr *AsmString, MultiExprArg Clobbers,
                              unsigned NumLabels,
                              SourceLocation RParenLoc);

clang/lib/AST/ASTContext.cpp

QualType ASTContext::getDecltypeForParenthesizedExpr(const Expr *e) const {
   QualType T = e->getType();
   switch (e->getValueKind()) {
   //     - otherwise, if e is an xvalue, decltype(e) is T&&, where T is the
   //       type of e;
   case VK_XValue:
     return getRValueReferenceType(T);
   //     - otherwise, if e is an lvalue, decltype(e) is T&, where T is the
   //       type of e;
+  case VK_YValue:
   case VK_LValue:
     return getLValueReferenceType(T);
   //  - otherwise, decltype(e) is the type of e.
   case VK_PRValue:
     return T;
   }
   llvm_unreachable("Unknown value kind");
 }

clang/lib/AST/ExprClassification.cpp

Cl Expr::ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const {
   }
 
   // Enable this assertion for testing.
   switch (kind) {
   case Cl::CL_LValue:
     assert(isLValue());
     break;
   case Cl::CL_XValue:
-    assert(isXValue());
+    assert(isXValue() || isYValue());
     break;
   case Cl::CL_Function:
   case Cl::CL_Void:
   case Cl::CL_AddressableVoid:
   case Cl::CL_DuplicateVectorComponents:
   case Cl::CL_MemberFunction:
   case Cl::CL_SubObjCPropertySetting:
   case Cl::CL_ClassTemporary:

 static Cl::Kinds ClassifyExprValueKind(const LangOptions &Lang,
                                        const Expr *E,
                                        ExprValueKind Kind) {
   switch (Kind) {
   case VK_PRValue:
     return Lang.CPlusPlus ? ClassifyTemporary(E->getType()) : Cl::CL_PRValue;
   case VK_LValue:
     return Cl::CL_LValue;
+  case VK_YValue:
   case VK_XValue:
     return Cl::CL_XValue;
   }
   llvm_unreachable("Invalid value category of implicit cast.");
 }
 
 static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
   // This function takes the first stab at classifying expressions.

clang/lib/AST/JSONNodeDumper.cpp

if (const auto *E = dyn_cast<Expr>(S)) {
     JOS.attribute("type", createQualType(E->getType()));
     const char *Category = nullptr;
     switch (E->getValueKind()) {
     case VK_LValue: Category = "lvalue"; break;
     case VK_XValue: Category = "xvalue"; break;
     case VK_PRValue:
       Category = "prvalue";
       break;
+    case VK_YValue:
+      Category = "yvalue";
+      break;
     }
     JOS.attribute("valueCategory", Category);
   }
   InnerStmtVisitor::Visit(S);
 }
 
 void JSONNodeDumper::Visit(const Type *T) {
   JOS.attribute("id", createPointerRepresentation(T));

clang/lib/AST/TextNodeDumper.cpp

if (E->containsErrors()) {
       case VK_PRValue:
         break;
       case VK_LValue:
         OS << " lvalue";
         break;
       case VK_XValue:
         OS << " xvalue";
         break;
+      case VK_YValue:
+        OS << " yvalue";
+        break;
       }
     }
 
     {
       ColorScope Color(OS, ShowColors, ObjectKindColor);
       switch (E->getObjectKind()) {
       case OK_Ordinary:
         break;

clang/lib/CodeGen/CGDecl.cpp

case CK_LValueToRValue: {
         srcAddr = CGF.Builder.CreateElementBitCast(
             srcAddr, destLV.getAddress(CGF).getElementType());
       }
 
       // If it was an l-value, use objc_copyWeak.
       if (srcExpr->isLValue()) {
         CGF.EmitARCCopyWeak(destLV.getAddress(CGF), srcAddr);
       } else {
-        assert(srcExpr->isXValue());
+        assert(srcExpr->isXValue() || srcExpr->isYValue());
         CGF.EmitARCMoveWeak(destLV.getAddress(CGF), srcAddr);
       }
       return true;
     }
 
     // Stop at anything else.
     default:
       return false;

clang/lib/CodeGen/CGObjC.cpp

 static TryEmitResult tryEmitARCRetainLoadOfScalar(CodeGenFunction &CGF,
                                                   const Expr *e) {
   e = e->IgnoreParens();
   QualType type = e->getType();
 
   // If we're loading retained from a __strong xvalue, we can avoid
   // an extra retain/release pair by zeroing out the source of this
   // "move" operation.
-  if (e->isXValue() &&
-      !type.isConstQualified() &&
+  if ((e->isXValue() || e->isYValue()) && !type.isConstQualified() &&
       type.getObjCLifetime() == Qualifiers::OCL_Strong) {
     // Emit the lvalue.
     LValue lv = CGF.EmitLValue(e);
 
     // Load the object pointer.
     llvm::Value *result = CGF.EmitLoadOfLValue(lv,
                                                SourceLocation()).getScalarVal();
 

clang/lib/Sema/Sema.cpp

 // according to the C++ standard in effect ([class.copy.elision]p3).
 static void checkEscapingByref(VarDecl *VD, Sema &S) {
   QualType T = VD->getType();
   EnterExpressionEvaluationContext scope(
       S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
   SourceLocation Loc = VD->getLocation();
   Expr *VarRef =
       new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
-  ExprResult Result;
   auto IE = InitializedEntity::InitializeBlock(Loc, T, false);
-  if (S.getLangOpts().CPlusPlus2b) {
-    auto *E = ImplicitCastExpr::Create(S.Context, T, CK_NoOp, VarRef, nullptr,
-                                       VK_XValue, FPOptionsOverride());
-    Result = S.PerformCopyInitialization(IE, SourceLocation(), E);
-  } else {
-    Result = S.PerformMoveOrCopyInitialization(
-        IE, Sema::NamedReturnInfo{VD, Sema::NamedReturnInfo::MoveEligible},
-        VarRef);
-  }
+  auto *E = S.getLangOpts().CPlusPlus11
+                ? ImplicitCastExpr::Create(
+                      S.Context, T, CK_NoOp, VarRef, nullptr,
+                      S.getLangOpts().CPlusPlus2b ? VK_XValue : VK_YValue,
+                      FPOptionsOverride())
+                : VarRef;
+  ExprResult Result = S.PerformCopyInitialization(IE, SourceLocation(), E);
 
   if (!Result.isInvalid()) {
     Result = S.MaybeCreateExprWithCleanups(Result);
     Expr *Init = Result.getAs<Expr>();
     S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
   }
 
   // The destructor's exception specification is needed when IRGen generates

clang/lib/Sema/SemaCodeComplete.cpp

static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate,
   RefQualifierKind CandidateRef = Candidate.getRefQualifier();
   RefQualifierKind IncumbentRef = Incumbent.getRefQualifier();
   if (CandidateRef != IncumbentRef) {
     // If the object kind is LValue/RValue, there's one acceptable ref-qualifier
     // and it can't be mixed with ref-unqualified overloads (in valid code).
 
     // For xvalue objects, we prefer the rvalue overload even if we have to
     // add qualifiers (which is rare, because const&& is rare).
-    if (ObjectKind == clang::VK_XValue)
+    if (ObjectKind == clang::VK_XValue || ObjectKind == clang::VK_YValue)
       return CandidateRef == RQ_RValue ? OverloadCompare::Dominates
                                        : OverloadCompare::Dominated;
   }
   // Now the ref qualifiers are the same (or we're in some invalid state).
   // So make some decision based on the qualifiers.
   Qualifiers CandidateQual = Candidate.getMethodQualifiers();
   Qualifiers IncumbentQual = Incumbent.getMethodQualifiers();
   bool CandidateSuperset = CandidateQual.compatiblyIncludes(IncumbentQual);

clang/lib/Sema/SemaCoroutine.cpp

if (E && E->getType()->isPlaceholderType() &&
     ExprResult R = CheckPlaceholderExpr(E);
     if (R.isInvalid()) return StmtError();
     E = R.get();
   }
 
   VarDecl *Promise = FSI->CoroutinePromise;
   ExprResult PC;
   if (E && (isa<InitListExpr>(E) || !E->getType()->isVoidType())) {
-    getNamedReturnInfo(E, /*ForceCXX2b=*/true);
+    getCopyElisionCandidate(E, NRVOExprContext::Co_Returned);
     PC = buildPromiseCall(*this, Promise, Loc, "return_value", E);
   } else {
     E = MakeFullDiscardedValueExpr(E).get();
     PC = buildPromiseCall(*this, Promise, Loc, "return_void", None);
   }
   if (PC.isInvalid())
     return StmtError();
 

clang/lib/Sema/SemaExprCXX.cpp

if (Ex && !Ex->isTypeDependent()) {
     //     - in a throw-expression, when the operand is the name of a
     //       non-volatile automatic object (other than a function or
     //       catch-clause
     //       parameter) whose scope does not extend beyond the end of the
     //       innermost enclosing try-block (if there is one), the copy/move
     //       operation from the operand to the exception object (15.1) can be
     //       omitted by constructing the automatic object directly into the
     //       exception object
-    NamedReturnInfo NRInfo =
-        IsThrownVarInScope ? getNamedReturnInfo(Ex) : NamedReturnInfo();
+    bool CopyElidable =
+        IsThrownVarInScope &&
+        getCopyElisionCandidate(Ex, NRVOExprContext::Thrown) != nullptr;
 
     QualType ExceptionObjectTy = Context.getExceptionObjectType(Ex->getType());
     if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
       return ExprError();
 
-    InitializedEntity Entity = InitializedEntity::InitializeException(
-        OpLoc, ExceptionObjectTy,
-        /*NRVO=*/NRInfo.isCopyElidable());
-    ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRInfo, Ex);
+    InitializedEntity Entity =
+        InitializedEntity::InitializeException(OpLoc, ExceptionObjectTy,
+                                               /*NRVO=*/CopyElidable);
+    ExprResult Res = PerformCopyInitialization(Entity, SourceLocation(), Ex);
     if (Res.isInvalid())
       return ExprError();
     Ex = Res.get();
   }
 
   // PPC MMA non-pointer types are not allowed as throw expr types.
   if (Ex && Context.getTargetInfo().getTriple().isPPC64())
     CheckPPCMMAType(Ex->getType(), Ex->getBeginLoc());

clang/lib/Sema/SemaInit.cpp

 
 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
                                                       ExprValueKind VK) {
   Step S;
   switch (VK) {
   case VK_PRValue:
     S.Kind = SK_CastDerivedToBasePRValue;
     break;
+  case VK_YValue:
   case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
   case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
   }
   S.Type = BaseType;
   Steps.push_back(S);
 }
 
 void InitializationSequence::AddReferenceBindingStep(QualType T,

 void InitializationSequence::AddQualificationConversionStep(QualType Ty,
                                                             ExprValueKind VK) {
   Step S;
   S.Kind = SK_QualificationConversionPRValue; // work around a gcc warning
   switch (VK) {
   case VK_PRValue:
     S.Kind = SK_QualificationConversionPRValue;
     break;
+  case VK_YValue:
   case VK_XValue:
     S.Kind = SK_QualificationConversionXValue;
     break;
   case VK_LValue:
     S.Kind = SK_QualificationConversionLValue;
     break;
   }
   S.Type = Ty;
static void TryReferenceInitializationCore(Sema &S,
   //     - If the reference is an lvalue reference and the initializer
   //       expression
   // Note the analogous bullet points for rvalue refs to functions. Because
   // there are no function rvalues in C++, rvalue refs to functions are treated
   // like lvalue refs.
   OverloadingResult ConvOvlResult = OR_Success;
   bool T1Function = T1->isFunctionType();
   if (isLValueRef || T1Function) {
-    if (InitCategory.isLValue() && !isNonReferenceableGLValue(Initializer) &&
+    if ((InitCategory.isLValue() || Initializer->isYValue()) &&
+        !isNonReferenceableGLValue(Initializer) &&
         (RefRelationship == Sema::Ref_Compatible ||
          (Kind.isCStyleOrFunctionalCast() &&
           RefRelationship == Sema::Ref_Related))) {
       //   - is an lvalue (but is not a bit-field), and "cv1 T1" is
       //     reference-compatible with "cv2 T2," or
       if (RefConv & (Sema::ReferenceConversions::DerivedToBase |
                      Sema::ReferenceConversions::ObjC)) {
         // If we're converting the pointee, add any qualifiers first;

clang/lib/Sema/SemaOverload.cpp

isBetterReferenceBindingKind(const StandardConversionSequence &SCS1,
   // because the semantics in the current C++0x working paper (N3225 at the
   // time of this writing) break the standard definition of std::forward
   // and std::reference_wrapper when dealing with references to functions.
   // Proposed wording changes submitted to CWG for consideration.
   if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier ||
       SCS2.BindsImplicitObjectArgumentWithoutRefQualifier)
     return false;
 
-  return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
-          SCS2.IsLvalueReference) ||
-         (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
-          !SCS2.IsLvalueReference && SCS2.BindsToFunctionLvalue);
+  if (!SCS1.IsLvalueReference && SCS1.BindsToRvalue && SCS2.IsLvalueReference)
+    return true;
+
+  if (SCS1.IsLvalueReference && SCS1.NonVolatileConstBindsToYvalue &&
+      SCS2.IsLvalueReference)
+    return true;
+
+  return SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
+         !SCS2.IsLvalueReference && SCS2.BindsToFunctionLvalue;
 }
 
 enum class FixedEnumPromotion {
   None,
   ToUnderlyingType,
   ToPromotedUnderlyingType
 };
 
auto SetAsReferenceBinding = [&](bool BindsDirectly) {
     ICS.Standard.Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
                               ? ICK_Derived_To_Base
                               : (RefConv & Sema::ReferenceConversions::ObjC)
                                     ? ICK_Compatible_Conversion
                                     : ICK_Identity;
     // FIXME: As a speculative fix to a defect introduced by CWG2352, we rank
     // a reference binding that performs a non-top-level qualification
     // conversion as a qualification conversion, not as an identity conversion.
-    ICS.Standard.Third = (RefConv &
-                              Sema::ReferenceConversions::NestedQualification)
-                             ? ICK_Qualification
-                             : ICK_Identity;
+    ICS.Standard.Third =
+        (RefConv & Sema::ReferenceConversions::NestedQualification)
     ICS.Standard.setFromType(T2);
     ICS.Standard.setToType(0, T2);
     ICS.Standard.setToType(1, T1);
     ICS.Standard.setToType(2, T1);
     ICS.Standard.ReferenceBinding = true;
     ICS.Standard.DirectBinding = BindsDirectly;
     ICS.Standard.IsLvalueReference = !isRValRef;
     ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
     ICS.Standard.BindsToRvalue = InitCategory.isRValue();
+    ICS.Standard.NonVolatileConstBindsToYvalue =
+        Init->isYValue() && T1.isConstQualified() && !T1.isVolatileQualified();
     ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
     ICS.Standard.ObjCLifetimeConversionBinding =
         (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
     ICS.Standard.CopyConstructor = nullptr;
     ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
   };
 
   // C++0x [dcl.init.ref]p5:
   //   A reference to type "cv1 T1" is initialized by an expression
   //   of type "cv2 T2" as follows:
 
   //     -- If reference is an lvalue reference and the initializer expression
   if (!isRValRef) {
     //     -- is an lvalue (but is not a bit-field), and "cv1 T1" is
     //        reference-compatible with "cv2 T2," or
     //
     // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
-    if (InitCategory.isLValue() && RefRelationship == Sema::Ref_Compatible) {
+    if ((InitCategory.isLValue() || Init->isYValue()) &&
+        RefRelationship == Sema::Ref_Compatible) {
       // C++ [over.ics.ref]p1:
       //   When a parameter of reference type binds directly (8.5.3)
       //   to an argument expression, the implicit conversion sequence
       //   is the identity conversion, unless the argument expression
       //   has a type that is a derived class of the parameter type,
       //   in which case the implicit conversion sequence is a
       //   derived-to-base Conversion (13.3.3.1).
       SetAsReferenceBinding(/*BindsDirectly=*/true);
if (!isRValRef) {
     if (!SuppressUserConversions && T2->isRecordType() &&
         S.isCompleteType(DeclLoc, T2) &&
         RefRelationship == Sema::Ref_Incompatible) {
       if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
                                    Init, T2, /*AllowRvalues=*/false,
                                    AllowExplicit))
         return ICS;
     }
-  }
 
     //     -- Otherwise, the reference shall be an lvalue reference to a
-  //        non-volatile const type (i.e., cv1 shall be const), or the reference
-  //        shall be an rvalue reference.
-  if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified())) {
+    //        non-volatile const type (i.e., cv1 shall be const), or the
+    //        reference shall be an rvalue reference.
+    if (!T1.isConstQualified() || T1.isVolatileQualified()) {
       if (InitCategory.isRValue() && RefRelationship != Sema::Ref_Incompatible)
         ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
       return ICS;
     }
+  }
 
   //       -- If the initializer expression
   //
   //            -- is an xvalue, class prvalue, array prvalue or function
   //               lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
   if (RefRelationship == Sema::Ref_Compatible &&
       (InitCategory.isXValue() ||
        (InitCategory.isPRValue() &&

clang/lib/Sema/SemaStmt.cpp

 /// might be modified by the implementation.
 ///
 /// \param ForceCXX2b Overrides detection of current language mode
 /// and uses the rules for C++2b.
 ///
 /// \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(Expr *&E, bool ForceCXX2b) {
+const VarDecl *Sema::getCopyElisionCandidate(Expr *&E, NRVOExprContext C,
+                                             QualType ReturnType) {
   if (!E)
-    return NamedReturnInfo();
+    return nullptr;
   // - 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();
+    return nullptr;
   const auto *VD = dyn_cast<VarDecl>(DR->getDecl());
   if (!VD)
-    return NamedReturnInfo();
-  NamedReturnInfo Res = getNamedReturnInfo(VD);
-  if (Res.Candidate && !E->isXValue() &&
-      (ForceCXX2b || getLangOpts().CPlusPlus2b)) {
+    return nullptr;
+
+  NamedReturnInfo Info = getNamedReturnInfo(VD, ReturnType, isa<ParenExpr>(E));
+  if (getLangOpts().CPlusPlus11 && Info.isMoveEligible() && !E->isXValue()) {
+    ExprValueKind CastToKind =
+        getLangOpts().CPlusPlus2b ? VK_XValue : VK_YValue;
     E = ImplicitCastExpr::Create(Context, VD->getType().getNonReferenceType(),
-                                 CK_NoOp, E, nullptr, VK_XValue,
+                                 CK_NoOp, E, nullptr, CastToKind,
                                  FPOptionsOverride());
   }
-  return Res;
+  return Info.isCopyElidable() ? Info.Candidate : nullptr;
 }
 
 /// Determine whether the given NRVO candidate variable is move-eligible or
 /// copy-elidable, without considering function return type.
 ///
 /// \param VD The NRVO candidate variable.
 ///
 /// \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) {
+Sema::NamedReturnInfo Sema::getNamedReturnInfo(const VarDecl *VD,
+                                               QualType ReturnType,
+                                               bool Parenthesized) {
   NamedReturnInfo Info{VD, NamedReturnInfo::MoveEligibleAndCopyElidable};
 
+  // Updates the status in Info to disallow copy elision.
+  // Optionally also disallows implicit move.
+  auto disallowNRVO = [&Info](bool CanMove) {
+    Info.S = std::min(Info.S, CanMove ? NamedReturnInfo::MoveEligible
+                                      : NamedReturnInfo::None);
+  };
+
   // C++20 [class.copy.elision]p3:
   // - in a return statement in a function with ...
   // (other than a function ... parameter)
   if (VD->getKind() == Decl::ParmVar)
     Info.S = NamedReturnInfo::MoveEligible;
   else if (VD->getKind() != Decl::Var)
     return NamedReturnInfo();
 
Sema::NamedReturnInfo Sema::getNamedReturnInfo(const VarDecl *VD,
   }
 
   // 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))
     Info.S = 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.
-///
-/// \param Info The NamedReturnInfo object to update.
-///
-/// \param ReturnType This is the return type of the function.
-/// \returns The copy elision candidate, in case the initial return expression
-/// was copy elidable, or nullptr otherwise.
-const VarDecl *Sema::getCopyElisionCandidate(NamedReturnInfo &Info,
-                                             QualType ReturnType) {
-  if (!Info.Candidate)
-    return nullptr;
-
-  auto invalidNRVO = [&] {
-    Info = NamedReturnInfo();
-    return nullptr;
-  };
-
-  // If we got a non-deduced auto ReturnType, we are in a dependent context and
-  // there is no point in allowing copy elision since we won't have it deduced
-  // by the point the VardDecl is instantiated, which is the last chance we have
-  // of deciding if the candidate is really copy elidable.
+  if (!ReturnType.isNull()) {
+    if (ReturnType->isDependentType()) {
       if ((ReturnType->getTypeClass() == Type::TypeClass::Auto &&
            ReturnType->isCanonicalUnqualified()) ||
-      ReturnType->isSpecificBuiltinType(BuiltinType::Dependent))
-    return invalidNRVO();
+          ReturnType->isSpecificBuiltinType(BuiltinType::Dependent)) {
+        return NamedReturnInfo();
+      }
+    } else {
+      if (ReturnType->isSpecificBuiltinType(BuiltinType::Dependent)) {
+        ReturnType = Context.getAutoDeductType();
+      }
+      if (ReturnType->isCanonicalUnqualified()) {
+        if (AutoType *AT = ReturnType->getContainedAutoType()) {
+          QualType T = VDType.getNonReferenceType().getUnqualifiedType();
+          if (AT->isDecltypeAuto())
+            ReturnType = Parenthesized ? Context.getLValueReferenceType(T) : T;
+          else if (ReturnType->isLValueReferenceType())
+            ReturnType = Context.getLValueReferenceType(T);
+          else if (ReturnType->isRValueReferenceType())
+            ReturnType = Context.getRValueReferenceType(T);
+          else
+            ReturnType = T;
+        }
+      }
 
-  if (!ReturnType->isDependentType()) {
       // - in a return statement in a function with ...
       // ... a class return type ...
       if (!ReturnType->isRecordType())
-      return invalidNRVO();
+        Info.S = getLangOpts().CPlusPlus2b ? NamedReturnInfo::MoveEligible
+                                           : NamedReturnInfo::None;
 
-    QualType VDType = Info.Candidate->getType();
       // ... the same cv-unqualified type as the function return type ...
-    // When considering moving this expression out, allow dissimilar types.
+      // When considering moving this expression out, allow dissimilar
+      // types.
       if (!VDType->isDependentType() &&
           !Context.hasSameUnqualifiedType(ReturnType, VDType))
-      Info.S = NamedReturnInfo::MoveEligible;
+        Info.S = std::min(Info.S, NamedReturnInfo::MoveEligible);
     }
-  return Info.isCopyElidable() ? Info.Candidate : nullptr;
   }
 
-/// Perform the initialization of a potentially-movable value, which
-/// is the result of return value.
-///
-/// This routine implements C++20 [class.copy.elision]p3, which attempts to
-/// treat returned lvalues as rvalues in certain cases (to prefer move
-/// construction), then falls back to treating them as lvalues if that failed.
-ExprResult
-Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
-                                      const NamedReturnInfo &NRInfo,
-                                      Expr *Value) {
-  if (getLangOpts().CPlusPlus11 && !getLangOpts().CPlusPlus2b &&
-      NRInfo.isMoveEligible()) {
-    ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack, Value->getType(),
-                              CK_NoOp, Value, VK_XValue, FPOptionsOverride());
-    Expr *InitExpr = &AsRvalue;
-    auto Kind = InitializationKind::CreateCopy(Value->getBeginLoc(),
-                                               Value->getBeginLoc());
-    InitializationSequence Seq(*this, Entity, Kind, InitExpr);
-    auto Res = Seq.getFailedOverloadResult();
-    if (Res == OR_Success || Res == OR_Deleted) {
-      // Promote "AsRvalue" to the heap, since we now need this
-      // expression node to persist.
-      Value =
-          ImplicitCastExpr::Create(Context, Value->getType(), CK_NoOp, Value,
-                                   nullptr, VK_XValue, FPOptionsOverride());
-      // Complete type-checking the initialization of the return type
-      // using the constructor we found.
-      return Seq.Perform(*this, Entity, Kind, Value);
-    }
-  }
-  // 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);
+  return Info;
 }
 
 /// 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) {
+                                         Expr *RetValExp) {
   // If this is the first return we've seen, infer the return type.
   // [expr.prim.lambda]p4 in C++11; block literals follow the same rules.
   CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction());
   QualType FnRetType = CurCap->ReturnType;
   LambdaScopeInfo *CurLambda = dyn_cast<LambdaScopeInfo>(CurCap);
   bool HasDeducedReturnType =
       CurLambda && hasDeducedReturnType(CurLambda->CallOperator);
 
   if (ExprEvalContexts.back().Context ==
           ExpressionEvaluationContext::DiscardedStatement &&
       (HasDeducedReturnType || CurCap->HasImplicitReturnType)) {
     if (RetValExp) {
       ExprResult ER =
           ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
       if (ER.isInvalid())
         return StmtError();
       RetValExp = ER.get();
     }
     return ReturnStmt::Create(Context, ReturnLoc, RetValExp,
                               /* NRVOCandidate=*/nullptr);
   }
 
+  const VarDecl *NRVOCandidate = nullptr;
   if (HasDeducedReturnType) {
     FunctionDecl *FD = CurLambda->CallOperator;
     // If we've already decided this lambda is invalid, e.g. because
     // we saw a `return` whose expression had an error, don't keep
     // trying to deduce its return type.
     if (FD->isInvalidDecl())
       return StmtError();
     // In C++1y, the return type may involve 'auto'.
     // FIXME: Blocks might have a return type of 'auto' explicitly specified.
     if (CurCap->ReturnType.isNull())
       CurCap->ReturnType = FD->getReturnType();
 
+    NRVOCandidate = getCopyElisionCandidate(
+        RetValExp, NRVOExprContext::Returned, CurCap->ReturnType);
+
     AutoType *AT = CurCap->ReturnType->getContainedAutoType();
     assert(AT && "lost auto type from lambda return type");
     if (DeduceFunctionTypeFromReturnExpr(FD, ReturnLoc, RetValExp, AT)) {
       FD->setInvalidDecl();
       // FIXME: preserve the ill-formed return expression.
       return StmtError();
     }
     CurCap->ReturnType = FnRetType = FD->getReturnType();
-  } else if (CurCap->HasImplicitReturnType) {
+  } else {
+    if (CurCap->HasImplicitReturnType) {
       // For blocks/lambdas with implicit return types, we check each return
-    // statement individually, and deduce the common return type when the block
-    // or lambda is completed.
+      // statement individually, and deduce the common return type when the
+      // block or lambda is completed.
       // FIXME: Fold this into the 'auto' codepath above.
       if (RetValExp && !isa<InitListExpr>(RetValExp)) {
         ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp);
         if (Result.isInvalid())
           return StmtError();
         RetValExp = Result.get();
 
         // DR1048: even prior to C++14, we should use the 'auto' deduction rules
         // when deducing a return type for a lambda-expression (or by extension
         // for a block). These rules differ from the stated C++11 rules only in
         // that they remove top-level cv-qualifiers.
         if (!CurContext->isDependentContext())
           FnRetType = RetValExp->getType().getUnqualifiedType();
         else
           FnRetType = CurCap->ReturnType = Context.DependentTy;
       } else {
         if (RetValExp) {
           // C++11 [expr.lambda.prim]p4 bans inferring the result from an
           // initializer list, because it is not an expression (even
           // though we represent it as one). We still deduce 'void'.
           Diag(ReturnLoc, diag::err_lambda_return_init_list)
               << RetValExp->getSourceRange();
         }
 
         FnRetType = Context.VoidTy;
       }
 
-    // Although we'll properly infer the type of the block once it's completed,
-    // make sure we provide a return type now for better error recovery.
+      // Although we'll properly infer the type of the block once it's
+      // completed, make sure we provide a return type now for better error
+      // recovery.
       if (CurCap->ReturnType.isNull())
         CurCap->ReturnType = FnRetType;
     }
-  const VarDecl *NRVOCandidate = getCopyElisionCandidate(NRInfo, FnRetType);
+    NRVOCandidate = getCopyElisionCandidate(
+        RetValExp, NRVOExprContext::Returned, CurCap->ReturnType);
+  }
 
   if (auto *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {
     if (CurBlock->FunctionType->castAs<FunctionType>()->getNoReturnAttr()) {
       Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr);
       return StmtError();
     }
   } else if (auto *CurRegion = dyn_cast<CapturedRegionScopeInfo>(CurCap)) {
     Diag(ReturnLoc, diag::err_return_in_captured_stmt) << CurRegion->getRegionName();
if (FnRetType->isDependentType()) {
     // C99 6.8.6.4p3(136): The return statement is not an assignment. The
     // overlap restriction of subclause 6.5.16.1 does not apply to the case of
     // function return.
 
     // In C++ the return statement is handled via a copy initialization.
     // the C version of which boils down to CheckSingleAssignmentConstraints.
     InitializedEntity Entity = InitializedEntity::InitializeResult(
         ReturnLoc, FnRetType, NRVOCandidate != nullptr);
-    ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRInfo, RetValExp);
+    ExprResult Res =
+        PerformCopyInitialization(Entity, SourceLocation(), RetValExp);
     if (Res.isInvalid()) {
       // FIXME: Cleanup temporaries here, anyway?
       return StmtError();
     }
     RetValExp = Res.get();
     CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc);
   }
 
Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
   return R;
 }
 
 StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
   // Check for unexpanded parameter packs.
   if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
     return StmtError();
 
-  NamedReturnInfo NRInfo = getNamedReturnInfo(RetValExp);
-
   if (isa<CapturingScopeInfo>(getCurFunction()))
-    return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp, NRInfo);
+    return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp);
 
   QualType FnRetType;
   QualType RelatedRetType;
   const AttrVec *Attrs = nullptr;
   bool isObjCMethod = false;
 
   if (const FunctionDecl *FD = getCurFunctionDecl()) {
     FnRetType = FD->getReturnType();
if (RetValExp) {
       if (ER.isInvalid())
         return StmtError();
       RetValExp = ER.get();
     }
     return ReturnStmt::Create(Context, ReturnLoc, RetValExp,
                               /* NRVOCandidate=*/nullptr);
   }
 
+  const VarDecl *NRVOCandidate =
+      getCopyElisionCandidate(RetValExp, NRVOExprContext::Returned, FnRetType);
   // FIXME: Add a flag to the ScopeInfo to indicate whether we're performing
   // deduction.
   if (getLangOpts().CPlusPlus14) {
     if (AutoType *AT = FnRetType->getContainedAutoType()) {
       FunctionDecl *FD = cast<FunctionDecl>(CurContext);
       // If we've already decided this function is invalid, e.g. because
       // we saw a `return` whose expression had an error, don't keep
       // trying to deduce its return type.
       if (FD->isInvalidDecl())
         return StmtError();
       if (DeduceFunctionTypeFromReturnExpr(FD, ReturnLoc, RetValExp, AT)) {
         FD->setInvalidDecl();
         return StmtError();
       } else {
         FnRetType = FD->getReturnType();
       }
     }
   }
-  const VarDecl *NRVOCandidate = getCopyElisionCandidate(NRInfo, FnRetType);
 
   bool HasDependentReturnType = FnRetType->isDependentType();
 
   ReturnStmt *Result = nullptr;
   if (FnRetType->isVoidType()) {
     if (RetValExp) {
       if (isa<InitListExpr>(RetValExp)) {
         // We simply never allow init lists as the return value of void
if (FnRetType->isVoidType()) {
 
     // In C++ the return statement is handled via a copy initialization,
     // the C version of which boils down to CheckSingleAssignmentConstraints.
     if (!HasDependentReturnType && !RetValExp->isTypeDependent()) {
       // we have a non-void function with an expression, continue checking
       InitializedEntity Entity = InitializedEntity::InitializeResult(
           ReturnLoc, RetType, NRVOCandidate != nullptr);
       ExprResult Res =
-          PerformMoveOrCopyInitialization(Entity, NRInfo, RetValExp);
+          PerformCopyInitialization(Entity, SourceLocation(), RetValExp);
       if (Res.isInvalid()) {
         // FIXME: Clean up temporaries here anyway?
         return StmtError();
       }
       RetValExp = Res.getAs<Expr>();
 
       // If we have a related result type, we need to implicitly
       // convert back to the formal result type.  We can't pretend to

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (D->isNRVOVariable()) {
     // regarding copy elision, since NRVO propagation runs on the scope exit
     // actions, and these are not run on instantiation.
     // This might run through some VarDecls which were returned from non-taken
     // 'if constexpr' branches, and these will end up being constructed on the
     // return slot even if they will never be returned, as a sort of accidental
     // 'optimization'. Notably, functions with 'auto' return types won't have it
     // deduced by this point. Coupled with the limitation described
     // previously, this makes it very hard to support copy elision for these.
-    Sema::NamedReturnInfo Info = SemaRef.getNamedReturnInfo(Var);
-    bool NRVO = SemaRef.getCopyElisionCandidate(Info, RT) != nullptr;
-    Var->setNRVOVariable(NRVO);
+    Sema::NamedReturnInfo Info =
+        SemaRef.getNamedReturnInfo(Var, RT, /*Parenthesized=*/false);
+    Var->setNRVOVariable(Info.isCopyElidable());
   }
 
   Var->setImplicit(D->isImplicit());
 
   if (Var->isStaticLocal())
     SemaRef.CheckStaticLocalForDllExport(Var);
 
   return Var;

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

 }
 
 } // namespace test_constandnonconstcopy
 
 namespace test_conversion {
 
 struct B;
 struct A {
-  A(B &) = delete; // cxx98-note {{has been explicitly deleted}}
+  A(B &) = delete; // cxx98_20-note {{has been explicitly deleted}}
 };
 struct B {
-  operator A(); // cxx98-note {{candidate function}}
+  operator A(); // cxx98_20-note {{candidate function}}
 };
-A test1(B x) { return x; } // cxx98-error {{conversion}} {{is ambiguous}}
+A test1(B x) { return x; } // cxx98_20-error {{conversion}} {{is ambiguous}}
 
 struct C {};
 struct D {
   operator C() &;
   operator C() const & = delete; // cxx11_2b-note {{marked deleted here}}
 };
 C test2(D x) { return x; } // cxx11_2b-error {{invokes a deleted function}}
 

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++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
+// 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,cxx98_20                -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx98_20,cxx98_11,cxx11 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_20,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-note {{declared private here}}
+  AutoPtr(AutoPtr &); // cxx98_20-note {{declared private here}}
 
 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-error {{calling a private constructor}}
+    return p; // cxx98_20-error {{calling a private constructor}}
 
   return AutoPtr();
 }
 
 struct A1 {
   A1(const char *);
   ~A1();
 

clang/test/SemaCXX/coroutine-rvo.cpp

-// RUN: %clang_cc1 -verify -std=c++17 -fcoroutines-ts -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++2b                 -fsyntax-only -verify=expected,cxx2b %s
+// RUN: %clang_cc1 -std=c++20                 -fsyntax-only -verify=expected       %s
 
 namespace std::experimental {
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 
 template <> struct coroutine_handle<void> {

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

clang/test/SemaObjCXX/block-capture.mm

-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx11_2b,cxx2b %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx11_2b       %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx11_2b       %s
-// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fobjc-arc -fblocks -Wno-c++11-extensions -verify=cxx98_2b,cxx98          %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx11_2b,cxx2b    %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx98_20,cxx11_2b %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fblocks                       -verify=cxx98_2b,cxx98_20,cxx11_2b %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fobjc-arc -fblocks -Wno-c++11-extensions -verify=cxx98_2b,cxx98_20,cxx98    %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;  // cxx98-note {{marked deleted here}}
   NoCopyNoMove(NoCopyNoMove &&) = delete; // cxx11_2b-note {{marked deleted here}}
 };
 TEST(NoCopyNoMove); // cxx98_2b-error {{call to deleted constructor}}
 
 struct ConvertingRVRef {
   ConvertingRVRef();
-  ConvertingRVRef(ConvertingRVRef &) = delete; // cxx98-note {{marked deleted here}}
+  ConvertingRVRef(ConvertingRVRef &) = delete; // cxx98_20-note {{marked deleted here}}
 
   struct X {};
   ConvertingRVRef(X &&);
   operator X() const & = delete;
   operator X() &&;
 };
-TEST(ConvertingRVRef); // cxx98-error {{call to deleted constructor}}
+TEST(ConvertingRVRef); // cxx98_20-error {{call to deleted constructor}}
 
 struct ConvertingCLVRef {
   ConvertingCLVRef();
   ConvertingCLVRef(ConvertingCLVRef &);
 
   struct X {};
-  ConvertingCLVRef(X &&); // cxx11_2b-note {{passing argument to parameter here}}
+  ConvertingCLVRef(X &&); // cxx2b-note {{passing argument to parameter here}}
   operator X() const &;
-  operator X() && = delete; // cxx11_2b-note {{marked deleted here}}
+  operator X() && = delete; // cxx2b-note {{marked deleted here}}
 };
-TEST(ConvertingCLVRef); // cxx11_2b-error {{invokes a deleted function}}
+TEST(ConvertingCLVRef); // cxx2b-error {{invokes a deleted function}}
 
 struct SubSubMove {};
 struct SubMove : SubSubMove {
   SubMove();
-  SubMove(SubMove &) = delete; // cxx98-note {{marked deleted here}}
+  SubMove(SubMove &) = delete; // cxx98_20-note {{marked deleted here}}
 
   SubMove(SubSubMove &&);
 };
-TEST(SubMove); // cxx98-error {{call to deleted constructor}}
+TEST(SubMove); // cxx98_20-error {{call to deleted constructor}}