clang/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 {{member is declared here}}
  95   };
  96
  97   template <class T> struct Derived : Base<T> {
  98     void doFoo(T v) {
  99       foo(v); // expected-error {{explicit qualification required to use member 'foo' from dependent base class}}
 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     int 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   }
 277
 278   namespace A2 {
 279     template<typename T>
 280     struct S {
 281       void f() {
 282         for (auto &a : e)
 283           __range(a); // expected-error {{undeclared identifier '__range'}}
 284       }
 285       T e[10];
 286     };
 287     void g() {
 288       S<int>().f(); // expected-note {{here}}
 289     }
 290     struct X {};
 291     void __range(X);
 292     void h() {
 293       S<X>().f();
 294     }
 295   }
 296
 297   namespace B {
 298     template<typename T> void g(); // expected-note {{not viable}}
 299     template<typename T> void f() {
 300       g<int>(T()); // expected-error {{no matching function}}
 301     }
 302
 303     namespace {
 304       struct S {};
 305     }
 306     void g(S);
 307
 308     template void f<S>(); // expected-note {{here}}
 309   }
 310 }
 311
 312 namespace rdar11242625 {
 313
 314 template <typename T>
 315 struct Main {
 316   struct default_names {
 317     typedef int id;
 318   };
 319
 320   template <typename T2 = typename default_names::id>
 321   struct TS {
 322     T2 q;
 323   };
 324 };
 325
 326 struct Sub : public Main<int> {
 327   TS<> ff;
 328 };
 329
 330 int arr[sizeof(Sub)];
 331
 332 }
 333
 334 namespace PR11421 {
 335 template < unsigned > struct X {
 336   static const unsigned dimension = 3;
 337   template<unsigned dim=dimension>
 338   struct Y: Y<dim> { }; // expected-error{{circular inheritance between 'Y<dim>' and 'Y<dim>'}}
 339 };
 340 typedef X<3> X3;
 341 X3::Y<>::iterator it; // expected-error {{no type named 'iterator' in 'PR11421::X<3>::Y<>'}}
 342 }
 343
 344 namespace rdar12629723 {
 345   template<class T>
 346   struct X {
 347     struct C : public C { }; // expected-error{{circular inheritance between 'C' and 'rdar12629723::X::C'}}
 348
 349     struct B;
 350
 351     struct A : public B {  // expected-note{{'A' declared here}}
 352       virtual void foo() { }
 353     };
 354
 355     struct D : T::foo { };
 356     struct E : D { };
 357   };
 358
 359   template<class T>
 360   struct X<T>::B : public A {  // expected-error{{circular inheritance between 'A' and 'rdar12629723::X::B'}}
 361     virtual void foo() { }
 362   };
 363 }
 364
 365 namespace test_reserved_identifiers {
 366   template<typename A, typename B> void tempf(A a, B b) {
 367     a + b;  // expected-error{{call to function 'operator+' that is neither visible in the template definition nor found by argument-dependent lookup}}
 368   }
 369   namespace __gnu_cxx { struct X {}; }
 370   namespace ns { struct Y {}; }
 371   void operator+(__gnu_cxx::X, ns::Y);  // expected-note{{or in namespace 'test_reserved_identifiers::ns'}}
 372   void test() {
 373     __gnu_cxx::X x;
 374     ns::Y y;
 375     tempf(x, y);  // expected-note{{in instantiation of}}
 376   }
 377 }
 378
 379 // This test must live in the global namespace.
 380 struct PR14695_X {};
 381 // FIXME: This note is bogus; it is the using directive which would need to move
 382 // to prior to the call site to fix the problem.
 383 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}}
 384 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}}
 385 using namespace PR14695_A;
 386 template void PR14695_g(PR14695_X); // expected-note{{requested here}}
 387
 388 namespace OperatorNew {
 389   template<typename T> void f(T t) {
 390     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}}
 391     // FIXME: This should give the same error.
 392     new (t) int;
 393   }
 394   struct X {};
 395 };
 396 using size_t = decltype(sizeof(0));
 397 void *operator new(size_t, OperatorNew::X); // expected-note-re {{should be declared prior to the call site{{$}}}}
 398 template void OperatorNew::f(OperatorNew::X); // expected-note {{instantiation of}}
 399
 400 namespace PR19936 {
 401   template<typename T> decltype(*T()) f() {} // expected-note {{previous}}
 402   template<typename T> decltype(T() * T()) g() {} // expected-note {{previous}}
 403
 404   // Create some overloaded operators so we build an overload operator call
 405   // instead of a builtin operator call for the dependent expression.
 406   enum E {};
 407   int operator*(E);
 408   int operator*(E, E);
 409
 410   // Check that they still profile the same.
 411   template<typename T> decltype(*T()) f() {} // expected-error {{redefinition}}
 412   template<typename T> decltype(T() * T()) g() {} // expected-error {{redefinition}}
 413 }
 414
 415 template <typename> struct CT2 {
 416   template <class U> struct X;
 417 };
 418 template <typename T> int CT2<int>::X<>; // expected-error {{template parameter list matching the non-templated nested type 'CT2<int>' should be empty}}
 419
 420 namespace DependentTemplateIdWithNoArgs {
 421   template<typename T> void f() { T::template f(); }
 422   struct X {
 423     template<int = 0> static void f();
 424   };
 425   void g() { f<X>(); }
 426 }
 427
 428 namespace DependentUnresolvedUsingTemplate {
 429   template<typename T>
 430   struct X : T {
 431     using T::foo;
 432     void f() { this->template foo(); } // expected-error {{does not refer to a template}}
 433     void g() { this->template foo<>(); } // expected-error {{does not refer to a template}}
 434     void h() { this->template foo<int>(); } // expected-error {{does not refer to a template}}
 435   };
 436   struct A { template<typename = int> int foo(); };
 437   struct B { int foo(); }; // expected-note 3{{non-template here}}
 438   void test(X<A> xa, X<B> xb) {
 439     xa.f();
 440     xa.g();
 441     xa.h();
 442     xb.f(); // expected-note {{instantiation of}}
 443     xb.g(); // expected-note {{instantiation of}}
 444     xb.h(); // expected-note {{instantiation of}}
 445   }
 446 }
 447
 448 namespace PR37680 {
 449   template <class a> struct b : a {
 450     using a::add;
 451     template<int> int add() { return this->template add(0); }
 452   };
 453   struct a {
 454     template<typename T = void> int add(...);
 455     void add(int);
 456   };
 457   int f(b<a> ba) { return ba.add<0>(); }
 458 }