Home | History | Annotate | Download | only in SemaTemplate
      1 // RUN: %clang_cc1 -fsyntax-only -verify %s
      2 
      3 namespace test0 {
      4   namespace N { }
      5 
      6   template<typename T>
      7   struct A {
      8     void f();
      9   };
     10 
     11   template<typename T>
     12   struct B : A<T> {
     13     using A<T>::f;
     14 
     15     void g() {
     16       using namespace N;
     17       f();
     18     }
     19   };
     20 
     21   template struct B<int>;
     22 }
     23 
     24 namespace test1 {
     25   template <class Derived> struct Visitor1 {
     26     void Visit(struct Object1*);
     27   };
     28   template <class Derived> struct Visitor2 {
     29     void Visit(struct Object2*); // expected-note {{candidate function}}
     30   };
     31 
     32   template <class Derived> struct JoinVisitor
     33       : Visitor1<Derived>, Visitor2<Derived> {
     34     typedef Visitor1<Derived> Base1;
     35     typedef Visitor2<Derived> Base2;
     36 
     37     void Visit(struct Object1*);  // expected-note {{candidate function}}
     38     using Base2::Visit;
     39   };
     40 
     41   class Knot : public JoinVisitor<Knot> {
     42   };
     43 
     44   void test() {
     45     Knot().Visit((struct Object1*) 0);
     46     Knot().Visit((struct Object2*) 0);
     47     Knot().Visit((struct Object3*) 0); // expected-error {{no matching member function for call}}
     48   }
     49 }
     50 
     51 // PR5847
     52 namespace test2 {
     53   namespace ns {
     54     void foo();
     55   }
     56 
     57   template <class T> void bar(T* ptr) {
     58     using ns::foo;
     59     foo();
     60   }
     61 
     62   template void bar(char *);
     63 }
     64 
     65 namespace test3 {
     66   template <typename T> struct t {
     67     struct s1 {
     68       T f1() const;
     69     };
     70     struct s2 : s1 {
     71       using s1::f1;
     72       T f1() const;
     73     };
     74   };
     75 
     76   void f2()
     77   {
     78     t<int>::s2 a;
     79     t<int>::s2 const & b = a;
     80     b.f1();
     81   }
     82 }
     83 
     84 namespace PR16936 {
     85   // Make sure both using decls are properly considered for
     86   // overload resolution.
     87   template<class> struct A {
     88     void access(int);
     89   };
     90   template<class> struct B {
     91     void access();
     92   };
     93   template<class CELL> struct X : public A<CELL>, public B<CELL> {
     94     using A<CELL>::access;
     95     using B<CELL>::access;
     96 
     97     void f() {
     98       access(0);
     99     }
    100   };
    101 
    102   void f() {
    103     X<int> x;
    104     x.f();
    105   }
    106 }
    107