1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++1y -triple x86_64-linux-gnu %s 2 3 // If there is a preceding declaration of the entity *in the same scope* in 4 // which the bound was specified, an omitted array bound is taken to be the 5 // same as in that earlier declaration 6 7 // rdar://13535367 8 namespace test0 { 9 extern "C" int array[]; declare()10 void declare() { extern int array[100]; } 11 int value1 = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 12 extern "C" int array[]; 13 int value2 = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 14 } 15 16 namespace test1 { 17 extern "C" int array[]; test()18 void test() { 19 { extern int array[100]; } 20 extern int array[]; 21 int x = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 22 } 23 } 24 25 namespace test2 { declare()26 void declare() { extern int array[100]; } 27 extern int array[]; 28 int value = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 29 } 30 31 namespace test3 { test()32 void test() { 33 { extern int array[100]; } 34 extern int array[]; 35 int x = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 36 } 37 } 38 39 namespace test4 { 40 extern int array[]; test()41 void test() { 42 extern int array[100]; 43 int x = sizeof(array); 44 } 45 int y = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 46 } 47 48 namespace test5 { test()49 void test() { 50 extern int array[100]; 51 extern int array[]; 52 int x = sizeof(array); 53 } 54 } 55 56 namespace test6 { test()57 void test() { 58 extern int array[100]; 59 { 60 extern int array[]; 61 int x = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 62 } 63 int y = sizeof(array); 64 extern int array[]; 65 int z = sizeof(array); 66 } 67 } 68 69 namespace test7 { 70 extern int array[100]; test()71 void test() { 72 extern int array[]; 73 int x = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 74 } 75 int y = sizeof(array); 76 extern int array[]; 77 int z = sizeof(array); 78 } 79 80 namespace test8 { 81 extern int array[]; test()82 void test() { 83 extern int array[100]; 84 int x = sizeof(array); 85 } 86 int y = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 87 extern int array[]; 88 int z = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}} 89 } 90 91 namespace dependent { f()92 template<typename T> void f() { 93 extern int arr1[]; 94 extern T arr1; 95 extern T arr2; 96 extern int arr2[]; 97 static_assert(sizeof(arr1) == 12, ""); 98 static_assert(sizeof(arr2) == 12, ""); 99 100 // Use a failing test to ensure the type isn't considered dependent. 101 static_assert(sizeof(arr2) == 13, ""); // expected-error {{failed}} 102 } 103 g()104 void g() { f<int[3]>(); } // expected-note {{in instantiation of}} 105 h1()106 template<typename T> void h1() { 107 extern T arr3; 108 { 109 int arr3; 110 { 111 extern int arr3[]; 112 // Detected in template definition. 113 (void)sizeof(arr3); // expected-error {{incomplete}} 114 } 115 } 116 } 117 h2()118 template<typename T> void h2() { 119 extern int arr4[3]; 120 { 121 int arr4; 122 { 123 extern T arr4; 124 // Detected in template instantiation. 125 (void)sizeof(arr4); // expected-error {{incomplete}} 126 } 127 } 128 } 129 i()130 void i() { 131 h1<int[3]>(); 132 h2<int[]>(); // expected-note {{in instantiation of}} 133 } 134 135 int arr5[3]; j()136 template<typename T> void j() { 137 extern T arr5; 138 extern T arr6; 139 (void)sizeof(arr5); // expected-error {{incomplete}} 140 (void)sizeof(arr6); // expected-error {{incomplete}} 141 } 142 int arr6[3]; 143 k()144 void k() { j<int[]>(); } // expected-note {{in instantiation of}} 145 l()146 template<typename T, typename U> void l() { 147 extern T arrX; // expected-note {{previous}} 148 extern U arrX; // expected-error {{different type: 'int [4]' vs 'int [3]'}} 149 (void)sizeof(arrX); // expected-error {{incomplete}} 150 } 151 m()152 void m() { 153 l<int[], int[3]>(); // ok 154 l<int[3], int[]>(); // ok 155 l<int[3], int[3]>(); // ok 156 l<int[3], int[4]>(); // expected-note {{in instantiation of}} 157 l<int[], int[]>(); // expected-note {{in instantiation of}} 158 } 159 n()160 template<typename T> void n() { 161 extern T n_var; // expected-error {{redeclaration of 'n_var' with a different type: 'double' vs 'int'}} expected-note {{previous}} 162 extern T n_fn(); // expected-error {{functions that differ only in their return type cannot be overloaded}} expected-note {{previous}} 163 } 164 template void n<int>(); 165 template void n<double>(); // expected-note {{in instantiation of}} 166 o()167 template<typename T> void o() { 168 extern T o_var; // expected-note {{previous}} 169 extern T o_fn(); // expected-note {{previous}} 170 } 171 template void o<int>(); 172 float o_var; // expected-error {{redefinition of 'o_var' with a different type: 'float' vs 'int'}} 173 float o_fn(); // expected-error {{functions that differ only in their return type cannot be overloaded}} 174 175 int p_var; 176 int p_fn(); p()177 template<typename T> void p() { 178 extern T p_var; 179 extern T p_fn(); 180 } 181 } 182 183 namespace use_outside_ns { 184 namespace A { 185 extern int a[3]; 186 extern int b[]; 187 extern int c[3]; f()188 void f() { 189 extern int a[]; 190 extern int b[3]; 191 } x()192 template<typename T> void x() { 193 extern T c; 194 extern T d; 195 } 196 extern int d[3]; 197 template void x<int[]>(); 198 } 199 int w = sizeof(A::a); 200 int x = sizeof(A::b); // expected-error {{incomplete}} 201 int y = sizeof(A::c); 202 int z = sizeof(A::d); 203 namespace A { g()204 int g() { return sizeof(a); } h()205 int h() { return sizeof(b); } // expected-error {{incomplete}} i()206 int i() { return sizeof(c); } j()207 int j() { return sizeof(d); } 208 } 209 } 210