test/SemaTemplate/ms-lookup-template-base-classes.cpp

   1 // RUN: %clang_cc1 -fms-compatibility -fsyntax-only -verify %s
   2
   3
   4 template <class T>
   5 class A {
   6 public:
   7    void f(T a) { }// expected-note {{must qualify identifier to find this declaration in dependent base class}}
   8    void g();// expected-note {{must qualify identifier to find this declaration in dependent base class}}
   9 };
  10
  11 template <class T>
  12 class B : public A<T> {
  13 public:
  14         void z(T a)
  15     {
  16        f(a); // expected-warning {{use of identifier 'f' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
  17        g(); // expected-warning {{use of identifier 'g' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
  18     }
  19 };
  20
  21 template class B<int>; // expected-note {{requested here}}
  22 template class B<char>;
  23
  24 void test()
  25 {
  26     B<int> b;
  27     b.z(3);
  28 }
  29
  30 struct A2 {
  31   template<class T> void f(T) {
  32     XX; //expected-error {{use of undeclared identifier 'XX'}}
  33     A2::XX; //expected-error {{no member named 'XX' in 'A2'}}
  34   }
  35 };
  36 template void A2::f(int);
  37
  38 template<class T0>
  39 struct A3 {
  40   template<class T1> void f(T1) {
  41     XX; //expected-error {{use of undeclared identifier 'XX'}}
  42   }
  43 };
  44 template void A3<int>::f(int);
  45
  46 template<class T0>
  47 struct A4 {
  48   void f(char) {
  49     XX; //expected-error {{use of undeclared identifier 'XX'}}
  50   }
  51 };
  52 template class A4<int>;
  53
  54
  55 namespace lookup_dependent_bases_id_expr {
  56
  57 template<class T> class A {
  58 public:
  59   int var;
  60 };
  61
  62
  63 template<class T>
  64 class B : public A<T> {
  65 public:
  66   void f() {
  67     var = 3;
  68   }
  69 };
  70
  71 template class B<int>;
  72
  73 }
  74
  75
  76
  77 namespace lookup_dependent_base_class_static_function {
  78
  79 template <class T>
  80 class A {
  81 public:
  82    static void static_func();// expected-note {{must qualify identifier to find this declaration in dependent base class}}
  83    void func();// expected-note {{must qualify identifier to find this declaration in dependent base class}}
  84 };
  85
  86
  87 template <class T>
  88 class B : public A<T> {
  89 public:
  90   static void z2(){
  91     static_func();  // expected-warning {{use of identifier 'static_func' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
  92     func(); // expected-warning {{use of identifier 'func' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}} expected-error {{call to non-static member function without an object argument}}
  93   }
  94 };
  95 template class B<int>; // expected-note {{requested here}}
  96
  97 }
  98
  99
 100
 101 namespace lookup_dependent_base_class_default_argument {
 102
 103 template<class T>
 104 class A {
 105 public:
 106   static int f1(); // expected-note {{must qualify identifier to find this declaration in dependent base class}}
 107   int f2(); // expected-note {{must qualify identifier to find this declaration in dependent base class}}
 108 };
 109
 110 template<class T>
 111 class B : public A<T> {
 112 public:
 113   void g1(int p = f1());// expected-warning {{use of identifier 'f1' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
 114   void g2(int p = f2());// expected-warning {{use of identifier 'f2' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}} expected-error {{call to non-static member function without an object argument}}
 115 };
 116
 117 void foo()
 118 {
 119         B<int> b;
 120         b.g1(); // expected-note {{required here}}
 121         b.g2(); // expected-note {{required here}}
 122 }
 123
 124 }
 125
 126
 127 namespace lookup_dependent_base_class_friend {
 128
 129 template <class T>
 130 class B {
 131 public:
 132   static void g();  // expected-note {{must qualify identifier to find this declaration in dependent base class}}
 133 };
 134
 135 template <class T>
 136 class A : public B<T> {
 137 public:
 138   friend void foo(A<T> p){
 139     g(); // expected-warning {{use of identifier 'g' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
 140   }
 141 };
 142
 143 int main2()
 144 {
 145   A<int> a;
 146   foo(a); // expected-note {{requested here}}
 147 }
 148
 149 }
 150
 151
 152 namespace lookup_dependent_base_no_typo_correction {
 153
 154 class C {
 155 public:
 156   int m_hWnd;
 157 };
 158
 159 template <class T>
 160 class A : public T {
 161 public:
 162   void f(int hWnd) {
 163     m_hWnd = 1;
 164   }
 165 };
 166
 167 template class A<C>;
 168
 169 }
 170
 171 namespace PR12701 {
 172
 173 class A {};
 174 class B {};
 175
 176 template <class T>
 177 class Base {
 178  public:
 179   bool base_fun(void* p) { return false; }  // expected-note {{must qualify identifier to find this declaration in dependent base clas}}
 180   operator T*() const { return 0; }
 181 };
 182
 183 template <class T>
 184 class Container : public Base<T> {
 185  public:
 186   template <typename S>
 187   bool operator=(const Container<S>& rhs) {
 188     return base_fun(rhs);  // expected-warning {{use of identifier 'base_fun' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
 189   }
 190 };
 191
 192 void f() {
 193   Container<A> text_provider;
 194   Container<B> text_provider2;
 195   text_provider2 = text_provider;  // expected-note {{in instantiation of function template specialization}}
 196 }
 197
 198 }  // namespace PR12701
 199
 200 namespace PR16014 {
 201
 202 struct A {
 203   int a;
 204   static int sa;
 205 };
 206 template <typename T> struct B : T {
 207   int     foo() { return a; }
 208   int    *bar() { return &a; }
 209   int     baz() { return T::a; }
 210   int T::*qux() { return &T::a; }
 211   static int T::*stuff() { return &T::a; }
 212   static int stuff1() { return T::sa; }
 213   static int *stuff2() { return &T::sa; }
 214 };
 215
 216 template <typename T> struct C : T {
 217   int     foo() { return b; }      // expected-error {{no member named 'b' in 'PR16014::C<PR16014::A>'}}
 218   int    *bar() { return &b; }     // expected-error {{no member named 'b' in 'PR16014::C<PR16014::A>'}}
 219   int     baz() { return T::b; }   // expected-error {{no member named 'b' in 'PR16014::A'}}
 220   int T::*qux() { return &T::b; }  // expected-error {{no member named 'b' in 'PR16014::A'}}
 221   int T::*fuz() { return &U::a; }  // expected-error {{use of undeclared identifier 'U'}}
 222 };
 223
 224 template struct B<A>;
 225 template struct C<A>;  // expected-note-re 1+ {{in instantiation of member function 'PR16014::C<PR16014::A>::.*' requested here}}
 226
 227 template <typename T> struct D : T {
 228   struct Inner {
 229     int foo() {
 230       // FIXME: MSVC can find this in D's base T!  Even worse, if ::sa exists,
 231       // clang will use it instead.
 232       return sa; // expected-error {{use of undeclared identifier 'sa'}}
 233     }
 234   };
 235 };
 236 template struct D<A>;
 237
 238 }