1 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s 2 3 template<typename T> struct A { fA4 void f() { } 5 struct N { }; // expected-note{{target of using declaration}} 6 }; 7 8 template<typename T> struct B : A<T> { 9 using A<T>::f; 10 using A<T>::N; // expected-error{{dependent using declaration resolved to type without 'typename'}} 11 12 using A<T>::foo; // expected-error{{no member named 'foo'}} 13 using A<double>::f; // expected-error{{using declaration refers into 'A<double>::', which is not a base class of 'B<int>'}} 14 }; 15 16 B<int> a; // expected-note{{in instantiation of template class 'B<int>' requested here}} 17 18 template<typename T> struct C : A<T> { 19 using A<T>::f; 20 fC21 void f() { }; 22 }; 23 24 template <typename T> struct D : A<T> { 25 using A<T>::f; 26 27 void f(); 28 }; 29 f()30template<typename T> void D<T>::f() { } 31 32 template<typename T> struct E : A<T> { 33 using A<T>::f; 34 gE35 void g() { f(); } 36 }; 37 38 namespace test0 { 39 struct Base { 40 int foo; 41 }; 42 template<typename T> struct E : Base { 43 using Base::foo; 44 }; 45 46 template struct E<int>; 47 } 48 49 // PR7896 50 namespace PR7896 { 51 template <class T> struct Foo { 52 int k (float); 53 }; 54 struct Baz { 55 int k (int); 56 }; 57 template <class T> struct Bar : public Foo<T>, Baz { 58 using Foo<T>::k; 59 using Baz::k; fooPR7896::Bar60 int foo() { 61 return k (1.0f); 62 } 63 }; 64 template int Bar<int>::foo(); 65 } 66 67 // PR10883 68 namespace PR10883 { 69 template <typename T> 70 class Base { 71 public: 72 typedef long Container; 73 }; 74 75 template <typename T> 76 class Derived : public Base<T> { 77 public: 78 using Base<T>::Container; 79 80 void foo(const Container& current); // expected-error {{unknown type name 'Container'}} 81 }; 82 } 83 84 template<typename T> class UsingTypenameNNS { 85 using typename T::X; 86 typename X::X x; 87 }; 88 89 namespace aliastemplateinst { 90 template<typename T> struct A { }; 91 template<typename T> using APtr = A<T*>; // expected-note{{previous use is here}} 92 93 template struct APtr<int>; // expected-error{{alias template 'APtr' cannot be referenced with the 'struct' specifier}} 94 } 95 96 namespace DontDiagnoseInvalidTest { 97 template <bool Value> struct Base { 98 static_assert(Value, ""); // expected-error {{static assertion failed}} 99 }; 100 struct Derived : Base<false> { // expected-note {{requested here}} 101 using Base<false>::Base; // OK. Don't diagnose that 'Base' isn't a base class of Derived. 102 }; 103 } // namespace DontDiagnoseInvalidTest 104 105 namespace shadow_nested_operator { 106 template <typename T> 107 struct A { 108 struct Nested {}; operator Nested*shadow_nested_operator::A109 operator Nested*() {return 0;}; 110 }; 111 112 template <typename T> 113 struct B : A<T> { 114 using A<T>::operator typename A<T>::Nested*; operator typename A<T>::Nested*shadow_nested_operator::B115 operator typename A<T>::Nested *() { 116 struct A<T> * thi = this; 117 return *thi; 118 }; 119 }; 120 foo()121int foo () { 122 struct B<int> b; 123 auto s = *b; 124 } 125 } // namespace shadow_nested_operator 126 127 namespace func_templ { 128 namespace sss { 129 double foo(int, double); 130 template <class T> 131 T foo(T); 132 } // namespace sss 133 134 namespace oad { 135 void foo(); 136 } 137 138 namespace oad { 139 using sss::foo; 140 } 141 142 namespace sss { 143 using oad::foo; 144 } 145 146 namespace sss { foo(int,double)147double foo(int, double) { return 0; } 148 // There used to be an error with the below declaration when the example should 149 // be accepted. 150 template <class T> foo(T t)151T foo(T t) { // OK 152 return t; 153 } 154 } // namespace sss 155 } // namespace func_templ 156