PR26448: [Sema] Fix determined type of ternary operator acting on two xvalue class types

[erik.pilkington]

Summary

Previously, when the 2 expressions passed to a ternary operator were xvalues and one inherits from the other, the resulting expression had type 'T', not 'T&&' as 5.16p3 dictates. For example:
`
Base b; Derived d;
typedef decltype(true ? static_cast<Base&&>(b) : static_cast<Derived&&>(d)) x; // x has type Base, not Base&&`

PR: https://llvm.org/bugs/show_bug.cgi?id=26448

[erik.pilkington]

Ping!

[erik.pilkington]

Fix the ill-generated diff. Would someone mind taking a look at this?

[rsmith]

LGTM, thanks!

lib/Sema/SemaExprCXX.cpp

4698

This should say: "... must bind directly to an lvalue."

[erik.pilkington]

Fix the wording of the quoted section of the standard. Would you mind committing this? Thanks for reviewing!

[erik.pilkington]

ping!

[erik.pilkington]

Ping!

[erik.pilkington]

Ping!

[rsmith]

Committed as r267454.

lib/Sema/SemaExprCXX.cpp

     VK = VK_LValue;
   } else {
     VK = LHS.get()->getValueKind();
   }
 
   return Result;
 }
 
-/// \brief Try to convert a type to another according to C++0x 5.16p3.
+/// \brief Try to convert a type to another according to C++11 5.16p3.
 ///
 /// This is part of the parameter validation for the ? operator. If either
 /// value operand is a class type, the two operands are attempted to be
 /// converted to each other. This function does the conversion in one direction.
 /// It returns true if the program is ill-formed and has already been diagnosed
 /// as such.
 static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
                                 SourceLocation QuestionLoc,
                                 bool &HaveConversion,
                                 QualType &ToType) {
   HaveConversion = false;
   ToType = To->getType();
 
   InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(),
                                                            SourceLocation());
-  // C++0x 5.16p3
+  // C++11 5.16p3
   //   The process for determining whether an operand expression E1 of type T1
   //   can be converted to match an operand expression E2 of type T2 is defined
   //   as follows:
-  //   -- If E2 is an lvalue:
-  bool ToIsLvalue = To->isLValue();
-  if (ToIsLvalue) {
-    //   E1 can be converted to match E2 if E1 can be implicitly converted to
-    //   type "lvalue reference to T2", subject to the constraint that in the
-    //   conversion the reference must bind directly to E1.
-    QualType T = Self.Context.getLValueReferenceType(ToType);
+  //   -- If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
+  //      implicitly converted to type "lvalue reference to T2", subject to the
+  //      constraint that in the conversion the reference must bind directly to
+  //      E1.
+  //   -- If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
+  //      implicitly conveted to the type "rvalue reference to R2", subject to
+  //      the constraint that the reference must bind directly.
+  if (To->isLValue() || To->isXValue()) {
+    QualType T = To->isLValue() ? Self.Context.getLValueReferenceType(ToType)
+                                : Self.Context.getRValueReferenceType(ToType);
+
     InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
 
     InitializationSequence InitSeq(Self, Entity, Kind, From);
     if (InitSeq.isDirectReferenceBinding()) {
       ToType = T;
       HaveConversion = true;
       return false;
     }

test/SemaCXX/conditional-expr.cpp

 namespace PR17052 {
   struct X {
     int i_;
     bool b_;
 
     int &test() { return b_ ? i_ : throw 1; }
   };
 }
+
+namespace PR26448 {
+struct Base {};
+struct Derived : Base {};
+Base b;
+Derived d;
+typedef decltype(true ? static_cast<Base&&>(b) : static_cast<Derived&&>(d)) x;
+typedef Base &&x;
+}