Home | History | Annotate | Download | only in SemaTemplate 
      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