1// RUN: %clang_cc1 -fsyntax-only -verify %s
2int g(int);
3
4void 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
20typedef int t[1];
21void 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
31struct A { };
32struct B : A { } b;
33
34void 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
43B fB();
44
45// C++ [dcl.init.ref]p5b2
46void 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
54void 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 of reference to type 'const int' to a value of type 'const volatile int' drops qualifiers}}
58}
59
60// C++ [dcl.init.ref]p3
61int& test6(int& x) {
62  int& yo; // expected-error{{declaration of reference variable 'yo' requires an initializer}}
63
64  return x;
65}
66int& not_initialized_error; // expected-error{{declaration of reference variable 'not_initialized_error' requires an initializer}}
67extern int& not_initialized_okay;
68
69class 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
73struct C : B, A { };
74
75void 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
80void 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; // okay. FIXME: how do we verify that this is the same type as intref?
89}
90
91
92class string {
93  char *Data;
94  unsigned Length;
95public:
96  string();
97  ~string();
98};
99
100string getInput();
101
102void test9() {
103  string &s = getInput(); // expected-error{{lvalue reference}}
104}
105
106void test10() {
107  __attribute((vector_size(16))) typedef int vec4;
108  typedef __attribute__(( ext_vector_type(4) )) int ext_vec4;
109
110  vec4 v;
111  int &a = v[0]; // expected-error{{non-const reference cannot bind to vector element}}
112  const int &b = v[0];
113
114  ext_vec4 ev;
115  int &c = ev.x; // expected-error{{non-const reference cannot bind to vector element}}
116  const int &d = ev.x;
117}
118
119namespace PR7149 {
120  template<typename T> struct X0
121  {
122    T& first;
123    X0(T& p1) : first(p1) { }
124  };
125
126
127  void f()
128  {
129    int p1[1];
130    X0< const int[1]> c(p1);
131  }
132}
133
134namespace PR8608 {
135  bool& f(unsigned char& c) { return (bool&)c; }
136}
137
138// The following crashed trying to recursively evaluate the LValue.
139const 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}}
140
141namespace ExplicitRefInit {
142  // This is invalid: we can't copy-initialize an 'A' temporary using an
143  // explicit constructor.
144  struct A { explicit A(int); };
145  const A &a(0); // expected-error {{reference to type 'const ExplicitRefInit::A' could not bind to an rvalue of type 'int'}}
146}
147