1 // RUN: %clang_cc1 -std=c++1z -verify %s
2
sum(T...t)3 template<typename ...T> constexpr auto sum(T ...t) { return (... + t); }
product(T...t)4 template<typename ...T> constexpr auto product(T ...t) { return (t * ...); }
all(T...t)5 template<typename ...T> constexpr auto all(T ...t) { return (true && ... && t); }
all2(T...t)6 template<typename ...T> constexpr auto all2(T ...t) { return (t && ... && true); }
7
8 int k1 = (1 + ... + 2); // expected-error {{does not contain any unexpanded parameter packs}}
9 int k2 = (1 + ...); // expected-error {{does not contain any unexpanded parameter packs}}
10 int k3 = (... + 2); // expected-error {{does not contain any unexpanded parameter packs}}
11
12 struct A { A(int); friend A operator+(A, A); A operator-(A); A operator()(A); A operator[](A); };
13 A operator*(A, A);
14
bad1()15 template<int ...N> void bad1() { (N + ... + N); } // expected-error {{unexpanded parameter packs in both operands}}
16 // FIXME: it would be reasonable to support this as an extension.
bad2()17 template<int ...N> void bad2() { (2 * N + ... + 1); } // expected-error {{expression not permitted as operand}}
bad3()18 template<int ...N> void bad3() { (2 + N * ... * 1); } // expected-error {{expression not permitted as operand}}
bad4(int (&...x)[N])19 template<int ...N, int ...M> void bad4(int (&...x)[N]) { (N + M * ... * 1); } // expected-error {{expression not permitted as operand}}
fixed4(int (&...x)[N])20 template<int ...N, int ...M> void fixed4(int (&...x)[N]) { ((N + M) * ... * 1); }
bad4a(T...t)21 template<typename ...T> void bad4a(T ...t) { (t * 2 + ... + 1); } // expected-error {{expression not permitted as operand}}
bad4b()22 template<int ...N> void bad4b() { (A(0) + A(N) + ...); } // expected-error {{expression not permitted as operand}}
bad4c()23 template<int ...N> void bad4c() { (A(0) - A(N) + ...); } // expected-error {{expression not permitted as operand}}
bad4d()24 template<int ...N> void bad4d() { (A(0)(A(0)) + ... + A(0)[A(N)]); }
25
26 // Parens are mandatory.
bad5()27 template<int ...N> void bad5() { N + ...; } // expected-error {{expected expression}} expected-error +{{}}
bad6()28 template<int ...N> void bad6() { ... + N; } // expected-error {{expected expression}}
bad7()29 template<int ...N> void bad7() { N + ... + N; } // expected-error {{expected expression}} expected-error +{{}}
30
31 // Must have a fold-operator in the relevant places.
bad8()32 template<int ...N> int bad8() { return (N + ... * 3); } // expected-error {{operators in fold expression must be the same}}
bad9()33 template<int ...N> int bad9() { return (3 + ... * N); } // expected-error {{operators in fold expression must be the same}}
bad10()34 template<int ...N> int bad10() { return (3 ? ... : N); } // expected-error +{{}} expected-note {{to match}}
bad11()35 template<int ...N> int bad11() { return (N + ... 0); } // expected-error {{expected a foldable binary operator}} expected-error {{expected expression}}
bad12()36 template<int ...N> int bad12() { return (... N); } // expected-error {{expected expression}}
37
as_operand_of_cast(int a,T...t)38 template<typename ...T> void as_operand_of_cast(int a, T ...t) {
39 return
40 (int)(a + ... + undeclared_junk) + // expected-error {{undeclared}} expected-error {{does not contain any unexpanded}}
41 (int)(t + ... + undeclared_junk) + // expected-error {{undeclared}}
42 (int)(... + undeclared_junk) + // expected-error {{undeclared}} expected-error {{does not contain any unexpanded}}
43 (int)(undeclared_junk + ...) + // expected-error {{undeclared}}
44 (int)(a + ...) + // expected-error {{does not contain any unexpanded}}
45 (int)(a, ...) + // expected-error {{does not contain any unexpanded}}
46 (int)(..., a) + // expected-error {{does not contain any unexpanded}}
47 (int)(a, ..., undeclared_junk) + // expected-error {{undeclared}} expected-error {{does not contain any unexpanded}}
48 (int)(t, ...) +
49 (int)(..., t) +
50 (int)(t, ..., a);
51 }
52
53 // fold-operator can be '>' or '>>'.
greaterThan()54 template <int... N> constexpr bool greaterThan() { return (N > ...); }
rightShift()55 template <int... N> constexpr int rightShift() { return (N >> ...); }
56
57 static_assert(greaterThan<2, 1>());
58 static_assert(rightShift<10, 1>() == 5);
59
60 template <auto V> constexpr auto Identity = V;
61
62 // Support fold operators within templates.
nestedFoldOperator()63 template <int... N> constexpr int nestedFoldOperator() {
64 return Identity<(Identity<0> >> ... >> N)> +
65 Identity<(N >> ... >> Identity<0>)>;
66 }
67
68 static_assert(nestedFoldOperator<3, 1>() == 1);
69
70 // A fold-expression is a primary-expression.
71 template <typename T, typename... Ts>
castSum(Ts...Args)72 constexpr auto castSum(Ts... Args) {
73 return (T)(Args + ...).Value; // expected-error{{member reference base type 'int' is not a structure or union}}
74 }
75
76 template <typename... Ts>
simpleSum(Ts...Args)77 constexpr auto simpleSum(Ts... Args) {
78 return (... + Args).Value; // expected-error{{member reference base type 'int' is not a structure or union}}
79 }
80
prim()81 void prim() {
82 castSum<int>(1, 2);
83 // expected-note@-1{{in instantiation of function template specialization}}
84 simpleSum(1, 2);
85 // expected-note@-1{{in instantiation of function template specialization}}
86
87 struct Number {
88 int Value;
89 constexpr Number operator+(Number Rhs) const { return {Rhs.Value + Value}; }
90 };
91
92 static_assert(castSum<long>(Number{1}, Number{2}) == 3);
93 static_assert(simpleSum(Number{1}, Number{2}) == 3);
94 }
95