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; // 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
98template<typename T> int const_param(const T) {}
99int const_ref_param = const_param<int&>(const_ref_param); // no-warning
100
101
102class string {
103  char *Data;
104  unsigned Length;
105public:
106  string();
107  ~string();
108};
109
110string getInput();
111
112void test9() {
113  string &s = getInput(); // expected-error{{lvalue reference}}
114}
115
116void 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
129namespace 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
144namespace PR8608 {
145  bool& f(unsigned char& c) { return (bool&)c; }
146}
147
148// The following crashed trying to recursively evaluate the LValue.
149const 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
151namespace 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