1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 2 3 typedef double A; 4 template<typename T> class B { 5 typedef int A; 6 }; 7 8 template<typename T> struct X : B<T> { 9 static A a; 10 }; 11 12 int a0[sizeof(X<int>::a) == sizeof(double) ? 1 : -1]; 13 14 // PR4365. 15 template<class T> class Q; 16 template<class T> class R : Q<T> {T current;}; 17 18 19 namespace test0 { 20 template <class T> class Base { 21 public: 22 void instance_foo(); 23 static void static_foo(); 24 class Inner { 25 public: 26 void instance_foo(); 27 static void static_foo(); 28 }; 29 }; 30 31 template <class T> class Derived1 : Base<T> { 32 public: 33 void test0() { 34 Base<T>::static_foo(); 35 Base<T>::instance_foo(); 36 } 37 38 void test1() { 39 Base<T>::Inner::static_foo(); 40 Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}} 41 } 42 43 static void test2() { 44 Base<T>::static_foo(); 45 Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}} 46 } 47 48 static void test3() { 49 Base<T>::Inner::static_foo(); 50 Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}} 51 } 52 }; 53 54 template <class T> class Derived2 : Base<T>::Inner { 55 public: 56 void test0() { 57 Base<T>::static_foo(); 58 Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}} 59 } 60 61 void test1() { 62 Base<T>::Inner::static_foo(); 63 Base<T>::Inner::instance_foo(); 64 } 65 66 static void test2() { 67 Base<T>::static_foo(); 68 Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}} 69 } 70 71 static void test3() { 72 Base<T>::Inner::static_foo(); 73 Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}} 74 } 75 }; 76 77 void test0() { 78 Derived1<int> d1; 79 d1.test0(); 80 d1.test1(); // expected-note {{in instantiation of member function}} 81 d1.test2(); // expected-note {{in instantiation of member function}} 82 d1.test3(); // expected-note {{in instantiation of member function}} 83 84 Derived2<int> d2; 85 d2.test0(); // expected-note {{in instantiation of member function}} 86 d2.test1(); 87 d2.test2(); // expected-note {{in instantiation of member function}} 88 d2.test3(); // expected-note {{in instantiation of member function}} 89 } 90 } 91 92 namespace test1 { 93 template <class T> struct Base { 94 void foo(T); // expected-note {{must qualify identifier to find this declaration in dependent base class}} 95 }; 96 97 template <class T> struct Derived : Base<T> { 98 void doFoo(T v) { 99 foo(v); // expected-error {{use of undeclared identifier}} 100 } 101 }; 102 103 template struct Derived<int>; // expected-note {{requested here}} 104 } 105 106 namespace PR8966 { 107 template <class T> 108 class MyClassCore 109 { 110 }; 111 112 template <class T> 113 class MyClass : public MyClassCore<T> 114 { 115 public: 116 enum { 117 N 118 }; 119 120 // static member declaration 121 static const char* array [N]; 122 123 void f() { 124 MyClass<T>::InBase = 17; 125 } 126 }; 127 128 // static member definition 129 template <class T> 130 const char* MyClass<T>::array [MyClass<T>::N] = { "A", "B", "C" }; 131 } 132 133 namespace std { 134 inline namespace v1 { 135 template<typename T> struct basic_ostream; 136 } 137 namespace inner { 138 template<typename T> struct vector {}; 139 } 140 using inner::vector; 141 template<typename T, typename U> struct pair {}; 142 typedef basic_ostream<char> ostream; 143 extern ostream cout; 144 std::ostream &operator<<(std::ostream &out, const char *); 145 } 146 147 namespace PR10053 { 148 template<typename T> struct A { 149 T t; 150 A() { 151 f(t); // expected-error {{call to function 'f' that is neither visible in the template definition nor found by argument-dependent lookup}} 152 } 153 }; 154 155 void f(int&); // expected-note {{'f' should be declared prior to the call site}} 156 157 A<int> a; // expected-note {{in instantiation of member function}} 158 159 160 namespace N { 161 namespace M { 162 template<typename T> int g(T t) { 163 f(t); // expected-error {{call to function 'f' that is neither visible in the template definition nor found by argument-dependent lookup}} 164 }; 165 } 166 167 void f(char&); // expected-note {{'f' should be declared prior to the call site}} 168 } 169 170 void f(char&); 171 172 int k = N::M::g<char>(0);; // expected-note {{in instantiation of function}} 173 174 175 namespace O { 176 void f(char&); // expected-note {{candidate function not viable}} 177 178 template<typename T> struct C { 179 static const int n = f(T()); // expected-error {{no matching function}} 180 }; 181 } 182 183 int f(double); // no note, shadowed by O::f 184 O::C<double> c; // expected-note {{requested here}} 185 186 187 // Example from www/compatibility.html 188 namespace my_file { 189 template <typename T> T Squared(T x) { 190 return Multiply(x, x); // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}} 191 } 192 193 int Multiply(int x, int y) { // expected-note {{should be declared prior to the call site}} 194 return x * y; 195 } 196 197 int main() { 198 Squared(5); // expected-note {{here}} 199 } 200 } 201 202 // Example from www/compatibility.html 203 namespace my_file2 { 204 template<typename T> 205 void Dump(const T& value) { 206 std::cout << value << "\n"; // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}} 207 } 208 209 namespace ns { 210 struct Data {}; 211 } 212 213 std::ostream& operator<<(std::ostream& out, ns::Data data) { // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2::ns'}} 214 return out << "Some data"; 215 } 216 217 void Use() { 218 Dump(ns::Data()); // expected-note {{here}} 219 } 220 } 221 222 namespace my_file2_a { 223 template<typename T> 224 void Dump(const T &value) { 225 print(std::cout, value); // expected-error 4{{neither visible in the template definition nor found by argument-dependent lookup}} 226 } 227 228 namespace ns { 229 struct Data {}; 230 } 231 namespace ns2 { 232 struct Data {}; 233 } 234 235 std::ostream &print(std::ostream &out, int); // expected-note-re {{should be declared prior to the call site{{$}}}} 236 std::ostream &print(std::ostream &out, ns::Data); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns'}} 237 std::ostream &print(std::ostream &out, std::vector<ns2::Data>); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns2'}} 238 std::ostream &print(std::ostream &out, std::pair<ns::Data, ns2::Data>); // expected-note {{should be declared prior to the call site or in an associated namespace of one of its arguments}} 239 240 void Use() { 241 Dump(0); // expected-note {{requested here}} 242 Dump(ns::Data()); // expected-note {{requested here}} 243 Dump(std::vector<ns2::Data>()); // expected-note {{requested here}} 244 Dump(std::pair<ns::Data, ns2::Data>()); // expected-note {{requested here}} 245 } 246 } 247 248 namespace unary { 249 template<typename T> 250 T Negate(const T& value) { 251 return !value; // expected-error {{call to function 'operator!' that is neither visible in the template definition nor found by argument-dependent lookup}} 252 } 253 254 namespace ns { 255 struct Data {}; 256 } 257 258 ns::Data operator!(ns::Data); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::unary::ns'}} 259 260 void Use() { 261 Negate(ns::Data()); // expected-note {{requested here}} 262 } 263 } 264 } 265 266 namespace PR10187 { 267 namespace A1 { 268 template<typename T> 269 struct S { 270 void f() { 271 for (auto &a : e) 272 __range(a); // expected-error {{undeclared identifier '__range'}} 273 } 274 int e[10]; 275 }; 276 void g() { 277 S<int>().f(); // expected-note {{here}} 278 } 279 } 280 281 namespace A2 { 282 template<typename T> 283 struct S { 284 void f() { 285 for (auto &a : e) 286 __range(a); // expected-error {{undeclared identifier '__range'}} 287 } 288 T e[10]; 289 }; 290 void g() { 291 S<int>().f(); // expected-note {{here}} 292 } 293 struct X {}; 294 void __range(X); 295 void h() { 296 S<X>().f(); 297 } 298 } 299 300 namespace B { 301 template<typename T> void g(); // expected-note {{not viable}} 302 template<typename T> void f() { 303 g<int>(T()); // expected-error {{no matching function}} 304 } 305 306 namespace { 307 struct S {}; 308 } 309 void g(S); 310 311 template void f<S>(); // expected-note {{here}} 312 } 313 } 314 315 namespace rdar11242625 { 316 317 template <typename T> 318 struct Main { 319 struct default_names { 320 typedef int id; 321 }; 322 323 template <typename T2 = typename default_names::id> 324 struct TS { 325 T2 q; 326 }; 327 }; 328 329 struct Sub : public Main<int> { 330 TS<> ff; 331 }; 332 333 int arr[sizeof(Sub)]; 334 335 } 336 337 namespace PR11421 { 338 template < unsigned > struct X { 339 static const unsigned dimension = 3; 340 template<unsigned dim=dimension> 341 struct Y: Y<dim> { }; // expected-error{{circular inheritance between 'Y<dim>' and 'Y<dim>'}} 342 }; 343 typedef X<3> X3; 344 X3::Y<>::iterator it; // expected-error {{no type named 'iterator' in 'PR11421::X<3>::Y<3>'}} 345 } 346 347 namespace rdar12629723 { 348 template<class T> 349 struct X { 350 struct C : public C { }; // expected-error{{circular inheritance between 'rdar12629723::X::C' and 'rdar12629723::X::C'}} 351 352 struct B; 353 354 struct A : public B { // expected-note{{'rdar12629723::X::A' declared here}} 355 virtual void foo() { } 356 }; 357 358 struct D : T::foo { }; 359 struct E : D { }; 360 }; 361 362 template<class T> 363 struct X<T>::B : public A { // expected-error{{circular inheritance between 'rdar12629723::X::A' and 'rdar12629723::X::B'}} 364 virtual void foo() { } 365 }; 366 } 367 368 namespace test_reserved_identifiers { 369 template<typename A, typename B> void tempf(A a, B b) { 370 a + b; // expected-error{{call to function 'operator+' that is neither visible in the template definition nor found by argument-dependent lookup}} 371 } 372 namespace __gnu_cxx { struct X {}; } 373 namespace ns { struct Y {}; } 374 void operator+(__gnu_cxx::X, ns::Y); // expected-note{{or in namespace 'test_reserved_identifiers::ns'}} 375 void test() { 376 __gnu_cxx::X x; 377 ns::Y y; 378 tempf(x, y); // expected-note{{in instantiation of}} 379 } 380 } 381 382 // This test must live in the global namespace. 383 struct PR14695_X {}; 384 // FIXME: This note is bogus; it is the using directive which would need to move 385 // to prior to the call site to fix the problem. 386 namespace PR14695_A { void PR14695_f(PR14695_X); } // expected-note {{'PR14695_f' should be declared prior to the call site or in the global namespace}} 387 template<typename T> void PR14695_g(T t) { PR14695_f(t); } // expected-error {{call to function 'PR14695_f' that is neither visible in the template definition nor found by argument-dependent lookup}} 388 using namespace PR14695_A; 389 template void PR14695_g(PR14695_X); // expected-note{{requested here}} 390 391 namespace OperatorNew { 392 template<typename T> void f(T t) { 393 operator new(100, t); // expected-error{{call to function 'operator new' that is neither visible in the template definition nor found by argument-dependent lookup}} 394 // FIXME: This should give the same error. 395 new (t) int; 396 } 397 struct X {}; 398 }; 399 using size_t = decltype(sizeof(0)); 400 void *operator new(size_t, OperatorNew::X); // expected-note-re {{should be declared prior to the call site{{$}}}} 401 template void OperatorNew::f(OperatorNew::X); // expected-note {{instantiation of}} 402 403 namespace PR19936 { 404 template<typename T> decltype(*T()) f() {} // expected-note {{previous}} 405 template<typename T> decltype(T() * T()) g() {} // expected-note {{previous}} 406 407 // Create some overloaded operators so we build an overload operator call 408 // instead of a builtin operator call for the dependent expression. 409 enum E {}; 410 int operator*(E); 411 int operator*(E, E); 412 413 // Check that they still profile the same. 414 template<typename T> decltype(*T()) f() {} // expected-error {{redefinition}} 415 template<typename T> decltype(T() * T()) g() {} // expected-error {{redefinition}} 416 } 417 418 template <typename> struct CT2 { 419 template <class U> struct X; 420 }; 421 template <typename T> int CT2<int>::X<>; // expected-error {{template parameter list matching the non-templated nested type 'CT2<int>' should be empty}} 422
