test/SemaCXX/rval-references.cpp

   1 // RUN: clang-cc -fsyntax-only -verify -std=c++0x %s
   2
   3 typedef int&& irr;
   4 typedef irr& ilr_c1; // Collapses to int&
   5 typedef int& ilr;
   6 typedef ilr&& ilr_c2; // Collapses to int&
   7
   8 irr ret_irr() {
   9   return 0;
  10 }
  11
  12 struct not_int {};
  13
  14 int over(int&);
  15 not_int over(int&&);
  16
  17 int over2(const int&);
  18 not_int over2(int&&);
  19
  20 struct conv_to_not_int_rvalue {
  21   operator not_int &&();
  22 };
  23
  24 void f() {
  25   int &&virr1; // expected-error {{declaration of reference variable 'virr1' requires an initializer}}
  26   int &&virr2 = 0;
  27   int &&virr3 = virr2; // expected-error {{rvalue reference cannot bind to lvalue}}
  28   int i1 = 0;
  29   int &&virr4 = i1; // expected-error {{rvalue reference cannot bind to lvalue}}
  30   int &&virr5 = ret_irr();
  31   int &&virr6 = static_cast<int&&>(i1);
  32   (void)static_cast<not_int&&>(i1); // expected-error {{types are not compatible}}
  33
  34   int i2 = over(i1);
  35   not_int ni1 = over(0);
  36   int i3 = over(virr2);
  37   not_int ni2 = over(ret_irr());
  38
  39   int i4 = over2(i1);
  40   not_int ni3 = over2(0);
  41
  42   ilr_c1 vilr1 = i1;
  43   ilr_c2 vilr2 = i1;
  44
  45   conv_to_not_int_rvalue cnir;
  46   not_int &&ni4 = cnir; // expected-error {{rvalue reference cannot bind to lvalue}}
  47   not_int &ni5 = cnir; // expected-error{{non-const lvalue reference to type 'struct not_int' cannot be initialized with a value of type 'struct conv_to_not_int_rvalue'}}
  48   not_int &&ni6 = conv_to_not_int_rvalue();
  49
  50
  51   try {
  52   } catch(int&&) { // expected-error {{cannot catch exceptions by rvalue reference}}
  53   }
  54 }
  55
  56 int&& should_warn(int i) {
  57   // FIXME: The stack address return test doesn't reason about casts.
  58   return static_cast<int&&>(i); // xpected-warning {{returning reference to temporary}}
  59 }
  60 int&& should_not_warn(int&& i) { // But GCC 4.4 does
  61   return static_cast<int&&>(i);
  62 }
  63
  64
  65 // Test the return dance. This also tests IsReturnCopyElidable.
  66 struct MoveOnly {
  67   MoveOnly();
  68   MoveOnly(const MoveOnly&) = delete;
  69   MoveOnly(MoveOnly&&);
  70   MoveOnly(int&&);
  71 };
  72
  73 MoveOnly returning() {
  74   MoveOnly mo;
  75   return mo;
  76 }
  77
  78 MoveOnly gmo;
  79 MoveOnly returningNonEligible() {
  80   int i;
  81   static MoveOnly mo;
  82   MoveOnly &r = mo;
  83   if (0) // Copy from global can't be elided
  84     return gmo; // expected-error {{incompatible type returning}}
  85   else if (0) // Copy from local static can't be elided
  86     return mo; // expected-error {{incompatible type returning}}
  87   else if (0) // Copy from reference can't be elided
  88     return r; // expected-error {{incompatible type returning}}
  89   else // Construction from different type can't be elided
  90     return i; // expected-error {{incompatible type returning}}
  91 }