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 an initializer-list (8.5); the pattern is an initializer-clause.
24 // Note: this also covers expression-lists, since expression-list is
25 // just defined as initializer-list.
26 void five_args(int, int, int, int, int); // expected-note{{candidate function not viable: requires 5 arguments, but 6 were provided}}
27 
28 template<int ...Values>
29 void initializer_list_expansion() {
30   int values[5] = { Values... }; // expected-error{{excess elements in array initializer}}
31   five_args(Values...); // expected-error{{no matching function for call to 'five_args'}}
32 }
33 
34 template void initializer_list_expansion<1, 2, 3, 4, 5>();
35 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}}
36 
37 namespace PR8977 {
38   struct A { };
39   template<typename T, typename... Args> void f(Args... args) {
40     T t(args...);
41   };
42 
43   template void f<A>();
44 }
45 
46 // In a base-specifier-list (Clause 10); the pattern is a base-specifier.
47 template<typename ...Mixins>
48 struct HasMixins : public Mixins... {
49   HasMixins();
50   HasMixins(const HasMixins&);
51   HasMixins(int i);
52 };
53 
54 struct A { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const A' for 1st argument}} \
55 // expected-note{{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'A' for 1st argument}} \
56 // expected-note{{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
57 struct B { };
58 struct C { };
59 struct D { };
60 
61 A *checkA = new HasMixins<A, B, C, D>;
62 B *checkB = new HasMixins<A, B, C, D>;
63 D *checkD = new HasMixins<A, B, C, D>;
64 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> *'}}
65 HasMixins<> *checkNone = new HasMixins<>;
66 
67 template<typename Mixins>
68 struct BrokenMixins : public Mixins... { }; // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
69 
70 // In a mem-initializer-list (12.6.2); the pattern is a mem-initializer.
71 template<typename ...Mixins>
72 HasMixins<Mixins...>::HasMixins(): Mixins()... { }
73 
74 template<typename ...Mixins>
75 HasMixins<Mixins...>::HasMixins(const HasMixins &other): Mixins(other)... { }
76 
77 template<typename ...Mixins>
78 HasMixins<Mixins...>::HasMixins(int i): Mixins(i)... { } // expected-error{{no matching constructor for initialization of 'A'}}
79 
80 void test_has_mixins() {
81   HasMixins<A, B> ab;
82   HasMixins<A, B> ab2 = ab;
83   HasMixins<A, B> ab3(17); // expected-note{{in instantiation of member function 'HasMixins<A, B>::HasMixins' requested here}}
84 }
85 
86 template<typename T>
87 struct X {
88   T member;
89 
90   X() : member()... { } // expected-error{{pack expansion for initialization of member 'member'}}
91 };
92 
93 // In a template-argument-list (14.3); the pattern is a template-argument.
94 template<typename ...Types>
95 struct tuple_of_refs {
96   typedef tuple<Types& ...> types;
97 };
98 
99 tuple<int&, float&> *t_int_ref_float_ref;
100 tuple_of_refs<int&, float&>::types *t_int_ref_float_ref_2 =  t_int_ref_float_ref;
101 
102 template<typename ...Types>
103 struct extract_nested_types {
104   typedef tuple<typename Types::type...> types;
105 };
106 
107 tuple<int, float> *t_int_float;
108 extract_nested_types<identity<int>, identity<float> >::types *t_int_float_2
109   = t_int_float;
110 
111 template<int ...N>
112 struct tuple_of_ints {
113   typedef tuple<int_c<N>...> type;
114 };
115 
116 int check_temp_arg_1[is_same<tuple_of_ints<1, 2, 3, 4, 5>::type,
117                              tuple<int_c<1>, int_c<2>, int_c<3>, int_c<4>,
118                                    int_c<5>>>::value? 1 : -1];
119 
120 // In a dynamic-exception-specification (15.4); the pattern is a type-id.
121 template<typename ...Types>
122 struct f_with_except {
123   virtual void f() throw(Types...); // expected-note{{overridden virtual function is here}}
124 };
125 
126 struct check_f_with_except_1 : f_with_except<int, float> {
127   virtual void f() throw(int, float);
128 };
129 
130 struct check_f_with_except_2 : f_with_except<int, float> {
131   virtual void f() throw(int);
132 };
133 
134 struct check_f_with_except_3 : f_with_except<int, float> {
135   virtual void f() throw(int, float, double); // expected-error{{exception specification of overriding function is more lax than base version}}
136 };
137