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 func_templ {
 106 namespace sss {
 107 double foo(int, double);
 108 template <class T>
 109 T foo(T);
 110 } // namespace sss
 111
 112 namespace oad {
 113 void foo();
 114 }
 115
 116 namespace oad {
 117 using sss::foo;
 118 }
 119
 120 namespace sss {
 121 using oad::foo;
 122 }
 123
 124 namespace sss {
 125 double foo(int, double) { return 0; }
 126 // There used to be an error with the below declaration when the example should
 127 // be accepted.
 128 template <class T>
 129 T foo(T t) { // OK
 130   return t;
 131 }
 132 } // namespace sss
 133 } // namespace func_templ