clang/test/SemaTemplate/partial-spec-instantiate.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
   3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   4
   5 // PR4607
   6 template <class T> struct X {};
   7
   8 template <> struct X<char>
   9 {
  10   static char* g();
  11 };
  12
  13 template <class T> struct X2 {};
  14
  15 template <class U>
  16 struct X2<U*> {
  17   static void f() {
  18     X<U>::g();
  19   }
  20 };
  21
  22 void a(char *a, char *b) {X2<char*>::f();}
  23
  24 namespace WonkyAccess {
  25   template<typename T>
  26   struct X {
  27     int m;
  28   };
  29
  30   template<typename U>
  31   class Y;
  32
  33   template<typename U>
  34   struct Y<U*> : X<U> { };
  35
  36   template<>
  37   struct Y<float*> : X<float> { };
  38
  39   int f(Y<int*> y, Y<float*> y2) {
  40     return y.m + y2.m;
  41   }
  42 }
  43
  44 namespace rdar9169404 {
  45   template<typename T, T N> struct X { };
  46   template<bool C> struct X<bool, C> {
  47     typedef int type;
  48   };
  49
  50   X<bool, -1>::type value;
  51 #if __cplusplus >= 201103L
  52   // expected-error@-2 {{non-type template argument evaluates to -1, which cannot be narrowed to type 'bool'}}
  53 #endif
  54 }
  55
  56 namespace rdar39524996 {
  57   template <typename T, typename U>
  58   struct enable_if_not_same
  59   {
  60     typedef void type;
  61   };
  62   template <typename T>
  63   struct enable_if_not_same<T, T>;
  64
  65   template <typename T>
  66   struct Wrapper {
  67     // Assertion triggered on trying to set twice the same partial specialization
  68     // enable_if_not_same<int, int>
  69     template <class U>
  70     Wrapper(const Wrapper<U>& other,
  71             typename enable_if_not_same<U, T>::type* = 0) {}
  72
  73     explicit Wrapper(int i) {}
  74   };
  75
  76   template <class T>
  77   struct Container {
  78     // It is important that the struct has implicit copy and move constructors.
  79     Container() : x() {}
  80
  81     template <class U>
  82     Container(const Container<U>& other) : x(static_cast<T>(other.x)) {}
  83
  84     // Implicit constructors are member-wise, so the field triggers instantiation
  85     // of T constructors and we instantiate all of them for overloading purposes.
  86     T x;
  87   };
  88
  89   void takesWrapperInContainer(const Container< Wrapper<int> >& c);
  90   void test() {
  91     // Type mismatch triggers initialization with conversion which requires
  92     // implicit constructors to be instantiated.
  93     Container<int> c;
  94     takesWrapperInContainer(c);
  95   }
  96 }
  97
  98 namespace InstantiationDependent {
  99   template<typename> using ignore = void; // expected-warning 0-1{{extension}}
 100   template<typename T, typename = void> struct A {
 101     static const bool specialized = false;
 102   };
 103   template<typename T> struct Hide { typedef void type; };
 104   template<typename T> struct A<T, Hide<ignore<typename T::type> >::type> {
 105     static const bool specialized = true;
 106   };
 107
 108   struct X {};
 109   struct Y { typedef int type; };
 110   _Static_assert(!A<X>::specialized, "");
 111   _Static_assert(A<Y>::specialized, "");
 112 }
 113
 114 namespace IgnorePartialSubstitution {
 115   template <typename... T> struct tuple {}; // expected-warning 0-1{{extension}}
 116   template <typename> struct IsTuple {
 117     enum { value = false };
 118   };
 119   template <typename... Us> struct IsTuple<tuple<Us...> > { // expected-warning 0-1{{extension}}
 120     enum { value = true };
 121   };
 122
 123   template <bool...> using ignore = void; // expected-warning 0-2{{extension}}
 124   template <class... Pred> ignore<Pred::value...> helper(); // expected-warning 0-1{{extension}}
 125
 126   using S = IsTuple<tuple<int> >; // expected-warning 0-1{{extension}}
 127
 128   // This used to pick the primary template, because we got confused and
 129   // thought that template parameter 0 was the current partially-substituted
 130   // pack (from `helper`) during the deduction for the partial specialization.
 131   void f() { helper<S>(); }
 132
 133   _Static_assert(S::value, "");
 134 }
 135
 136 namespace GH60778 {
 137   template <bool B = false> class ClassTemplate {
 138   public:
 139       template <typename T, typename = void> class Nested {};
 140   };
 141
 142   template <typename DerivedType> class Base {};
 143
 144   template <>
 145   template <typename T>
 146   class ClassTemplate<>::Nested<T> : public Base<ClassTemplate<>::Nested<T> > {};
 147
 148   void use() {
 149     // This should instantiate the body of Nested with the template arguments
 150     // from the Partial Specialization. This would previously get confused and
 151     // get the template arguments from the primary template instead.
 152     ClassTemplate<>::Nested<int> instantiation;
 153   }
 154 }