clang/test/SemaTemplate/default-arguments.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 template<typename T, int N = 2> struct X; // expected-note{{template is declared here}}
   5
   6 X<int, 1> *x1;
   7 X<int> *x2;
   8
   9 X<> *x3; // expected-error{{too few template arguments for class template 'X'}}
  10
  11 template<typename U = float, int M> struct X;
  12
  13 X<> *x4;
  14
  15 template<typename T = int> struct Z { };
  16 template struct Z<>;
  17
  18 // PR4362
  19 template<class T> struct a { };
  20 template<> struct a<int> { static const bool v = true; };
  21
  22 template<class T, bool = a<T>::v> struct p { }; // expected-error {{no member named 'v'}}
  23
  24 template struct p<bool>; // expected-note {{in instantiation of default argument for 'p<bool>' required here}}
  25 template struct p<int>;
  26
  27 // PR5187
  28 template<typename T, typename U>
  29 struct A;
  30
  31 template<typename T, typename U = T>
  32 struct A;
  33
  34 template<typename T, typename U>
  35 struct A {
  36   void f(A<T>);
  37 };
  38
  39 template<typename T>
  40 struct B { };
  41
  42 template<>
  43 struct B<void> {
  44   typedef B<void*> type;
  45 };
  46
  47 // Nested default arguments for template parameters.
  48 template<typename T> struct X1 { };
  49
  50 template<typename T>
  51 struct X2 {
  52   template<typename U = typename X1<T>::type> // expected-error{{no type named 'type' in 'X1<int>'}} \
  53                                               // expected-error{{no type named 'type' in 'X1<char>'}}
  54   struct Inner1 { }; // expected-note{{template is declared here}}
  55
  56   template<T Value = X1<T>::value> // expected-error{{no member named 'value' in 'X1<int>'}} \
  57                                    // expected-error{{no member named 'value' in 'X1<char>'}}
  58   struct NonType1 { }; // expected-note{{template is declared here}}
  59
  60   template<T Value>
  61   struct Inner2 { };
  62
  63   template<typename U>
  64   struct Inner3 {
  65     template<typename X = T, typename V = U>
  66     struct VeryInner { };
  67
  68     template<T Value1 = sizeof(T), T Value2 = sizeof(U),
  69              T Value3 = Value1 + Value2>
  70     struct NonType2 { };
  71   };
  72 };
  73
  74 X2<int> x2i; // expected-note{{in instantiation of template class 'X2<int>' requested here}}
  75 X2<int>::Inner1<float> x2iif;
  76
  77 X2<int>::Inner1<> x2bad; // expected-error{{too few template arguments for class template 'Inner1'}}
  78
  79 X2<int>::NonType1<'a'> x2_nontype1;
  80 X2<int>::NonType1<> x2_nontype1_bad; // expected-error{{too few template arguments for class template 'NonType1'}}
  81
  82 // Check multi-level substitution into template type arguments
  83 X2<int>::Inner3<float>::VeryInner<> vi;
  84 X2<char>::Inner3<int>::NonType2<> x2_deep_nontype; // expected-note{{in instantiation of template class 'X2<char>' requested here}}
  85
  86 template<typename T, typename U>
  87 struct is_same { static const bool value = false; };
  88
  89 template<typename T>
  90 struct is_same<T, T> { static const bool value = true; };
  91
  92 int array1[is_same<__typeof__(vi),
  93                X2<int>::Inner3<float>::VeryInner<int, float> >::value? 1 : -1];
  94
  95 int array2[is_same<__typeof(x2_deep_nontype),
  96                    X2<char>::Inner3<int>::NonType2<sizeof(char), sizeof(int),
  97                                     sizeof(char)+sizeof(int)> >::value? 1 : -1];
  98
  99 // Template template parameter defaults
 100 template<template<typename T> class X = X2> struct X3 { };
 101 int array3[is_same<X3<>, X3<X2> >::value? 1 : -1];
 102
 103 struct add_pointer {
 104   template<typename T>
 105   struct apply {
 106     typedef T* type;
 107   };
 108 };
 109
 110 template<typename T, template<typename> class X = T::template apply>
 111   struct X4;
 112 int array4[is_same<X4<add_pointer>,
 113                    X4<add_pointer, add_pointer::apply> >::value? 1 : -1];
 114
 115 template<int> struct X5 {}; // expected-note{{has a different type 'int'}}
 116 template<long> struct X5b {};
 117 template<typename T,
 118          template<T> class B = X5> // expected-error{{template template argument has different}} \
 119                                    // expected-note{{previous non-type template parameter}}
 120   struct X6 {};
 121
 122 X6<int> x6a;
 123 X6<long> x6b; // expected-note{{while checking a default template argument}}
 124 X6<long, X5b> x6c;
 125
 126
 127 template<template<class> class X = B<int> > struct X7; // expected-error{{must be a class template}}
 128
 129 namespace PR9643 {
 130   template<typename T> class allocator {};
 131   template<typename T, typename U = allocator<T> > class vector {};
 132
 133   template<template<typename U, typename = allocator<U> > class container,
 134            typename DT>
 135   container<DT> initializer(const DT& d) {
 136     return container<DT>();
 137   }
 138
 139   void f() {
 140     vector<int, allocator<int> > v = initializer<vector>(5);
 141   }
 142 }
 143
 144 namespace PR16288 {
 145   template<typename X>
 146   struct S {
 147     template<typename T = int, typename U>
 148 #if __cplusplus <= 199711L // C++03 or earlier modes
 149     // expected-warning@-2 {{default template arguments for a function template are a C++11 extension}}
 150 #endif
 151     void f();
 152   };
 153   template<typename X>
 154   template<typename T, typename U>
 155   void S<X>::f() {}
 156 }
 157
 158 namespace DR1635 {
 159   template <class T> struct X {
 160     template <class U = typename T::type> static void f(int) {} // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
 161 #if __cplusplus <= 199711L // C++03 or earlier modes
 162     // expected-warning@-2 {{default template arguments for a function template are a C++11 extension}}
 163 #endif
 164     static void f(...) {}
 165   };
 166
 167   int g() { X<int>::f(0); } // expected-note {{in instantiation of template class 'DR1635::X<int>' requested here}}
 168 }
 169
 170 namespace NondefDecls {
 171   template<typename T> void f1() {
 172     int g1(int defarg = T::error);  // expected-error{{type 'int' cannot be used prior to '::' because it has no members}} \
 173                                     // expected-note {{in instantiation of default function argument expression for 'g1<int>' required here}}
 174   }
 175   template void f1<int>();  // expected-note{{in instantiation of function template specialization 'NondefDecls::f1<int>' requested here}}
 176 }
 177
 178 template <typename T>
 179 struct C {
 180   C(T t = ); // expected-error {{expected expression}}
 181 };
 182 C<int> obj;
 183
 184 namespace PR26134 {
 185 // Make sure when substituting default template arguments we do it in the current context.
 186 template<class T, bool Val = T::value>
 187 struct X {};
 188
 189 template<bool B> struct Y {
 190   void f() { X<Y> xy; }
 191   static const bool value = B;
 192 };
 193
 194 namespace ns1 {
 195 template<class T0>
 196 struct X {
 197   template<bool B = T0::value> struct XInner { static const bool value = B; };
 198 };
 199 template<bool B> struct S { static const bool value = B; };
 200 #if __cplusplus > 199711L
 201 template<bool B> struct Y {
 202   static constexpr bool f() { return typename X<S<B>>::template XInner<>{}.value; }
 203   static_assert(f() == B, "");
 204 };
 205 Y<true> y;
 206 Y<false> y2;
 207 #endif
 208
 209 } // end ns1
 210 } // end ns PR26134
 211
 212 namespace friends {
 213   namespace ns {
 214     template<typename> struct A {
 215       template<typename> friend void f();
 216       template<typename> friend struct X;
 217     };
 218     template<typename = int> void f(); // expected-warning 0-1{{extension}}
 219     template<typename = int> struct X;
 220     A<int> a;
 221   }
 222   namespace ns {
 223     void g() { f(); }
 224     X<int> *p;
 225   }
 226 }
 227
 228 namespace unevaluated {
 229   int a;
 230   template<int = 0> int f(int = a); // expected-warning 0-1{{extension}}
 231   int k = sizeof(f());
 232 }