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
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// RUN: %clang_cc1 -std=c++2a -verify %s
template<typename T, typename U>
constexpr static bool is_same_v = false;
template<typename T>
constexpr static bool is_same_v<T, T> = true;
namespace templates
{
template<typename T>
concept AtLeast1 = sizeof(T) >= 1;
template<typename T>
int foo(T t) requires (sizeof(T) == 4) { // expected-note {{candidate function}}
return 0;
}
template<typename T>
char foo(T t) requires AtLeast1<T> { // expected-note {{candidate function}}
return 'a';
}
template<typename T>
double foo(T t) requires (AtLeast1<T> && sizeof(T) <= 2) {
return 'a';
}
static_assert(is_same_v<decltype(foo(10)), int>); // expected-error {{call to 'foo' is ambiguous}}
static_assert(is_same_v<decltype(foo(short(10))), double>);
template<typename T>
void bar() requires (sizeof(T) == 1) { }
// expected-note@-1{{similar constraint expressions not considered equivalent}}
// expected-note@-2{{candidate function [with T = char]}}
template<typename T>
void bar() requires (sizeof(T) == 1 && sizeof(T) >= 0) { }
// expected-note@-1{{candidate function [with T = char]}}
// expected-note@-2{{similar constraint expression here}}
static_assert(is_same_v<decltype(bar<char>()), void>);
// expected-error@-1{{call to 'bar' is ambiguous}}
template<typename T>
constexpr int baz() requires AtLeast1<T> { // expected-note {{candidate function}}
return 1;
}
template<typename T> requires AtLeast1<T>
constexpr int baz() { // expected-note {{candidate function [with T = int]}}
return 2;
}
static_assert(baz<int>() == 1); // expected-error {{call to 'baz' is ambiguous}}
}
namespace non_template
{
template<typename T>
concept AtLeast2 = sizeof(T) >= 2;
template<typename T>
concept AtMost8 = sizeof(T) <= 8;
int foo() requires AtLeast2<long> && AtMost8<long> {
return 0;
}
double foo() requires AtLeast2<long> {
return 0.0;
}
double baz() requires AtLeast2<long> && AtMost8<long> { // expected-note {{candidate function}}
return 0.0;
}
int baz() requires AtMost8<long> && AtLeast2<long> { // expected-note {{candidate function}}
return 0.0;
}
void bar() requires (sizeof(char[8]) >= 8) { }
// expected-note@-1 {{candidate function}}
// expected-note@-2 {{similar constraint expressions not considered equivalent}}
void bar() requires (sizeof(char[8]) >= 8 && sizeof(int) <= 30) { }
// expected-note@-1 {{candidate function}}
// expected-note@-2 {{similar constraint expression here}}
static_assert(is_same_v<decltype(foo()), int>);
static_assert(is_same_v<decltype(baz()), int>); // expected-error {{call to 'baz' is ambiguous}}
static_assert(is_same_v<decltype(bar()), void>); // expected-error {{call to 'bar' is ambiguous}}
constexpr int goo(int a) requires AtLeast2<int> && true {
return 1;
}
constexpr int goo(const int b) requires AtLeast2<int> {
return 2;
}
// Only trailing requires clauses of redeclarations are compared for overload resolution.
constexpr int doo(int a, ...) requires AtLeast2<int> && true { // expected-note {{candidate function}}
return 1;
}
constexpr int doo(int b) requires AtLeast2<int> { // expected-note {{candidate function}}
return 2;
}
static_assert(goo(1) == 1);
static_assert(doo(2) == 1); // expected-error {{call to 'doo' is ambiguous}}
}
|
