Home | History | Annotate | Download | only in SemaCXX
      1 // RUN: %clang_cc1 -fsyntax-only -verify %s
      2 int g(int);
      3 
      4 void f() {
      5   int i;
      6   int &r = i;
      7   r = 1;
      8   int *p = &r;
      9   int &rr = r;
     10   int (&rg)(int) = g;
     11   rg(i);
     12   int a[3];
     13   int (&ra)[3] = a;
     14   ra[1] = i;
     15   int *Q;
     16   int *& P = Q;
     17   P[1] = 1;
     18 }
     19 
     20 typedef int t[1];
     21 void test2() {
     22     t a;
     23     t& b = a;
     24 
     25 
     26     int c[3];
     27     int (&rc)[3] = c;
     28 }
     29 
     30 // C++ [dcl.init.ref]p5b1
     31 struct A { };
     32 struct B : A { } b;
     33 
     34 void test3() {
     35   double d = 2.0;
     36   double& rd = d; // rd refers to d
     37   const double& rcd = d; // rcd refers to d
     38 
     39   A& ra = b; // ra refers to A subobject in b
     40   const A& rca = b; // rca refers to A subobject in b
     41 }
     42 
     43 B fB();
     44 
     45 // C++ [dcl.init.ref]p5b2
     46 void test4() {
     47   double& rd2 = 2.0; // expected-error{{non-const lvalue reference to type 'double' cannot bind to a temporary of type 'double'}}
     48   int i = 2;
     49   double& rd3 = i; // expected-error{{non-const lvalue reference to type 'double' cannot bind to a value of unrelated type 'int'}}
     50 
     51   const A& rca = fB();
     52 }
     53 
     54 void test5() {
     55   //  const double& rcd2 = 2; // rcd2 refers to temporary with value 2.0
     56   const volatile int cvi = 1;
     57   const int& r = cvi; // expected-error{{binding value of type 'const volatile int' to reference to type 'const int' drops 'volatile' qualifier}}
     58 }
     59 
     60 // C++ [dcl.init.ref]p3
     61 int& test6(int& x) {
     62   int& yo; // expected-error{{declaration of reference variable 'yo' requires an initializer}}
     63 
     64   return x;
     65 }
     66 int& not_initialized_error; // expected-error{{declaration of reference variable 'not_initialized_error' requires an initializer}}
     67 extern int& not_initialized_okay;
     68 
     69 class Test6 { // expected-warning{{class 'Test6' does not declare any constructor to initialize its non-modifiable members}}
     70   int& okay; // expected-note{{reference member 'okay' will never be initialized}}
     71 };
     72 
     73 struct C : B, A { }; // expected-warning {{direct base 'A' is inaccessible due to ambiguity:\n    struct C -> struct B -> struct A\nstruct C -> struct A}}
     74 
     75 void test7(C& c) {
     76   A& a1 = c; // expected-error {{ambiguous conversion from derived class 'C' to base class 'A':}}
     77 }
     78 
     79 // C++ [dcl.ref]p1, C++ [dcl.ref]p4
     80 void test8(int& const,// expected-error{{'const' qualifier may not be applied to a reference}}
     81 
     82            void&,     // expected-error{{cannot form a reference to 'void'}}
     83            int& &)    // expected-error{{type name declared as a reference to a reference}}
     84 {
     85   typedef int& intref;
     86   typedef intref& intrefref; // C++ DR 106: reference collapsing
     87 
     88   typedef intref const intref_c; // expected-warning {{'const' qualifier on reference type 'intref' (aka 'int &') has no effect}}
     89   typedef intref_c intref; // ok, same type
     90 
     91   typedef intref volatile intref; // expected-warning {{'volatile' qualifier on reference type 'intref' (aka 'int &') has no effect}}
     92   typedef intref _Atomic intref; // expected-warning {{'_Atomic' qualifier on reference type 'intref' (aka 'int &') has no effect}}
     93 
     94   void restrict_ref(__restrict intref); // ok
     95   void restrict_ref(int &__restrict); // ok
     96 }
     97 
     98 template<typename T> int const_param(const T) {}
     99 int const_ref_param = const_param<int&>(const_ref_param); // no-warning
    100 
    101 
    102 class string {
    103   char *Data;
    104   unsigned Length;
    105 public:
    106   string();
    107   ~string();
    108 };
    109 
    110 string getInput();
    111 
    112 void test9() {
    113   string &s = getInput(); // expected-error{{lvalue reference}}
    114 }
    115 
    116 void test10() {
    117   __attribute((vector_size(16))) typedef int vec4;
    118   typedef __attribute__(( ext_vector_type(4) )) int ext_vec4;
    119 
    120   vec4 v;
    121   int &a = v[0]; // expected-error{{non-const reference cannot bind to vector element}}
    122   const int &b = v[0];
    123 
    124   ext_vec4 ev;
    125   int &c = ev.x; // expected-error{{non-const reference cannot bind to vector element}}
    126   const int &d = ev.x;
    127 }
    128 
    129 namespace PR7149 {
    130   template<typename T> struct X0
    131   {
    132     T& first;
    133     X0(T& p1) : first(p1) { }
    134   };
    135 
    136 
    137   void f()
    138   {
    139     int p1[1];
    140     X0< const int[1]> c(p1);
    141   }
    142 }
    143 
    144 namespace PR8608 {
    145   bool& f(unsigned char& c) { return (bool&)c; }
    146 }
    147 
    148 // The following crashed trying to recursively evaluate the LValue.
    149 const int &do_not_crash = do_not_crash; // expected-warning{{reference 'do_not_crash' is not yet bound to a value when used within its own initialization}}
    150 
    151 namespace ExplicitRefInit {
    152   // This is invalid: we can't copy-initialize an 'A' temporary using an
    153   // explicit constructor.
    154   struct A { explicit A(int); };
    155   const A &a(0); // expected-error {{reference to type 'const ExplicitRefInit::A' could not bind to an rvalue of type 'int'}}
    156 }
    157