clang/test/SemaCXX/using-decl-templates.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
   2
   3 template<typename T> struct A {
   4   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
  21   void f() { };
  22 };
  23
  24 template <typename T> struct D : A<T> {
  25   using A<T>::f;
  26
  27   void f();
  28 };
  29
  30 template<typename T> void D<T>::f() { }
  31
  32 template<typename T> struct E : A<T> {
  33   using A<T>::f;
  34
  35   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;
  60   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{{type alias template 'APtr' cannot be referenced with a 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 {};
 109   operator Nested*() {return 0;};
 110 };
 111
 112 template <typename T>
 113 struct B : A<T> {
 114   using A<T>::operator typename A<T>::Nested*;
 115   operator typename A<T>::Nested *() {
 116     struct A<T> * thi = this;
 117     return *thi;
 118  };
 119 };
 120
 121 int 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 {
 147 double 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>
 151 T foo(T t) { // OK
 152   return t;
 153 }
 154 } // namespace sss
 155 } // namespace func_templ