Home | History | Annotate | Download | only in temp.variadic
      1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
      2 
      3 template<typename... Types> struct tuple;
      4 template<int I> struct int_c;
      5 
      6 template<typename T>
      7 struct identity {
      8   typedef T type;
      9 };
     10 
     11 template<typename T, typename U>
     12 struct is_same {
     13   static const bool value = false;
     14 };
     15 
     16 template<typename T>
     17 struct is_same<T, T> {
     18   static const bool value = true;
     19 };
     20 
     21 // FIXME: Several more bullets to go
     22 
     23 // In a function parameter pack, the pattern is the parameter-declaration
     24 // without the ellipsis.
     25 namespace PR11850 {
     26   template<typename ...T> struct S {
     27     int f(T...a, int b) { return b; }
     28   };
     29   S<> s;
     30   S<int*, char, const double&> t;
     31   int k = s.f(0);
     32   int l = t.f(&k, 'x', 5.9, 4);
     33 
     34   template<typename ...As> struct A {
     35     template<typename ...Bs> struct B {
     36       template<typename ...Cs> struct C {
     37         C(As..., Bs..., int &k, Cs...);
     38       };
     39     };
     40   };
     41   A<>::B<>::C<> c000(k);
     42   A<int>::B<>::C<int> c101(1, k, 3);
     43   A<>::B<int>::C<int> c011(1, k, 3);
     44   A<int>::B<int>::C<> c110(1, 2, k);
     45   A<int, int>::B<int, int>::C<int, int> c222(1, 2, 3, 4, k, 5, 6);
     46   A<int, int, int>::B<>::C<> c300(1, 2, 3, k);
     47 
     48   int &f();
     49   char &f(void*);
     50   template<typename ...A> struct U {
     51     template<typename ...B> struct V {
     52       auto g(A...a, B...b) -> decltype(f(a...));
     53     };
     54   };
     55   U<>::V<int*> v0;
     56   U<int*>::V<> v1;
     57   int &v0f = v0.g(0);
     58   char &v1f = v1.g(0);
     59 }
     60 namespace PR12096 {
     61   void Foo(int) {}
     62   void Foo(int, int) = delete;
     63   template<typename ...Args> struct Var {
     64     Var(const Args &...args, int *) { Foo(args...); }
     65   };
     66   Var<int> var(1, 0);
     67 }
     68 
     69 // In an initializer-list (8.5); the pattern is an initializer-clause.
     70 // Note: this also covers expression-lists, since expression-list is
     71 // just defined as initializer-list.
     72 void five_args(int, int, int, int, int); // expected-note{{candidate function not viable: requires 5 arguments, but 6 were provided}}
     73 
     74 template<int ...Values>
     75 void initializer_list_expansion() {
     76   int values[5] = { Values... }; // expected-error{{excess elements in array initializer}}
     77   five_args(Values...); // expected-error{{no matching function for call to 'five_args'}}
     78 }
     79 
     80 template void initializer_list_expansion<1, 2, 3, 4, 5>();
     81 template void initializer_list_expansion<1, 2, 3, 4, 5, 6>(); // expected-note{{in instantiation of function template specialization 'initializer_list_expansion<1, 2, 3, 4, 5, 6>' requested here}}
     82 
     83 namespace PR8977 {
     84   struct A { };
     85   template<typename T, typename... Args> void f(Args... args) {
     86     // An empty expression-list performs value initialization.
     87     constexpr T t(args...);
     88   };
     89 
     90   template void f<A>();
     91 }
     92 
     93 // In a base-specifier-list (Clause 10); the pattern is a base-specifier.
     94 template<typename ...Mixins>
     95 struct HasMixins : public Mixins... {
     96   HasMixins();
     97   HasMixins(const HasMixins&);
     98   HasMixins(int i);
     99 };
    100 
    101 struct A { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const A' for 1st argument}} \
    102 // expected-note{{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'A' for 1st argument}} \
    103 // expected-note{{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
    104 struct B { };
    105 struct C { };
    106 struct D { };
    107 
    108 A *checkA = new HasMixins<A, B, C, D>;
    109 B *checkB = new HasMixins<A, B, C, D>;
    110 D *checkD = new HasMixins<A, B, C, D>;
    111 C *checkC = new HasMixins<A, B, D>; // expected-error{{cannot initialize a variable of type 'C *' with an rvalue of type 'HasMixins<A, B, D> *'}}
    112 HasMixins<> *checkNone = new HasMixins<>;
    113 
    114 template<typename Mixins>
    115 struct BrokenMixins : public Mixins... { }; // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
    116 
    117 // In a mem-initializer-list (12.6.2); the pattern is a mem-initializer.
    118 template<typename ...Mixins>
    119 HasMixins<Mixins...>::HasMixins(): Mixins()... { }
    120 
    121 template<typename ...Mixins>
    122 HasMixins<Mixins...>::HasMixins(const HasMixins &other): Mixins(other)... { }
    123 
    124 template<typename ...Mixins>
    125 HasMixins<Mixins...>::HasMixins(int i): Mixins(i)... { } // expected-error{{no matching constructor for initialization of 'A'}}
    126 
    127 void test_has_mixins() {
    128   HasMixins<A, B> ab;
    129   HasMixins<A, B> ab2 = ab;
    130   HasMixins<A, B> ab3(17); // expected-note{{in instantiation of member function 'HasMixins<A, B>::HasMixins' requested here}}
    131 }
    132 
    133 template<typename T>
    134 struct X {
    135   T member;
    136 
    137   X() : member()... { } // expected-error{{pack expansion for initialization of member 'member'}}
    138 };
    139 
    140 // There was a bug in the delayed parsing code for the
    141 // following case.
    142 template<typename ...T>
    143 struct DelayedParseTest : T...
    144 {
    145   int a;
    146   DelayedParseTest(T... i) : T{i}..., a{10} {}
    147 };
    148 
    149 
    150 // In a template-argument-list (14.3); the pattern is a template-argument.
    151 template<typename ...Types>
    152 struct tuple_of_refs {
    153   typedef tuple<Types& ...> types;
    154 };
    155 
    156 tuple<int&, float&> *t_int_ref_float_ref;
    157 tuple_of_refs<int&, float&>::types *t_int_ref_float_ref_2 =  t_int_ref_float_ref;
    158 
    159 template<typename ...Types>
    160 struct extract_nested_types {
    161   typedef tuple<typename Types::type...> types;
    162 };
    163 
    164 tuple<int, float> *t_int_float;
    165 extract_nested_types<identity<int>, identity<float> >::types *t_int_float_2
    166   = t_int_float;
    167 
    168 template<int ...N>
    169 struct tuple_of_ints {
    170   typedef tuple<int_c<N>...> type;
    171 };
    172 
    173 int check_temp_arg_1[is_same<tuple_of_ints<1, 2, 3, 4, 5>::type,
    174                              tuple<int_c<1>, int_c<2>, int_c<3>, int_c<4>,
    175                                    int_c<5>>>::value? 1 : -1];
    176 
    177 // In a dynamic-exception-specification (15.4); the pattern is a type-id.
    178 template<typename ...Types>
    179 struct f_with_except {
    180   virtual void f() throw(Types...); // expected-note{{overridden virtual function is here}}
    181 };
    182 
    183 struct check_f_with_except_1 : f_with_except<int, float> {
    184   virtual void f() throw(int, float);
    185 };
    186 
    187 struct check_f_with_except_2 : f_with_except<int, float> {
    188   virtual void f() throw(int);
    189 };
    190 
    191 struct check_f_with_except_3 : f_with_except<int, float> {
    192   virtual void f() throw(int, float, double); // expected-error{{exception specification of overriding function is more lax than base version}}
    193 };
    194