[Sema] Allow static_cast<T&&>(e) to check explicit conversions for non-reference-related types.

[EricWF]

Summary

[expr.cast.static] states:

3. A glvalue of type “cv1 T1” can be cast to type “rvalue reference to cv2 T2” if “cv2 T2” is reference-compatible

with “cv1 T1”. The result refers to the object or the specified base class subobject thereof. If T2 is
an inaccessible or ambiguous base class of T1, a program that necessitates such a cast is
ill-formed.

4. Otherwise, an expression e can be explicitly converted to a type T using a static_cast of the form static_-

cast<T>(e) if the declaration T t(e); is well-formed, for some invented temporary variable t. [...]

Currently when checking p3 Clang will diagnose static_cast<T&&>(e) as invalid if the argument is not reference compatible with T. However I believe the correct behavior is to also check p4 in those cases. For example:

double y = 42;
static_cast<int&&>(y); // this should be OK.  'int&& t(y)' is well formed

Note that we still don't check p4 for non-reference-compatible types which are reference-related since T&& t(e); should never be well formed in those cases.

[EricWF]

The C++1z wording here is much different than the C++11 wording I was looking at earlier. I'm going to re-adjust this patch to target the new C++1z wording. I'm also planning to add a test under test/CXX/expr/expr.post/expr.static.cast.

[EricWF]

• Add tests under test/CXX
• Add FIXME regarding the C++1z change from glvalue to lvalue in p3.

[rsmith]

include/clang/Basic/DiagnosticSemaKinds.td

5946

Delete the first "reference" here. We're never casting from a reference (there are no expressions of reference type).

lib/Sema/SemaCast.cpp

1148

Actually, it does, but it's covered by p4. (p3 now only covers the special lvalue->xvalue case for static_cast, which is not permitted by p4.) It's fine for us to still handle this here, or to allow the p4 case to deal with it instead. It's probably better to keep handling it here, since we produce better diagnostics this way.

1171–1173

OK, so the idea here is that p4 will never apply in a case where the reference is reference-related to the source but not reference-compatible, and no other rules would let us static_cast to reference type? It would be good to add a comment explaining that, since it's not immediately obvious.

test/CXX/expr/expr.post/expr.static.cast/p3-p4-0x.cpp

29

It'd be good to also have some negative tests here, for cases like

A &&ar8 = static_cast<A&&>(prvalue<const A>());

[EricWF]

lib/Sema/SemaCast.cpp

1148

Cool sounds good. I knew p4 would end up handling it, but I wasn't sure if forwarding to p4 would allow previously ill-formed conversions. I tried to construct such a case but couldn't.

1171–1173

That's my understanding. I'll add a comment.

include/clang/Basic/DiagnosticSemaKinds.td

   "%select{||reinterpret_cast||C-style cast|}0 from scalar %1 " 
   "to vector %2 of different size">;
 def err_bad_cxx_cast_vector_to_vector_different_size : Error<
   "%select{||reinterpret_cast||C-style cast|}0 from vector %1 " 
   "to vector %2 of different size">;
 def err_bad_lvalue_to_rvalue_cast : Error<
   "cannot cast from lvalue of type %1 to rvalue reference type %2; types are "
   "not compatible">;
+def err_bad_rvalue_to_rvalue_cast : Error<
+  "cannot cast from rvalue reference of type %1 to rvalue reference type %2; types are "
+  "not compatible">;
 def err_bad_static_cast_pointer_nonpointer : Error<
   "cannot cast from type %1 to pointer type %2">;
 def err_bad_static_cast_member_pointer_nonmp : Error<
   "cannot cast from type %1 to member pointer type %2">;
 def err_bad_cxx_cast_member_pointer_size : Error<
   "cannot %select{||reinterpret_cast||C-style cast|}0 from member pointer "
   "type %1 to member pointer type %2 of different size">;
 def err_bad_reinterpret_cast_reference : Error<

lib/Sema/SemaCast.cpp

           DestPointer->getPointeeType()->getAs<RecordType>())
        msg = diag::err_bad_cxx_cast_unrelated_class;
   
   // We tried everything. Everything! Nothing works! :-(
   return TC_NotApplicable;
 }
 
 /// Tests whether a conversion according to N2844 is valid.
-TryCastResult
-TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType,
-                      bool CStyle, CastKind &Kind, CXXCastPath &BasePath, 
+TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr,
+                                    QualType DestType, bool CStyle,
+                                    CastKind &Kind, CXXCastPath &BasePath,
                                     unsigned &msg) {
   // C++11 [expr.static.cast]p3:
   //   A glvalue of type "cv1 T1" can be cast to type "rvalue reference to
   //   cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1".
   const RValueReferenceType *R = DestType->getAs<RValueReferenceType>();
   if (!R)
     return TC_NotApplicable;
 
+  // FIXME C++1z doesn't allow this conversions for xvalues.
   if (!SrcExpr->isGLValue())
     return TC_NotApplicable;
 
   // Because we try the reference downcast before this function, from now on
   // this is the only cast possibility, so we issue an error if we fail now.
   // FIXME: Should allow casting away constness if CStyle.
   bool DerivedToBase;
   bool ObjCConversion;
   bool ObjCLifetimeConversion;
   QualType FromType = SrcExpr->getType();
   QualType ToType = R->getPointeeType();
   if (CStyle) {
     FromType = FromType.getUnqualifiedType();
     ToType = ToType.getUnqualifiedType();
   }
 
-  if (Self.CompareReferenceRelationship(SrcExpr->getLocStart(),
-                                        ToType, FromType,
-                                        DerivedToBase, ObjCConversion,
-                                        ObjCLifetimeConversion) 
-        != Sema::Ref_Compatible) {
-    if (CStyle)
+  Sema::ReferenceCompareResult RefResult = Self.CompareReferenceRelationship(
+      SrcExpr->getLocStart(), ToType, FromType, DerivedToBase, ObjCConversion,
+      ObjCLifetimeConversion);
+  if (RefResult != Sema::Ref_Compatible) {
+    if (CStyle || RefResult == Sema::Ref_Incompatible)
       return TC_NotApplicable;
-    msg = diag::err_bad_lvalue_to_rvalue_cast;
+    msg = SrcExpr->isLValue() ? diag::err_bad_lvalue_to_rvalue_cast
+                              : diag::err_bad_rvalue_to_rvalue_cast;
     return TC_Failed;
   }
 
   if (DerivedToBase) {
     Kind = CK_DerivedToBase;
     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
                        /*DetectVirtual=*/true);
     if (!Self.IsDerivedFrom(SrcExpr->getLocStart(), SrcExpr->getType(),
                             R->getPointeeType(), Paths))

test/CXX/expr/expr.post/expr.static.cast/p3-p4-0x.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+// p3
+// A glvalue of type "cv1 T1" can be cast to type "rvalue reference to
+// cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1" (8.5.3).
+// p4
+// Otherwise, an expression e can be explicitly converted to a type T using a
+// static_cast of the form static_cast<T>(e) if the declaration T t(e); is
+// well-formed, for some invented temporary variable t (8.5). [...]
+struct A { };
+struct B : A { };
+
+struct C { explicit operator A&&(); };
+struct D { operator B(); };
+
+template<typename T> T& lvalue();
+template<typename T> T&& xvalue();
+template <typename T> T prvalue();
+
+void test(A &a, B &b) {
+  A &&ar0 = static_cast<A&&>(prvalue<A>());
+  A &&ar1 = static_cast<A&&>(prvalue<B>());
+  A &&ar2 = static_cast<A&&>(lvalue<C>());
+  A &&ar3 = static_cast<A&&>(xvalue<C>());
+  A &&ar4 = static_cast<A&&>(prvalue<C>());
+  A &&ar5 = static_cast<A&&>(lvalue<D>());
+  A &&ar6 = static_cast<A&&>(xvalue<D>());
+  A &&ar7 = static_cast<A&&>(prvalue<D>());
+
+  const A &&ar8 = static_cast<const A&&>(prvalue<A>());
+  const A &&ar9 = static_cast<const A&&>(prvalue<B>());
+  const A &&ar10 = static_cast<const A&&>(lvalue<C>());
+  const A &&ar11 = static_cast<const A&&>(xvalue<C>());
+  const A &&ar12 = static_cast<const A&&>(prvalue<C>());
+  const A &&ar13 = static_cast<const A&&>(lvalue<D>());
+}

test/SemaCXX/rval-references.cpp

 void fun();
 fun_type &&make_fun();
 
 void f() {
   int &&virr1; // expected-error {{declaration of reference variable 'virr1' requires an initializer}}
   int &&virr2 = 0;
   int &&virr3 = virr2; // expected-error {{rvalue reference to type 'int' cannot bind to lvalue of type 'int'}}
   int i1 = 0;
+  const double d1 = 0;
+  const int ci1 = 1;
   int &&virr4 = i1; // expected-error {{rvalue reference to type 'int' cannot bind to lvalue of type 'int'}}
   int &&virr5 = ret_irr();
   int &&virr6 = static_cast<int&&>(i1);
-  (void)static_cast<not_int&&>(i1); // expected-error {{types are not compatible}}
-
+  (void)static_cast<not_int &&>(i1); // expected-error {{reference to type 'not_int' could not bind to an lvalue of type 'int'}}
+  (void)static_cast<int &&>(static_cast<int const&&>(i1)); // expected-error {{cannot cast from rvalue reference of type 'const int' to rvalue reference type 'int &&'}}
+  (void)static_cast<int &&>(ci1);    // expected-error {{types are not compatible}}
+  (void)static_cast<int &&>(d1);
   int i2 = over(i1);
   not_int ni1 = over(0);
   int i3 = over(virr2);
   not_int ni2 = over(ret_irr());
 
   int i4 = over2(i1);
   not_int ni3 = over2(0);