Home | History | Annotate | Download | only in SemaTemplate
      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   }
    174   template void f1<int>();  // expected-note{{in instantiation of function template specialization 'NondefDecls::f1<int>' requested here}}
    175 }
    176 
    177 template <typename T>
    178 struct C {
    179   C(T t = ); // expected-error {{expected expression}}
    180 };
    181 C<int> obj;
    182