test/SemaTemplate/member-template-access-expr.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 template<typename U, typename T>
   3 U f0(T t) {
   4   return t.template get<U>();
   5 }
   6
   7 template<typename U, typename T>
   8 int &f1(T t) {
   9   // FIXME: When we pretty-print this, we lose the "template" keyword.
  10   return t.U::template get<int&>();
  11 }
  12
  13 struct X {
  14   template<typename T> T get();
  15 };
  16
  17 void test_f0(X x) {
  18   int i = f0<int>(x);
  19   int &ir = f0<int&>(x);
  20 }
  21
  22 struct XDerived : public X {
  23 };
  24
  25 void test_f1(XDerived xd) {
  26   int &ir = f1<X>(xd);
  27 }
  28
  29 // PR5213
  30 template <class T>
  31 struct A {};
  32
  33 template<class T>
  34 class B
  35 {
  36   A<T> a_;
  37
  38 public:
  39   void destroy();
  40 };
  41
  42 template<class T>
  43 void
  44 B<T>::destroy()
  45 {
  46   a_.~A<T>();
  47 }
  48
  49 void do_destroy_B(B<int> b) {
  50   b.destroy();
  51 }
  52
  53 struct X1 {
  54   int* f1(int);
  55   template<typename T> float* f1(T);
  56
  57   static int* f2(int);
  58   template<typename T> static float* f2(T);
  59 };
  60
  61 void test_X1(X1 x1) {
  62   float *fp1 = x1.f1<>(17);
  63   float *fp2 = x1.f1<int>(3.14);
  64   int *ip1 = x1.f1(17);
  65   float *ip2 = x1.f1(3.14);
  66
  67   float* (X1::*mf1)(int) = &X1::f1;
  68   float* (X1::*mf2)(int) = &X1::f1<>;
  69   float* (X1::*mf3)(float) = &X1::f1<float>;
  70
  71   float* (*fp3)(int) = &X1::f2;
  72   float* (*fp4)(int) = &X1::f2<>;
  73   float* (*fp5)(float) = &X1::f2<float>;
  74   float* (*fp6)(int) = X1::f2;
  75   float* (*fp7)(int) = X1::f2<>;
  76   float* (*fp8)(float) = X1::f2<float>;
  77 }
  78
  79 template<int A> struct X2 {
  80   int m;
  81 };
  82
  83 template<typename T>
  84 struct X3 : T { };
  85
  86 template<typename T>
  87 struct X4 {
  88   template<typename U>
  89   void f(X2<sizeof(X3<U>().U::m)>);
  90 };
  91
  92 void f(X4<X3<int> > x4i) {
  93   X2<sizeof(int)> x2;
  94   x4i.f<X2<sizeof(int)> >(x2);
  95 }
  96
  97 template<typename T>
  98 struct X5 {
  99   template<typename U>
 100   void f();
 101
 102   void g() {
 103     this->f<T*>();
 104   }
 105 };
 106
 107 namespace PR6021 {
 108   template< class T1, class T2 >
 109   class Outer
 110   {
 111   public: // Range operations
 112     template< class X > X tmpl( const X* = 0 ) const;
 113
 114     struct Inner
 115     {
 116       const Outer& o;
 117
 118       template< class X >
 119       operator X() const
 120       {
 121         return o.tmpl<X>();
 122       }
 123     };
 124   };
 125 }
 126
 127 namespace rdar8198511 {
 128   template<int, typename U>
 129   struct Base {
 130     void f();
 131   };
 132
 133   template<typename T>
 134   struct X0 : Base<1, T> { };
 135
 136   template<typename T>
 137   struct X1 {
 138     X0<int> x0;
 139
 140     void f() {
 141       this->x0.Base<1, int>::f();
 142     }
 143   };
 144 }