1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks %s
// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
namespace explicit_argument_variadics {
template<class ... Ts> void print(Ts ... ) { }
struct X { };
struct Y { };
struct Z { };
int test() {
{
auto L = [](auto ... as) { };
L.operator()<bool>(true);
}
{
auto L = [](auto a) { };
L.operator()<bool>(false);
}
{
auto L = [](auto a, auto b) { };
L.operator()<bool>(false, 'a');
}
{
auto L = [](auto a, auto b) { };
L.operator()<bool, char>(false, 'a');
}
{
auto L = [](auto a, auto b, auto ... cs) { };
L.operator()<bool, char>(false, 'a');
L.operator()<bool, char, const char*>(false, 'a', "jim");
}
{
auto L = [](auto ... As) {
};
L.operator()<bool, double>(false, 3.14, "abc");
}
{
auto L = [](auto A, auto B, auto ... As) {
};
L.operator()<bool>(false, 3.14, "abc");
L.operator()<bool, char>(false, 3.14, "abc"); //expected-warning{{implicit conversion}}
L.operator()<X, Y, bool, Z>(X{}, Y{}, 3.14, Z{}, X{}); //expected-warning{{implicit conversion}}
}
{
auto L = [](auto ... As) {
print("\nL::As = ", As ...);
return [](decltype(As) ... as, auto ... Bs) {
print("\nL::Inner::as = ", as ...);
print("\nL::Inner::Bs = ", Bs ...);
return 4;
};
};
auto M = L.operator()<bool, double>(false, 3.14, "abc");
M(false, 6.26, "jim", true);
M.operator()<bool>(true, 6.26, "jim", false, 3.14);
}
{
auto L = [](auto A, auto ... As) {
print("\nL::As = ", As ...);
return [](decltype(As) ... as, decltype(A) a, auto ... Bs) {
print("\nL::Inner::as = ", as ...);
print("\nL::Inner::Bs = ", Bs ...);
return 4;
};
};
auto M = L.operator()<bool, double>(false, 3.14, "abc");
M(6.26, "jim", true);
M.operator()<X>(6.26, "jim", false, X{}, Y{}, Z{});
}
return 0;
}
int run = test();
} // end ns explicit_argument_extension
#ifdef PR18499_FIXED
namespace variadic_expansion {
void f(int &, char &);
template <typename ... T> void g(T &... t) {
f([&a(t)]()->decltype(auto) {
return a;
}() ...);
f([&a(f([&b(t)]()->decltype(auto) { return b; }()...), t)]()->decltype(auto) {
return a;
}()...);
}
void h(int i, char c) { g(i, c); }
}
#endif
|
