Fix requires expression evaluating implicit expression check (#14)

lackhole · Jun 21, 2024 · 3c1b955 · 3c1b955
1 parent db1a0c9
commit 3c1b955
Show file tree

Hide file tree

Showing 11 changed files with 99 additions and 87 deletions.
diff --git a/include/preview/__concepts/implicit_expression_check.h b/include/preview/__concepts/implicit_expression_check.h
diff --git a/include/preview/__concepts/partially_ordered_with.h b/include/preview/__concepts/partially_ordered_with.h
@@ -7,7 +7,7 @@
 
 #include <type_traits>
 
-#include "preview/__concepts/implicit_expression_check.h"
+#include "preview/__concepts/requires_expression.h"
 #include "preview/__type_traits/bool_constant.h"
 #include "preview/__type_traits/conjunction.h"
 #include "preview/__type_traits/is_referenceable.h"
@@ -18,23 +18,25 @@ namespace detail {
 
 template<typename T, typename U, bool = conjunction<is_referencable<T>, is_referencable<U>>::value>
 struct partially_ordered_with_impl : std::false_type {};
+
+// TODO: Use boolean_testable
 template<typename T, typename U>
 struct partially_ordered_with_impl<T, U, true>
     : conjunction<
-        implicit_expression_check<rel_ops::is_less_than_comparable,          const std::remove_reference_t<T>&, const std::remove_reference_t<U>& >,
-        implicit_expression_check<rel_ops::is_less_equal_than_comparable,    const std::remove_reference_t<T>&, const std::remove_reference_t<U>& >,
-        implicit_expression_check<rel_ops::is_greater_than_comparable,       const std::remove_reference_t<T>&, const std::remove_reference_t<U>& >,
-        implicit_expression_check<rel_ops::is_greater_equal_than_comparable, const std::remove_reference_t<T>&, const std::remove_reference_t<U>& >,
-        implicit_expression_check<rel_ops::is_less_than_comparable,          const std::remove_reference_t<U>&, const std::remove_reference_t<T>& >,
-        implicit_expression_check<rel_ops::is_less_equal_than_comparable,    const std::remove_reference_t<U>&, const std::remove_reference_t<T>& >,
-        implicit_expression_check<rel_ops::is_greater_than_comparable,       const std::remove_reference_t<U>&, const std::remove_reference_t<T>& >,
-        implicit_expression_check<rel_ops::is_greater_equal_than_comparable, const std::remove_reference_t<U>&, const std::remove_reference_t<T>& >
-      > {};
+        requires_expression<rel_ops::is_less_than_comparable,          const T&, const U& >,
+        requires_expression<rel_ops::is_less_equal_than_comparable,    const T&, const U& >,
+        requires_expression<rel_ops::is_greater_than_comparable,       const T&, const U& >,
+        requires_expression<rel_ops::is_greater_equal_than_comparable, const T&, const U& >,
+        requires_expression<rel_ops::is_less_than_comparable,          const U&, const T& >,
+        requires_expression<rel_ops::is_less_equal_than_comparable,    const U&, const T& >,
+        requires_expression<rel_ops::is_greater_than_comparable,       const U&, const T& >,
+        requires_expression<rel_ops::is_greater_equal_than_comparable, const U&, const T& >
+    > {};
 
 } // namespace detail
 
 template<typename T, typename U>
-struct partially_ordered_with : detail::partially_ordered_with_impl<T, U> {};
+struct partially_ordered_with : detail::partially_ordered_with_impl<std::remove_reference_t<T>, std::remove_reference_t<U>> {};
 
 } // namespace preview
 

diff --git a/include/preview/__concepts/requires_expression.h b/include/preview/__concepts/requires_expression.h
@@ -0,0 +1,58 @@
+//
+// Created by yonggyulee on 2023/12/21.
+//
+
+#ifndef PREVIEW_CONCEPTS_REQUIRES_EXPRESSION_H_
+#define PREVIEW_CONCEPTS_REQUIRES_EXPRESSION_H_
+
+#include "preview/__type_traits/conjunction.h"
+
+namespace preview {
+namespace detail {
+
+template<template<typename, typename, typename...> class Check, typename Left, typename Right>
+struct implicit_expression_check
+    : conjunction<
+        Check<Left, Right&>,
+        Check<Left, Right&&>,
+        Check<Left, const Right&>,
+        Check<Left, const Right&&>
+      > {};
+
+} // namespace detail
+
+template<template<typename, typename...> class Check, typename Operand, typename...>
+struct requires_expression;
+
+template<template<typename, typename...> class Check, typename Operand>
+struct requires_expression<Check, Operand> : Check<Operand> {};
+
+template<template<typename, typename, typename...> class Check, typename Left, typename Right>
+struct requires_expression<Check, Left, Right> : Check<Left, Right> {};
+
+// TODO: Add diagnostics for implicit requires expansion
+//
+//template<template<typename, typename, typename...> class Check, typename Left, typename Right>
+//struct requires_expression<Check, Left, const Right&>
+//    : detail::implicit_expression_check<Check, Left, Right> {};
+//s
+//template<template<typename, typename, typename...> class Check, typename Left, typename Right>
+//struct requires_expression<Check, const Left&, const Right&>
+//    : conjunction<
+//        detail::implicit_expression_check<Check, Left&, Right>,
+//        detail::implicit_expression_check<Check, Left&&, Right>,
+//        detail::implicit_expression_check<Check, const Left&, Right>,
+//        detail::implicit_expression_check<Check, const Left&&, Right>
+//      > {};
+
+//template<template<typename, typename...> class Check, typename Operand>
+//struct requires_expression<Check, const Operand&> : conjunction<
+//        Check<Operand&>,
+//        Check<Operand&&>,
+//        Check<const Operand&>,
+//        Check<const Operand&&>
+//      > {};
+
+} // namespace preview
+
+#endif // PREVIEW_CONCEPTS_REQUIRES_EXPRESSION_H_
diff --git a/include/preview/__concepts/subtractable.h b/include/preview/__concepts/subtractable.h
@@ -7,12 +7,13 @@
 
 #include <type_traits>
 
-#include "preview/__concepts/implicit_expression_check.h"
+#include "preview/__concepts/requires_expression.h"
 #include "preview/__type_traits/conjunction.h"
 #include "preview/__type_traits/is_referenceable.h"
 #include "preview/__type_traits/void_t.h"
 
 namespace preview {
+namespace detail {
 
 template<typename T, typename U, typename = void>
 struct is_explicitly_subtractable : std::false_type {};
@@ -24,10 +25,12 @@ template<typename T, bool = is_referencable<T>::value>
 struct is_subtractable_impl : std::false_type {};
 
 template<typename T>
-struct is_subtractable_impl<T, true> : implicit_expression_check<is_explicitly_subtractable, const T&, const T&> {};
+struct is_subtractable_impl<T, true> : requires_expression<is_explicitly_subtractable, const T&, const T&> {};
+
+} // namespace detail
 
 template<typename T>
-struct subtractable : is_subtractable_impl<T> {};
+struct subtractable : detail::is_subtractable_impl<T> {};
 
 } // namespace preview
 

diff --git a/include/preview/__iterator/contiguous_iterator.h b/include/preview/__iterator/contiguous_iterator.h
@@ -9,6 +9,7 @@
 
 #include "preview/__concepts/derived_from.h"
 #include "preview/__concepts/same_as.h"
+#include "preview/__concepts/requires_expression.h"
 #include "preview/__iterator/detail/iter_concept.h"
 #include "preview/__iterator/iterator_traits/legacy_random_access_iterator.h"
 #include "preview/__iterator/iter_reference_t.h"
@@ -30,10 +31,13 @@ template<typename I>
 struct explicit_contiguous_requires<
         I,
         void_t<decltype( preview::to_address( std::declval<I>() ) )>
-    > : same_as<decltype( preview::to_address( std::declval<I>() ) ), std::add_pointer_t<iter_reference_t<remove_cvref_t<I>>>> {};
+    > : same_as<
+        decltype( preview::to_address( std::declval<I>() ) ),
+        std::add_pointer_t<iter_reference_t<remove_cvref_t<I>>>
+    > {};
 
 template<typename I>
-struct contiguous_requires : implicit_expression_check<explicit_contiguous_requires, const I&> {};
+struct contiguous_requires : requires_expression<explicit_contiguous_requires, const I&> {};
 
 template<
     typename I,

diff --git a/include/preview/__iterator/incrementable_traits.h b/include/preview/__iterator/incrementable_traits.h
@@ -17,10 +17,10 @@ namespace preview {
 namespace detail {
 
 template<typename T, bool = subtractable<T>::value>
-struct substract_check : std::false_type {};
+struct subtract_check : std::false_type {};
 
 template<typename T>
-struct substract_check<T, true> : std::is_integral<decltype(std::declval<const T&>() - std::declval<const T&>())> {};
+struct subtract_check<T, true> : std::is_integral<decltype(std::declval<const T&>() - std::declval<const T&>())> {};
 
 
 template<typename T>
@@ -31,7 +31,7 @@ struct incrementable_traits_subtractable {
 template<typename T>
 struct incrementable_traits_no_difference_type
     : std::conditional_t<
-        substract_check<T>::value,
+        subtract_check<T>::value,
         incrementable_traits_subtractable<T>,
         no_traits
       > {};

diff --git a/include/preview/__iterator/random_access_iterator.h b/include/preview/__iterator/random_access_iterator.h
@@ -8,7 +8,7 @@
 #include <type_traits>
 
 #include "preview/__concepts/derived_from.h"
-#include "preview/__concepts/implicit_expression_check.h"
+#include "preview/__concepts/requires_expression.h"
 #include "preview/__concepts/totally_ordered.h"
 #include "preview/__iterator/detail/iter_concept.h"
 #include "preview/__iterator/bidirectional_iterator.h"
@@ -65,9 +65,9 @@ struct op_check : std::false_type {};
 template<typename I>
 struct op_check<I, true>
     : conjunction<
-        implicit_expression_check<explicit_op_assign_check, I&, const iter_difference_t<I>&>,
-        implicit_expression_check<explicit_op_const_check, const I&, const iter_difference_t<I>&>
-      > {};
+        requires_expression<explicit_op_assign_check, I&, const iter_difference_t<I>&>,
+        requires_expression<explicit_op_const_check, const I&, const iter_difference_t<I>&>
+    > {};
 
 } // detail_random_access_iterator
 

diff --git a/include/preview/__iterator/sized_sentinel_for.h b/include/preview/__iterator/sized_sentinel_for.h
@@ -7,7 +7,7 @@
 
 #include <type_traits>
 
-#include "preview/__concepts/implicit_expression_check.h"
+#include "preview/__concepts/requires_expression.h"
 #include "preview/__concepts/same_as.h"
 #include "preview/__iterator/iter_difference_t.h"
 #include "preview/__iterator/sentinel_for.h"
@@ -37,7 +37,7 @@ struct explicit_sized_sentinel_subtract_check<
       > {};
 
 template<typename S, typename I>
-struct sized_sentinel_requires : implicit_expression_check<explicit_sized_sentinel_subtract_check, const S&, const I&> {};
+struct sized_sentinel_requires : requires_expression<explicit_sized_sentinel_subtract_check, const S&, const I&> {};
 
 template<
     typename S,

diff --git a/include/preview/__ranges/size.h b/include/preview/__ranges/size.h
@@ -63,7 +63,7 @@ template<
            >::value /* true */
 >
 struct size_range_check_2
-    : is_explicitly_subtractable<
+    : preview::detail::is_explicitly_subtractable<
           decltype(ranges::end(std::declval<T>())),
           decltype(ranges::begin(std::declval<T>()))> {
   using category = return_category<4, std::make_unsigned_t<decltype(ranges::end(std::declval<T>()) - ranges::begin(std::declval<T>()))>>;

diff --git a/include/preview/__ranges/views/iota_view.h b/include/preview/__ranges/views/iota_view.h
@@ -12,6 +12,7 @@
 #include "preview/__concepts/copyable.h"
 #include "preview/__concepts/convertible_to.h"
 #include "preview/__concepts/default_initializable.h"
+#include "preview/__concepts/requires_expression.h"
 #include "preview/__concepts/same_as.h"
 #include "preview/__concepts/semiregular.h"
 #include "preview/__concepts/totally_ordered.h"
@@ -94,9 +95,9 @@ struct iv_advanceable : std::false_type {};
 template<typename I>
 struct iv_advanceable<I, true>
     : conjunction<
-        implicit_expression_check<preview::detail::detail_random_access_iterator::explicit_op_assign_check, I&, const iota_diff_t<I>&>,
-        implicit_expression_check<iv_advanceable_explicit, const I&, const iota_diff_t<I>&>
-      > {};
+        requires_expression<preview::detail::detail_random_access_iterator::explicit_op_assign_check, I&, const iota_diff_t<I>&>,
+        requires_expression<iv_advanceable_explicit, const I&, const iota_diff_t<I>&>
+    > {};
 
 template<typename I, bool = incrementable<I>::value /* true */>
 struct iota_view_iterator_category {

diff --git a/include/preview/concepts.h b/include/preview/concepts.h
@@ -18,19 +18,19 @@
 #include "preview/__concepts/dereferenceable.h"
 #include "preview/__concepts/derived_from.h"
 #include "preview/__concepts/derived_from_single_crtp.h"
+#include "preview/__concepts/destructible.h"
 #include "preview/__concepts/different_from.h"
 #include "preview/__concepts/equality_comparable.h"
 #include "preview/__concepts/equivalence_relation.h"
 #include "preview/__concepts/floating_point.h"
-#include "preview/__concepts/implicit_expression_check.h"
 #include "preview/__concepts/invocable.h"
-#include "preview/__concepts/destructible.h"
 #include "preview/__concepts/movable.h"
 #include "preview/__concepts/move_constructible.h"
 #include "preview/__concepts/partially_ordered_with.h"
 #include "preview/__concepts/predicate.h"
 #include "preview/__concepts/regular.h"
 #include "preview/__concepts/relation.h"
+#include "preview/__concepts/requires_expression.h"
 #include "preview/__concepts/same_as.h"
 #include "preview/__concepts/semiregular.h"
 #include "preview/__concepts/signed_integral.h"