114 lines
3.3 KiB
C++
114 lines
3.3 KiB
C++
// 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}}
|
|
}
|