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