test/SemaCXX/rval-references.cpp

   1 // RUN: %clang_cc1 -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; // expected-warning {{returning reference to local temporary}}
  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 typedef void (fun_type)();
  25 void fun();
  26 fun_type &&make_fun();
  27
  28 void f() {
  29   int &&virr1; // expected-error {{declaration of reference variable 'virr1' requires an initializer}}
  30   int &&virr2 = 0;
  31   int &&virr3 = virr2; // expected-error {{rvalue reference cannot bind to lvalue}}
  32   int i1 = 0;
  33   int &&virr4 = i1; // expected-error {{rvalue reference cannot bind to lvalue}}
  34   int &&virr5 = ret_irr();
  35   int &&virr6 = static_cast<int&&>(i1);
  36   (void)static_cast<not_int&&>(i1); // expected-error {{types are not compatible}}
  37
  38   int i2 = over(i1);
  39   not_int ni1 = over(0);
  40   int i3 = over(virr2);
  41   not_int ni2 = over(ret_irr());
  42
  43   int i4 = over2(i1);
  44   not_int ni3 = over2(0);
  45
  46   ilr_c1 vilr1 = i1;
  47   ilr_c2 vilr2 = i1;
  48
  49   conv_to_not_int_rvalue cnir;
  50   not_int &&ni4 = cnir; // expected-error {{rvalue reference cannot bind to lvalue}}
  51   not_int &ni5 = cnir; // expected-error{{non-const lvalue reference to type 'not_int' cannot bind to a value of unrelated type 'conv_to_not_int_rvalue'}}
  52   not_int &&ni6 = conv_to_not_int_rvalue();
  53
  54   fun_type &&fun_ref = fun; // works because functions are special
  55   fun_type &&fun_ref2 = make_fun(); // same
  56   fun_type &fun_lref = make_fun(); // also special
  57
  58   try {
  59   } catch(int&&) { // expected-error {{cannot catch exceptions by rvalue reference}}
  60   }
  61 }
  62
  63 int&& should_warn(int i) {
  64   // FIXME: The stack address return test doesn't reason about casts.
  65   return static_cast<int&&>(i); // xpected-warning {{returning reference to temporary}}
  66 }
  67 int&& should_not_warn(int&& i) { // But GCC 4.4 does
  68   return static_cast<int&&>(i);
  69 }
  70
  71
  72 // Test the return dance. This also tests IsReturnCopyElidable.
  73 struct MoveOnly {
  74   MoveOnly();
  75   MoveOnly(const MoveOnly&) = delete;   // expected-note {{candidate constructor}} \
  76   // expected-note 3{{explicitly marked deleted here}}
  77   MoveOnly(MoveOnly&&); // expected-note {{candidate constructor}}
  78   MoveOnly(int&&);      // expected-note {{candidate constructor}}
  79 };
  80
  81 MoveOnly gmo;
  82 MoveOnly returningNonEligible() {
  83   int i;
  84   static MoveOnly mo;
  85   MoveOnly &r = mo;
  86   if (0) // Copy from global can't be elided
  87     return gmo; // expected-error {{call to deleted constructor}}
  88   else if (0) // Copy from local static can't be elided
  89     return mo; // expected-error {{call to deleted constructor}}
  90   else if (0) // Copy from reference can't be elided
  91     return r; // expected-error {{call to deleted constructor}}
  92   else // Construction from different type can't be elided
  93     return i; // expected-error {{no viable conversion from 'int' to 'MoveOnly'}}
  94 }