1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 int g(int);
3
f()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];
test2()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
test3()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
test4()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
test5()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
test6(int & x)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
test7(C & c)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
test8(int & const,void &,int & &)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
const_param(const T)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
test9()112 void test9() {
113 string &s = getInput(); // expected-error{{lvalue reference}}
114 }
115
test10()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;
X0PR7149::X0133 X0(T& p1) : first(p1) { }
134 };
135
136
f()137 void f()
138 {
139 int p1[1];
140 X0< const int[1]> c(p1);
141 }
142 }
143
144 namespace PR8608 {
f(unsigned char & c)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