// RUN: %clang_cc1 -std=c++2a -verify %s
struct S2 {};
// expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'S1<int>' to 'const S2' for 1st argument}}
// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'S1<int>' to 'S2' for 1st argument}}
// expected-note@-3 {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
template<typename T>
struct S1 {
void foo() const requires true {}
void foo() const requires false {}
void bar() const requires false {}
// expected-note@-1 {{because 'false' evaluated to false}}
operator bool() const requires true { return true; }
explicit operator bool() const requires false;
explicit operator S2() const requires false;
// expected-note@-1 {{candidate function not viable: constraints not satisfied}}
// expected-note@-2 {{because 'false' evaluated to false}}
};
void foo() {
S1<int>().foo();
S1<int>().bar();
// expected-error@-1 {{invalid reference to function 'bar': constraints not satisfied}}
(void) static_cast<bool>(S1<int>());
(void) static_cast<S2>(S1<int>());
// expected-error@-1 {{no matching conversion for static_cast from 'S1<int>' to 'S2'}}
}
// Test that constraints are checked before implicit conversions are formed.
template<typename T>
struct invalid_template { using X = typename T::non_existant; };
struct A {
template<typename T, bool=invalid_template<T>::aadasas>
operator T() {}
};
template<typename>
struct WrapsStatics {
static void foo(int) requires false;
static void foo(A) requires true;
};
template<typename T>
struct S {
void foo(int) requires false;
void foo(A) requires true;
S(A) requires false;
S(double) requires true;
~S() requires false;
~S() requires true;
operator int() requires true;
operator int() requires false;
};
void bar() {
WrapsStatics<int>::foo(A{});
S<int>{1.}.foo(A{});
S<int> s = 1;
int a = s;
}