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
|
// RUN: %clang_cc1 -std=c++03 -verify -Dstatic_assert=_Static_assert -Wno-c++11-extensions -Wno-c++14-extensions -Wno-c++17-extensions -Wno-c++20-extensions %s
// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx11,cxx11-cxx14 -Wno-c++20-extensions -Wno-c++17-extensions -Wno-c++14-extensions %s
// RUN: %clang_cc1 -std=c++14 -verify=expected,cxx11-cxx14,cxx14 -Wno-c++20-extensions -Wno-c++17-extensions %s
// RUN: %clang_cc1 -std=c++17 -verify -Wno-c++20-extensions %s
// RUN: %clang_cc1 -std=c++20 -verify %s
template<typename, typename>
inline const bool is_same = false;
template<typename T>
inline const bool is_same<T, T> = true;
template<typename T>
struct DummyTemplate { };
void func() {
auto L0 = []<typename T>(T arg) {
static_assert(is_same<T, int>); // expected-error {{static assertion failed}}
};
L0(0);
L0(0.0); // expected-note {{in instantiation}}
auto L1 = []<int I> {
static_assert(I == 5); // expected-error {{static assertion failed}}
};
L1.operator()<5>();
L1.operator()<6>(); // expected-note {{in instantiation}}
auto L2 = []<template<typename> class T, class U>(T<U> &&arg) {
static_assert(is_same<T<U>, DummyTemplate<float> >); // // expected-error {{static assertion failed}}
};
L2(DummyTemplate<float>());
L2(DummyTemplate<double>()); // expected-note {{in instantiation}}
}
template<typename T> // expected-note {{declared here}}
struct ShadowMe {
void member_func() {
auto L = []<typename T> { }; // expected-error {{'T' shadows template parameter}}
}
};
#if __cplusplus >= 201102L
template<typename T>
constexpr T outer() {
// FIXME: The C++11 error seems wrong
return []<T x>() { return x; }.template operator()<123>(); // expected-error {{no matching member function}} \
expected-note {{candidate template ignored}} \
cxx11-note {{non-literal type '<dependent type>' cannot be used in a constant expression}} \
cxx14-note {{non-literal type}}
}
static_assert(outer<int>() == 123); // cxx11-cxx14-error {{not an integral constant expression}} cxx11-cxx14-note {{in call}}
template int *outer<int *>(); // expected-note {{in instantiation}}
#endif
#if __cplusplus >= 202002L
namespace GH62611 {
template <auto A = [](auto x){}>
struct C {
static constexpr auto B = A;
};
int test() {
C<>::B(42);
}
namespace AutoParam
{
template <auto A = [](auto x) { return x;}>
auto B = A;
static_assert(B<>(42) == 42);
}
namespace TypeParam
{
template <typename T = decltype([](auto x) {return x;})>
auto B = T{};
static_assert(B<>(42) == 42);
}
}
namespace GH64689 {
void f();
void foo() {
[]<typename T>(int)
noexcept(requires(int t) { f(); })
-> decltype(requires(int t) { f(); })
requires requires(int t) { f(); }
{return {};}.operator()<int>(0);
[](auto)
noexcept(requires(int t) { f(); })
-> decltype(requires(int t) { f(); })
requires requires(int t) { f(); }
{return {};}(1);
}
}
#endif
|
