|
150
|
1 // RUN: %clang_cc1 -std=c++1z -verify %s
|
|
|
2 // RUN: %clang_cc1 -std=c++2a -verify %s
|
|
|
3
|
|
|
4 template<typename ...T> constexpr auto sum(T ...t) { return (... + t); }
|
|
|
5 template<typename ...T> constexpr auto product(T ...t) { return (t * ...); }
|
|
|
6 template<typename ...T> constexpr auto all(T ...t) { return (true && ... && t); }
|
|
|
7 template<typename ...T> constexpr auto dumb(T ...t) { return (false && ... && t); }
|
|
|
8
|
|
|
9 static_assert(sum(1, 2, 3, 4, 5) == 15);
|
|
|
10 static_assert(product(1, 2, 3, 4, 5) == 120);
|
|
|
11 static_assert(!all(true, true, false, true, false));
|
|
|
12 static_assert(all(true, true, true, true, true));
|
|
|
13 static_assert(!dumb(true, true, true, true, true));
|
|
|
14
|
|
|
15 struct S {
|
|
|
16 int a, b, c, d, e;
|
|
|
17 };
|
|
|
18 template<typename ...T> constexpr auto increment_all(T &...t) {
|
|
|
19 (++t, ...);
|
|
|
20 }
|
|
|
21 constexpr bool check() {
|
|
|
22 S s = { 1, 2, 3, 4, 5 };
|
|
|
23 increment_all(s.a, s.b, s.c, s.d, s.e);
|
|
|
24 return s.a == 2 && s.b == 3 && s.c == 4 && s.d == 5 && s.e == 6;
|
|
|
25 }
|
|
|
26 static_assert(check());
|
|
|
27
|
|
|
28 template<int ...N> void empty() {
|
|
|
29 static_assert((N || ...) == false);
|
|
|
30 static_assert((N && ...) == true);
|
|
|
31 (N, ...);
|
|
|
32 }
|
|
|
33 template void empty<>();
|
|
|
34
|
|
|
35 // An empty fold-expression isn't a null pointer just because it's an integer
|
|
|
36 // with value 0. (This is no longer an issue since empty pack expansions don't
|
|
|
37 // produce integers any more.)
|
|
|
38 template<int ...N> void null_ptr() {
|
|
|
39 void *p = (N || ...); // expected-error {{rvalue of type 'bool'}}
|
|
|
40 void *q = (N , ...); // expected-error {{rvalue of type 'void'}}
|
|
|
41 }
|
|
|
42 template void null_ptr<>(); // expected-note {{in instantiation of}}
|
|
|
43
|
|
|
44 template<int ...N> void bad_empty() {
|
|
|
45 (N + ...); // expected-error {{empty expansion for operator '+' with no fallback}}
|
|
|
46 (N * ...); // expected-error {{empty expansion for operator '*' with no fallback}}
|
|
|
47 (N | ...); // expected-error {{empty expansion for operator '|' with no fallback}}
|
|
|
48 (N & ...); // expected-error {{empty expansion for operator '&' with no fallback}}
|
|
|
49 (N - ...); // expected-error {{empty expansion for operator '-' with no fallback}}
|
|
|
50 (N / ...); // expected-error {{empty expansion for operator '/' with no fallback}}
|
|
|
51 (N % ...); // expected-error {{empty expansion for operator '%' with no fallback}}
|
|
|
52 (N = ...); // expected-error {{empty expansion for operator '=' with no fallback}}
|
|
|
53 }
|
|
|
54 template void bad_empty<>(); // expected-note {{in instantiation of}}
|
|
|
55
|
|
|
56 template<int ...N> void empty_with_base() {
|
|
|
57 extern int k;
|
|
|
58 (k = ... = N); // expected-warning{{unused}}
|
|
|
59
|
|
|
60 void (k = ... = N); // expected-error {{expected ')'}} expected-note {{to match}}
|
|
|
61 void ((k = ... = N));
|
|
|
62 (void) (k = ... = N);
|
|
|
63 }
|
|
|
64 template void empty_with_base<>(); // expected-note {{in instantiation of}}
|
|
|
65 template void empty_with_base<1>();
|
|
|
66
|
|
|
67 struct A {
|
|
|
68 struct B {
|
|
|
69 struct C {
|
|
|
70 struct D {
|
|
|
71 int e;
|
|
|
72 } d;
|
|
|
73 } c;
|
|
|
74 } b;
|
|
|
75 } a;
|
|
|
76 template<typename T, typename ...Ts> constexpr decltype(auto) apply(T &t, Ts ...ts) {
|
|
|
77 return (t.*....*ts);
|
|
|
78 }
|
|
|
79 static_assert(&apply(a, &A::b, &A::B::c, &A::B::C::d, &A::B::C::D::e) == &a.b.c.d.e);
|
|
|
80
|
|
|
81 #if __cplusplus > 201703L
|
|
|
82 // The <=> operator is unique among binary operators in not being a
|
|
|
83 // fold-operator.
|
|
|
84 // FIXME: This diagnostic is not great.
|
|
|
85 template<typename ...T> constexpr auto spaceship1(T ...t) { return (t <=> ...); } // expected-error {{expected expression}}
|
|
|
86 template<typename ...T> constexpr auto spaceship2(T ...t) { return (... <=> t); } // expected-error {{expected expression}}
|
|
|
87 template<typename ...T> constexpr auto spaceship3(T ...t) { return (t <=> ... <=> 0); } // expected-error {{expected expression}}
|
|
|
88 #endif
|
|
|
89
|
|
|
90 // The GNU binary conditional operator ?: is not recognized as a fold-operator.
|
|
|
91 // FIXME: Why not? This seems like it would be useful.
|
|
|
92 template<typename ...T> constexpr auto binary_conditional1(T ...t) { return (t ?: ...); } // expected-error {{expected expression}}
|
|
|
93 template<typename ...T> constexpr auto binary_conditional2(T ...t) { return (... ?: t); } // expected-error {{expected expression}}
|
|
|
94 template<typename ...T> constexpr auto binary_conditional3(T ...t) { return (t ?: ... ?: 0); } // expected-error {{expected expression}}
|
|
|
95
|
|
|
96 namespace PR41845 {
|
|
|
97 template <int I> struct Constant {};
|
|
|
98
|
|
|
99 template <int... Is> struct Sum {
|
|
|
100 template <int... Js> using type = Constant<((Is + Js) + ... + 0)>; // expected-error {{pack expansion contains parameter pack 'Js' that has a different length (1 vs. 2) from outer parameter packs}}
|
|
|
101 };
|
|
|
102
|
|
|
103 Sum<1>::type<1, 2> x; // expected-note {{instantiation of}}
|
|
|
104 }
|
|
221
|
105
|
|
|
106 namespace PR30738 {
|
|
|
107 namespace N {
|
|
|
108 struct S {};
|
|
|
109 }
|
|
|
110
|
|
|
111 namespace T {
|
|
|
112 void operator+(N::S, N::S) {}
|
|
|
113 template<typename ...Ts> void f() { (Ts{} + ...); }
|
|
|
114 }
|
|
|
115
|
|
|
116 void g() { T::f<N::S, N::S>(); }
|
|
|
117
|
|
|
118 template<typename T, typename ...U> auto h(U ...v) {
|
|
|
119 T operator+(T, T); // expected-note {{candidate}}
|
|
|
120 return (v + ...); // expected-error {{invalid operands}}
|
|
|
121 }
|
|
|
122 int test_h1 = h<N::S>(1, 2, 3);
|
|
|
123 N::S test_h2 = h<N::S>(N::S(), N::S(), N::S());
|
|
|
124 int test_h3 = h<struct X>(1, 2, 3);
|
|
|
125 N::S test_h4 = h<struct X>(N::S(), N::S(), N::S()); // expected-note {{instantiation of}}
|
|
|
126 }
|
