| 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 |
namespace test0 { |
| 8 |
extern "C" int array[]; |
| 9 |
void declare() { extern int array[100]; } |
| 10 |
int value1 = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 11 |
extern "C" int array[]; |
| 12 |
int value2 = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 13 |
} |
| 14 |
|
| 15 |
namespace test1 { |
| 16 |
extern "C" int array[]; |
| 17 |
void test() { |
| 18 |
{ extern int array[100]; } |
| 19 |
extern int array[]; |
| 20 |
int x = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 21 |
} |
| 22 |
} |
| 23 |
|
| 24 |
namespace test2 { |
| 25 |
void declare() { extern int array[100]; } |
| 26 |
extern int array[]; |
| 27 |
int value = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 28 |
} |
| 29 |
|
| 30 |
namespace test3 { |
| 31 |
void test() { |
| 32 |
{ extern int array[100]; } |
| 33 |
extern int array[]; |
| 34 |
int x = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 35 |
} |
| 36 |
} |
| 37 |
|
| 38 |
namespace test4 { |
| 39 |
extern int array[]; |
| 40 |
void test() { |
| 41 |
extern int array[100]; |
| 42 |
int x = sizeof(array); |
| 43 |
} |
| 44 |
int y = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 45 |
} |
| 46 |
|
| 47 |
namespace test5 { |
| 48 |
void test() { |
| 49 |
extern int array[100]; |
| 50 |
extern int array[]; |
| 51 |
int x = sizeof(array); |
| 52 |
} |
| 53 |
} |
| 54 |
|
| 55 |
namespace test6 { |
| 56 |
void test() { |
| 57 |
extern int array[100]; |
| 58 |
{ |
| 59 |
extern int array[]; |
| 60 |
int x = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 61 |
} |
| 62 |
int y = sizeof(array); |
| 63 |
extern int array[]; |
| 64 |
int z = sizeof(array); |
| 65 |
} |
| 66 |
} |
| 67 |
|
| 68 |
namespace test7 { |
| 69 |
extern int array[100]; |
| 70 |
void test() { |
| 71 |
extern int array[]; |
| 72 |
int x = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 73 |
} |
| 74 |
int y = sizeof(array); |
| 75 |
extern int array[]; |
| 76 |
int z = sizeof(array); |
| 77 |
} |
| 78 |
|
| 79 |
namespace test8 { |
| 80 |
extern int array[]; |
| 81 |
void test() { |
| 82 |
extern int array[100]; |
| 83 |
int x = sizeof(array); |
| 84 |
} |
| 85 |
int y = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 86 |
extern int array[]; |
| 87 |
int z = sizeof(array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} |
| 88 |
} |
| 89 |
|
| 90 |
namespace dependent { |
| 91 |
template<typename T> void f() { |
| 92 |
extern int arr1[]; |
| 93 |
extern T arr1; |
| 94 |
extern T arr2; |
| 95 |
extern int arr2[]; |
| 96 |
static_assert(sizeof(arr1) == 12, ""); |
| 97 |
static_assert(sizeof(arr2) == 12, ""); |
| 98 |
|
| 99 |
// Use a failing test to ensure the type isn't considered dependent. |
| 100 |
static_assert(sizeof(arr2) == 13, ""); // expected-error {{failed}} \ |
| 101 |
// expected-note {{evaluates to '12 == 13'}} |
| 102 |
} |
| 103 |
|
| 104 |
void g() { f<int[3]>(); } // expected-note {{in instantiation of}} |
| 105 |
|
| 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 |
|
| 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 |
|
| 130 |
void i() { |
| 131 |
h1<int[3]>(); |
| 132 |
h2<int[]>(); // expected-note {{in instantiation of}} |
| 133 |
} |
| 134 |
|
| 135 |
int arr5[3]; |
| 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 |
|
| 144 |
void k() { j<int[]>(); } // expected-note {{in instantiation of}} |
| 145 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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(); |
| 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]; |
| 188 |
void f() { |
| 189 |
extern int a[]; |
| 190 |
extern int b[3]; |
| 191 |
} |
| 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 { |
| 204 |
int g() { return sizeof(a); } |
| 205 |
int h() { return sizeof(b); } // expected-error {{incomplete}} |
| 206 |
int i() { return sizeof(c); } |
| 207 |
int j() { return sizeof(d); } |
| 208 |
} |
| 209 |
} |
| 210 |
|
| 211 |
extern int arr[]; |
| 212 |
void f1() { extern int arr[2]; } // expected-note {{previous}} |
| 213 |
void f2() { extern int arr[3]; } // expected-error {{different type: 'int[3]' vs 'int[2]'}} |