272 lines · cpp
1// RUN: %clang_cc1 -std=c++2c -fexperimental-new-constant-interpreter -verify=expected,both %s2// RUN: %clang_cc1 -std=c++2c -verify=ref,both %s3 4// both-no-diagnostics5 6namespace std {7inline namespace {8template <class _Tp, _Tp __v> struct integral_constant {9 static const _Tp value = __v;10};11template <bool _Val> using _BoolConstant = integral_constant<bool, _Val>;12template <class _Tp> using __remove_cv_t = __remove_cv(_Tp);13template <class _Tp> using remove_cv_t = __remove_cv_t<_Tp>;14} // namespace15inline namespace __1 {16template <class _Tp>17using __libcpp_remove_reference_t = __remove_reference_t(_Tp);18template <bool, class _IfRes, class> using conditional_t = _IfRes;19template <class _Tp, class _Up>20using _IsSame = _BoolConstant<__is_same(_Tp, _Up)>;21template <class _Tp> struct enable_if {22 typedef _Tp type;23};24template <bool, class _Tp = void> using __enable_if_t = _Tp;25template <class _Bp, class _Dp>26constexpr bool is_base_of_v = __is_base_of(_Bp, _Dp);27template <class _Tp> _Tp __declval(long);28template <class _Tp> decltype(__declval<_Tp>(0)) declval();29template <class _Fp, class... _Args>30constexpr decltype(declval<_Fp>()(declval<_Args>()...))31__invoke(_Fp __f, _Args... __args) {32 return (__f)((__args)...);33}34template <class, class _Fp, class... _Args> struct __invokable_r {35 template <class _XFp, class... _XArgs>36 static decltype(__invoke(declval<_XFp>(), declval<_XArgs>()...))37 __try_call(int);38 using _Result = decltype(__try_call<_Fp, _Args...>(0));39};40template <class _Func, class... _Args>41struct __invoke_result42 : enable_if<typename __invokable_r<void, _Func, _Args...>::_Result> {};43template <class _Fn, class... _Args>44using invoke_result_t = __invoke_result<_Fn, _Args...>::type;45template <class _Tp> constexpr __libcpp_remove_reference_t<_Tp> &&move(_Tp &&);46template <class _From, class _To>47constexpr bool is_convertible_v = __is_convertible(_From, _To);48template <class _From, class _To>49concept convertible_to =50 is_convertible_v<_From, _To> && requires { (declval<_From>()); };51template <class _Tp, class _Up>52concept __same_as_impl = _IsSame<_Tp, _Up>::value;53template <class _Tp, class _Up>54concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;55template <class _Tp> using __remove_cvref_t = __remove_cvref(_Tp);56template <class _Tp> using remove_cvref_t = __remove_cvref_t<_Tp>;57template <class _Xp, class _Yp>58using __cond_res =59 decltype(false ? declval<_Xp (&)()>()() : declval<_Yp (&)()>()());60template <class...> struct common_reference;61template <class... _Types>62using common_reference_t = common_reference<_Types...>::type;63template <class, class> struct __common_reference_sub_bullet3;64template <class _Tp, class _Up>65struct common_reference<_Tp, _Up> : __common_reference_sub_bullet3<_Tp, _Up> {};66template <class _Tp, class _Up>67 requires requires { typename __cond_res<_Tp, _Up>; }68struct __common_reference_sub_bullet3<_Tp, _Up> {69 using type = __cond_res<_Tp, _Up>;70};71template <class _Tp, class _Up>72concept common_reference_with =73 same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&74 convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&75 convertible_to<_Up, common_reference_t<_Tp, _Up>>;76template <class _Tp>77using __make_const_lvalue_ref = __libcpp_remove_reference_t<_Tp>;78template <class _Lhs, class _Rhs>79concept assignable_from =80 common_reference_with<__make_const_lvalue_ref<_Lhs>,81 __make_const_lvalue_ref<_Rhs>> &&82 requires(_Lhs __lhs, _Rhs __rhs) {83 { __lhs = (__rhs) };84 };85template <class _Tp>86concept default_initializable = requires { _Tp{}; };87template <class _Tp> constexpr bool is_object_v = __is_object(_Tp);88template <class _Dp, class _Bp>89concept derived_from = is_base_of_v<_Bp, _Dp> && is_convertible_v<_Dp *, _Bp *>;90template <class _Tp, class _Up>91concept __weakly_equality_comparable_with = requires(92 __make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {93 { __u };94};95template <class _Fn, class... _Args>96constexpr invoke_result_t<_Fn, _Args...> invoke(_Fn __f, _Args &&...__args) {97 return __invoke((__f), (__args)...);98}99template <class _Fn, class... _Args>100concept invocable =101 requires(_Fn __fn, _Args... __args) { invoke((__fn), (__args)...); };102template <class _Fn, class... _Args>103concept regular_invocable = invocable<_Fn, _Args...>;104template <template <class> class, class>105integral_constant<bool, false> __sfinae_test_impl();106template <template <class> class _Templ, class... _Args>107using _IsValidExpansion = decltype(__sfinae_test_impl<_Templ, _Args...>());108template <class _Tp>109using __test_for_primary_template =110 __enable_if_t<_IsSame<_Tp, typename _Tp::__primary_template>::value>;111template <class _Tp>112using __is_primary_template =113 _IsValidExpansion<__test_for_primary_template, _Tp>;114template <class> struct __cond_value_type;115template <class _Tp>116 requires is_object_v<_Tp>117struct __cond_value_type<_Tp> {118 using value_type = remove_cv_t<_Tp>;119};120template <class _Tp>121concept __has_member_value_type = requires { typename _Tp; };122template <class> struct indirectly_readable_traits;123template <class _Tp>124struct indirectly_readable_traits<_Tp *> : __cond_value_type<_Tp> {};125template <__has_member_value_type _Tp>126struct indirectly_readable_traits<_Tp>127 : __cond_value_type<typename _Tp::value_type> {};128template <bool> struct _OrImpl;129template <> struct _OrImpl<true> {130 template <class, class _First, class... _Rest>131 using _Result =132 _OrImpl<!bool() && sizeof...(_Rest)>::template _Result<_First, _Rest...>;133};134template <> struct _OrImpl<false> {135 template <class _Res> using _Result = _Res;136};137template <class... _Args>138using _Or =139 _OrImpl<sizeof...(_Args) !=140 0>::template _Result<integral_constant<bool, false>, _Args...>;141template <class _Tp>142concept __dereferenceable = requires(_Tp __t) {143 { __t };144};145template <__dereferenceable _Tp>146using iter_reference_t = decltype(*declval<_Tp>());147struct input_iterator_tag {};148struct forward_iterator_tag : input_iterator_tag {};149struct bidirectional_iterator_tag : forward_iterator_tag {};150struct __iter_concept_random_fallback {151 template <class>152 using _Apply = __enable_if_t<__is_primary_template<int>::value,153 bidirectional_iterator_tag>;154};155template <class _Tester> struct __test_iter_concept : _Tester {};156struct __iter_concept_cache {157 using type = _Or<__test_iter_concept<__iter_concept_random_fallback>>;158};159template <class _Iter>160using _ITER_CONCEPT = __iter_concept_cache::type::_Apply<_Iter>;161template <class _Ip>162using iter_value_t =163 conditional_t<__is_primary_template<int>::value,164 indirectly_readable_traits<remove_cvref_t<_Ip>>,165 int>::value_type;166namespace ranges {167struct Trans_NS___iter_move___fn {168 template <class _Ip> auto operator()(_Ip __i) const -> decltype(std::move(*(__i)));169};170inline namespace {171auto iter_move = Trans_NS___iter_move___fn{};172}173} // namespace ranges174template <__dereferenceable _Tp>175 requires requires {176 { ranges::iter_move };177 }178using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<_Tp>()));179template <class _In>180concept __indirectly_readable_impl =181 requires(_In __i) {182 { ranges::iter_move(__i) } -> same_as<iter_rvalue_reference_t<_In>>;183 } && common_reference_with<iter_reference_t<_In>, iter_value_t<_In>> &&184 common_reference_with<iter_reference_t<_In>,185 iter_rvalue_reference_t<_In>> &&186 common_reference_with<iter_rvalue_reference_t<_In>, iter_value_t<_In>>;187template <class _In>188concept indirectly_readable = __indirectly_readable_impl<remove_cvref_t<_In>>;189template <class _Tp> struct __indirect_value_t_impl {190 using type = iter_value_t<_Tp>;191};192template <indirectly_readable _Tp>193using __indirect_value_t = __indirect_value_t_impl<_Tp>::type;194template <class _Sp, class _Ip>195concept sentinel_for = __weakly_equality_comparable_with<_Sp, _Ip>;196template <class _Ip>197concept input_iterator = requires { typename _ITER_CONCEPT<_Ip>; } &&198 derived_from<_ITER_CONCEPT<_Ip>, input_iterator_tag>;199template <class _Fp, class _It>200concept indirectly_unary_invocable =201 invocable<_Fp, __indirect_value_t<_It>> &&202 invocable<_Fp, iter_reference_t<_It>> &&203 common_reference_with<invoke_result_t<_Fp, __indirect_value_t<_It>>,204 invoke_result_t<_Fp, iter_reference_t<_It>>>;205template <class _Fp, class _It>206concept indirectly_regular_unary_invocable =207 regular_invocable<_Fp, __indirect_value_t<_It>> &&208 regular_invocable<_Fp, iter_reference_t<_It>> &&209 common_reference_with<invoke_result_t<_Fp, __indirect_value_t<_It>>,210 invoke_result_t<_Fp, iter_reference_t<_It>>>;211template <class _Fp, class... _Its>212 requires(indirectly_readable<_Its> && ...) &&213 invocable<_Fp, iter_reference_t<_Its>...>214using indirect_result_t = invoke_result_t<_Fp, iter_reference_t<_Its>...>;215template <class _It, class _Proj> struct __projected_impl {216 struct __type {217 using value_type = remove_cvref_t<indirect_result_t<_Proj, _It>>;218 indirect_result_t<_Proj, _It> operator*();219 };220};221template <indirectly_readable _It,222 indirectly_regular_unary_invocable<_It> _Proj>223using projected = __projected_impl<_It, _Proj>::__type;224namespace ranges {225template <class, class> using for_each_result = int;226 227struct Z {};228constexpr Z zomg() {229 return {};230}231constexpr Z zomg2(Z z) {232 return {};233}234 235struct __for_each {236 237 template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj,238 indirectly_unary_invocable<projected<_Iter, _Proj>> _Func>239 constexpr for_each_result<_Iter, _Func>240 operator()(_Iter __first, _Sent __last, _Func __func, _Proj __proj) const {241 242 for (; __first != __last; ++__first)243 invoke(__func, invoke(__proj, *__first));244 return {};245 }246 247};248inline namespace {249auto for_each = __for_each{};250}251} // namespace ranges252} // namespace __1253} // namespace std254 255 256 257struct T {};258struct Proj {259 constexpr void *operator()(T) { return nullptr; }260};261struct UnaryVoid {262 constexpr void operator()(void *) {}263};264 265constexpr bool all_the_algorithms() {266 T a[2];267 T *last = a + 2;268 std::ranges::for_each(a, last, UnaryVoid(), Proj());269 return true;270}271static_assert(all_the_algorithms());272