1 // RUN: %clang_cc1 -std=c++20 -verify %s 2 // RUN: %clang_cc1 -std=c++20 -verify %s -DDEPENDENT_OR 3 4 #ifdef DEPENDENT_OR 5 // This causes the || below to be a CXXOperatorCallExpr not a BinaryOperator. 6 struct A {}; bool operator||(A, A); 7 #endif 8 9 namespace PR45589 { 10 template<typename T> struct X { static constexpr bool value = T::value; }; // expected-error {{cannot be used prior to '::'}} 11 struct False { static constexpr bool value = false; }; 12 struct True { static constexpr bool value = true; }; 13 14 template<typename T> concept C = true; 15 16 template<bool B, typename T> constexpr int test = 0; 17 template<bool B, typename T> requires C<T> constexpr int test<B, T> = 1; 18 template<bool B, typename T> requires (B && C<T>) || (X<T>::value && C<T>) constexpr int test<B, T> = 2; // expected-error {{non-constant expression}} expected-note {{subexpression}} expected-note {{instantiation of}} expected-note {{while substituting}} 19 static_assert(test<true, False> == 2); 20 static_assert(test<true, True> == 2); 21 static_assert(test<true, char> == 2); // satisfaction of second term of || not considered 22 static_assert(test<false, False> == 1); 23 static_assert(test<false, True> == 2); // constraints are partially ordered 24 // FIXME: These diagnostics are excessive. 25 static_assert(test<false, char> == 1); // expected-note 2{{while}} expected-note 2{{during}} 26 } 27 28 namespace PR52905 { 29 // A mock for std::convertible_to. Not complete support. 30 template <typename _From, typename _To> 31 concept convertible_to = __is_convertible_to(_From, _To); // expected-note {{evaluated to false}} 32 33 template <typename T> 34 class A { 35 public: 36 using iterator = void **; 37 38 iterator begin(); 39 const iterator begin() const; 40 }; 41 42 template <class T> 43 concept Beginable1 = requires(T t) { 44 { t.begin } 45 ->convertible_to<typename T::iterator>; // expected-note {{not satisfied}} 46 }; 47 48 static_assert(Beginable1<A<int>>); // expected-error {{static_assert failed}} 49 // expected-note@-1 {{does not satisfy 'Beginable1'}} 50 51 template <class T> 52 concept Beginable2 = requires(T t) { 53 { t.begin() } 54 ->convertible_to<typename T::iterator>; 55 }; 56 57 static_assert(Beginable2<A<int>>); 58 } // namespace PR52905 59