test/SemaTemplate/dependent-names.cpp

   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}}