e04e140adb
The previous approach broke code generation for the MS ABI due to an unintended code path during constraint substitution. This time we address the issue by inspecting the evaluation contexts and thereby avoiding that code path. This reapplies 96eced624 (#102857).
365 lines
8.7 KiB
C++
365 lines
8.7 KiB
C++
// RUN: %clang_cc1 -std=c++20 -verify %s
|
|
namespace GH53213 {
|
|
template<typename T>
|
|
concept c = requires(T t) { f(t); }; // #CDEF
|
|
|
|
auto f(c auto); // #FDEF
|
|
|
|
void g() {
|
|
f(0);
|
|
// expected-error@-1{{no matching function for call to 'f'}}
|
|
// expected-note@#FDEF{{constraints not satisfied}}
|
|
// expected-note@#FDEF{{because 'int' does not satisfy 'c'}}
|
|
// expected-note@#CDEF{{because 'f(t)' would be invalid: no matching function for call to 'f'}}
|
|
}
|
|
} // namespace GH53213
|
|
|
|
namespace GH45736 {
|
|
struct constrained;
|
|
|
|
template<typename T>
|
|
struct type {
|
|
};
|
|
template<typename T>
|
|
constexpr bool f(type<T>) {
|
|
return true;
|
|
}
|
|
|
|
template<typename T>
|
|
concept matches = f(type<T>());
|
|
|
|
|
|
struct constrained {
|
|
template<typename U> requires matches<U>
|
|
explicit constrained(U value) {
|
|
}
|
|
};
|
|
|
|
bool f(constrained const &) {
|
|
return true;
|
|
}
|
|
|
|
struct outer {
|
|
constrained state;
|
|
};
|
|
|
|
bool f(outer const & x) {
|
|
return f(x.state);
|
|
}
|
|
} // namespace GH45736
|
|
|
|
namespace DirectRecursiveCheck {
|
|
template<class T>
|
|
concept NotInf = true;
|
|
template<class T>
|
|
concept Inf = requires(T& v){ // #INF_REQ
|
|
{begin(v)}; // #INF_BEGIN_EXPR
|
|
};
|
|
|
|
void begin(NotInf auto& v){ } // #NOTINF_BEGIN
|
|
// This lookup should fail, since it results in a recursive check.
|
|
// However, this is a 'hard failure'(not a SFINAE failure or constraints
|
|
// violation), so it needs to cause the entire lookup to fail.
|
|
void begin(Inf auto& v){ } // #INF_BEGIN
|
|
|
|
struct my_range{
|
|
} rng;
|
|
|
|
void baz() {
|
|
auto it = begin(rng); // #BEGIN_CALL
|
|
// expected-error@#INF_BEGIN {{satisfaction of constraint 'Inf<Inf auto>' depends on itself}}
|
|
// expected-note@#INF_BEGIN {{while substituting template arguments into constraint expression here}}
|
|
// expected-note@#INF_BEGIN_EXPR {{while checking constraint satisfaction for template 'begin<DirectRecursiveCheck::my_range>' required here}}
|
|
// expected-note@#INF_BEGIN_EXPR {{while substituting deduced template arguments into function template 'begin'}}
|
|
// expected-note@#INF_BEGIN_EXPR {{in instantiation of requirement here}}
|
|
// expected-note@#INF_REQ {{while substituting template arguments into constraint expression here}}
|
|
// expected-note@#INF_BEGIN {{while checking the satisfaction of concept 'Inf<DirectRecursiveCheck::my_range>' requested here}}
|
|
// expected-note@#INF_BEGIN {{while substituting template arguments into constraint expression here}}
|
|
// expected-note@#BEGIN_CALL {{while checking constraint satisfaction for template 'begin<DirectRecursiveCheck::my_range>' required here}}
|
|
// expected-note@#BEGIN_CALL {{while substituting deduced template arguments into function template}}
|
|
|
|
// Fallout of the failure is failed lookup, which is necessary to stop odd
|
|
// cascading errors.
|
|
// expected-error@#BEGIN_CALL {{no matching function for call to 'begin'}}
|
|
// expected-note@#NOTINF_BEGIN {{candidate function}}
|
|
// expected-note@#INF_BEGIN{{candidate template ignored: constraints not satisfied}}
|
|
}
|
|
} // namespace DirectRecursiveCheck
|
|
|
|
namespace GH50891 {
|
|
template <typename T>
|
|
concept Numeric = requires(T a) { // #NUMERIC
|
|
foo(a); // #FOO_CALL
|
|
};
|
|
|
|
struct Deferred {
|
|
friend void foo(Deferred);
|
|
template <Numeric TO> operator TO(); // #OP_TO
|
|
};
|
|
|
|
static_assert(Numeric<Deferred>); // #STATIC_ASSERT
|
|
// expected-error@#NUMERIC{{satisfaction of constraint 'requires (T a) { foo(a); }' depends on itself}}
|
|
// expected-note@#NUMERIC {{while substituting template arguments into constraint expression here}}
|
|
// expected-note@#OP_TO {{while checking the satisfaction of concept 'Numeric<GH50891::Deferred>' requested here}}
|
|
// expected-note@#OP_TO {{while substituting template arguments into constraint expression here}}
|
|
// expected-note@#FOO_CALL {{while checking constraint satisfaction for template}}
|
|
// expected-note@#FOO_CALL {{while substituting deduced template arguments into function template}}
|
|
// expected-note@#FOO_CALL {{in instantiation of requirement here}}
|
|
// expected-note@#NUMERIC {{while substituting template arguments into constraint expression here}}
|
|
|
|
// expected-error@#STATIC_ASSERT {{static assertion failed}}
|
|
// expected-note@#STATIC_ASSERT{{while checking the satisfaction of concept 'Numeric<GH50891::Deferred>' requested here}}
|
|
// expected-note@#STATIC_ASSERT{{because substituted constraint expression is ill-formed: constraint depends on a previously diagnosed expression}}
|
|
|
|
} // namespace GH50891
|
|
|
|
|
|
namespace GH60323 {
|
|
// This should not diagnose, as it does not depend on itself.
|
|
struct End {
|
|
template<class T>
|
|
void go(T t) { }
|
|
|
|
template<class T>
|
|
auto endparens(T t)
|
|
requires requires { go(t); }
|
|
{ return go(t); }
|
|
};
|
|
|
|
struct Size {
|
|
template<class T>
|
|
auto go(T t)
|
|
{ return End().endparens(t); }
|
|
|
|
template<class T>
|
|
auto sizeparens(T t)
|
|
requires requires { go(t); }
|
|
{ return go(t); }
|
|
};
|
|
|
|
int f()
|
|
{
|
|
int i = 42;
|
|
Size().sizeparens(i);
|
|
}
|
|
}
|
|
|
|
namespace CWG2369_Regressions {
|
|
|
|
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109397
|
|
namespace GCC_103997 {
|
|
|
|
template<typename _type, typename _stream>
|
|
concept streamable = requires(_stream &s, _type &&v) {
|
|
s << static_cast<_type &&>(v);
|
|
};
|
|
|
|
struct type_a {
|
|
template<typename _arg>
|
|
type_a &operator<<(_arg &&) {
|
|
// std::clog << "type_a" << std::endl;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
struct type_b {
|
|
type_b &operator<<(type_a const &) {
|
|
// std::clog << "type_b" << std::endl;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
struct type_c {
|
|
type_b b;
|
|
template<typename _arg>
|
|
requires streamable<_arg, type_b>
|
|
friend type_c &operator<<(type_c &c, _arg &&a) {
|
|
// std::clog << "type_c" << std::endl;
|
|
c.b << static_cast<_arg &&>(a);
|
|
return c;
|
|
}
|
|
};
|
|
|
|
void foo() {
|
|
type_a a;
|
|
type_c c;
|
|
a << c; // "type_a\n" (gcc gives error here)
|
|
c << a; // "type_c\ntype_b\n"
|
|
}
|
|
|
|
}
|
|
|
|
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108393
|
|
namespace GCC_108393 {
|
|
|
|
template<class>
|
|
struct iterator_traits
|
|
{};
|
|
|
|
template<class T>
|
|
requires requires(T __t, T __u) { __t == __u; }
|
|
struct iterator_traits<T>
|
|
{};
|
|
|
|
template<class T>
|
|
concept C = requires { typename iterator_traits<T>::A; };
|
|
|
|
struct unreachable_sentinel_t
|
|
{
|
|
template<C _Iter>
|
|
friend constexpr bool operator==(unreachable_sentinel_t, const _Iter&) noexcept;
|
|
};
|
|
|
|
template<class T>
|
|
struct S
|
|
{};
|
|
|
|
static_assert(!C<S<unreachable_sentinel_t>>);
|
|
|
|
}
|
|
|
|
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107429
|
|
namespace GCC_107429 {
|
|
|
|
struct tag_foo { } inline constexpr foo;
|
|
struct tag_bar { } inline constexpr bar;
|
|
|
|
template<typename... T>
|
|
auto f(tag_foo, T... x)
|
|
{
|
|
return (x + ...);
|
|
}
|
|
|
|
template<typename... T>
|
|
concept fooable = requires (T... x) { f(foo, x...); };
|
|
|
|
template<typename... T> requires (fooable<T...>)
|
|
auto f(tag_bar, T... x)
|
|
{
|
|
return f(foo, x...);
|
|
}
|
|
|
|
auto test()
|
|
{
|
|
return f(bar, 1, 2, 3);
|
|
}
|
|
|
|
}
|
|
|
|
namespace GCC_99599 {
|
|
|
|
struct foo_tag {};
|
|
struct bar_tag {};
|
|
|
|
template <class T>
|
|
concept fooable = requires(T it) {
|
|
invoke_tag(foo_tag{}, it); // <-- here
|
|
};
|
|
|
|
template <class T> auto invoke_tag(foo_tag, T in) { return in; }
|
|
|
|
template <fooable T> auto invoke_tag(bar_tag, T it) { return it; }
|
|
|
|
int main() {
|
|
// Neither line below compiles in GCC 11, independently of the other
|
|
return invoke_tag(foo_tag{}, 2) + invoke_tag(bar_tag{}, 2);
|
|
}
|
|
|
|
}
|
|
|
|
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99599#c22
|
|
namespace GCC_99599_2 {
|
|
|
|
template<typename T> class indirect {
|
|
public:
|
|
template<typename U> requires
|
|
requires (const T& t, const U& u) { t == u; }
|
|
friend constexpr bool operator==(const indirect&, const U&) { return false; }
|
|
|
|
private:
|
|
T* _M_ptr{};
|
|
};
|
|
|
|
indirect<int> i;
|
|
bool b = i == 1;
|
|
|
|
}
|
|
|
|
namespace GCC_99599_3 {
|
|
|
|
template<typename T>
|
|
struct S { T t; };
|
|
|
|
template<typename T>
|
|
concept C = sizeof(S<T>) > 0;
|
|
|
|
struct I;
|
|
|
|
struct from_range_t {
|
|
explicit from_range_t() = default;
|
|
};
|
|
inline constexpr from_range_t from_range;
|
|
|
|
template<typename T>
|
|
concept FromRange = __is_same_as (T, from_range_t);
|
|
|
|
//#define WORKAROUND
|
|
#ifdef WORKAROUND
|
|
template<FromRange U, C T>
|
|
void f(U, T*);
|
|
#else
|
|
template<C T>
|
|
void f(from_range_t, T*);
|
|
#endif
|
|
|
|
void f(...);
|
|
|
|
void g(I* p) {
|
|
f(0, p);
|
|
}
|
|
|
|
}
|
|
|
|
namespace GCC_99599_4 {
|
|
|
|
struct A {
|
|
A(...);
|
|
};
|
|
|
|
template <class T> void f(A, T) { }
|
|
|
|
int main()
|
|
{
|
|
f(42, 24);
|
|
}
|
|
|
|
}
|
|
|
|
namespace FAILED_GCC_110160 {
|
|
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110160
|
|
// Current heuristic FAILED; GCC trunk also failed
|
|
// https://godbolt.org/z/r3Pz9Tehz
|
|
#if 0
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
template <class T>
|
|
concept StreamCanReceiveString = requires(T& t, std::string s) {
|
|
{ t << s };
|
|
};
|
|
|
|
struct NotAStream {};
|
|
struct UnrelatedType {};
|
|
|
|
template <StreamCanReceiveString S>
|
|
S& operator<<(S& s, UnrelatedType) {
|
|
return s;
|
|
}
|
|
|
|
static_assert(!StreamCanReceiveString<NotAStream>);
|
|
|
|
static_assert(StreamCanReceiveString<std::stringstream>);
|
|
#endif
|
|
}
|
|
}
|