1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s 2 // RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify %s 3 4 namespace test0 { 5 namespace N { } 6 7 template<typename T> 8 struct A { 9 void f(); 10 }; 11 12 template<typename T> 13 struct B : A<T> { 14 using A<T>::f; 15 16 void g() { 17 using namespace N; 18 f(); 19 } 20 }; 21 22 template struct B<int>; 23 } 24 25 namespace test1 { 26 template <class Derived> struct Visitor1 { 27 void Visit(struct Object1*); 28 }; 29 template <class Derived> struct Visitor2 { 30 void Visit(struct Object2*); // expected-note {{candidate function}} 31 }; 32 33 template <class Derived> struct JoinVisitor 34 : Visitor1<Derived>, Visitor2<Derived> { 35 typedef Visitor1<Derived> Base1; 36 typedef Visitor2<Derived> Base2; 37 38 void Visit(struct Object1*); // expected-note {{candidate function}} 39 using Base2::Visit; 40 }; 41 42 class Knot : public JoinVisitor<Knot> { 43 }; 44 45 void test() { 46 Knot().Visit((struct Object1*) 0); 47 Knot().Visit((struct Object2*) 0); 48 Knot().Visit((struct Object3*) 0); // expected-error {{no matching member function for call}} 49 } 50 } 51 52 // PR5847 53 namespace test2 { 54 namespace ns { 55 void foo(); 56 } 57 58 template <class T> void bar(T* ptr) { 59 using ns::foo; 60 foo(); 61 } 62 63 template void bar(char *); 64 } 65 66 namespace test3 { 67 template <typename T> struct t { 68 struct s1 { 69 T f1() const; 70 }; 71 struct s2 : s1 { 72 using s1::f1; 73 T f1() const; 74 }; 75 }; 76 77 void f2() 78 { 79 t<int>::s2 a; 80 t<int>::s2 const & b = a; 81 b.f1(); 82 } 83 } 84 85 namespace PR16936 { 86 // Make sure both using decls are properly considered for 87 // overload resolution. 88 template<class> struct A { 89 void access(int); 90 }; 91 template<class> struct B { 92 void access(); 93 }; 94 template<class CELL> struct X : public A<CELL>, public B<CELL> { 95 using A<CELL>::access; 96 using B<CELL>::access; 97 98 void f() { 99 access(0); 100 } 101 }; 102 103 void f() { 104 X<int> x; 105 x.f(); 106 } 107 } 108 109 namespace pr21923 { 110 template <typename> struct Base { 111 int field; 112 void method(); 113 }; 114 template <typename Scalar> struct Derived : Base<Scalar> { 115 using Base<Scalar>::field; 116 using Base<Scalar>::method; 117 static void m_fn1() { 118 // expected-error@+1 {{invalid use of member 'field' in static member function}} 119 (void)field; 120 // expected-error@+1 {{invalid use of member 'field' in static member function}} 121 (void)&field; 122 // expected-error@+1 {{call to non-static member function without an object argument}} 123 (void)method; 124 // expected-error@+1 {{call to non-static member function without an object argument}} 125 (void)&method; 126 // expected-error@+1 {{call to non-static member function without an object argument}} 127 method(); 128 (void)&Base<Scalar>::field; 129 (void)&Base<Scalar>::method; 130 } 131 #if __cplusplus >= 201103L 132 // These usages are OK in C++11 due to the unevaluated context. 133 enum { TheSize = sizeof(field) }; 134 typedef decltype(field) U; 135 #else 136 // expected-error@+1 {{invalid use of non-static data member 'field'}} 137 enum { TheSize = sizeof(field) }; 138 #endif 139 }; 140 141 #if __cplusplus < 201103L 142 // C++98 has an extra note for TheSize. 143 // expected-note@+2 {{requested here}} 144 #endif 145 template class Derived<int>; // expected-note {{requested here}} 146 147 // This is interesting because we form an UnresolvedLookupExpr in the static 148 // function template and an UnresolvedMemberExpr in the instance function 149 // template. As a result, we get slightly different behavior. 150 struct UnresolvedTemplateNames { 151 template <typename> void maybe_static(); 152 #if __cplusplus < 201103L 153 // expected-warning@+2 {{default template arguments for a function template are a C++11 extension}} 154 #endif 155 template <typename T, typename T::type = 0> static void maybe_static(); 156 157 template <typename T> 158 void instance_method() { (void)maybe_static<T>(); } 159 template <typename T> 160 static void static_method() { 161 // expected-error@+1 {{call to non-static member function without an object argument}} 162 (void)maybe_static<T>(); 163 } 164 }; 165 void force_instantiation(UnresolvedTemplateNames x) { 166 x.instance_method<int>(); 167 UnresolvedTemplateNames::static_method<int>(); // expected-note {{requested here}} 168 } 169 } // pr21923 170
