feat: recognize requires expressions

Author: JohelEGP

include/cpp2util.h

@@ -191,7 +191,7 @@
         // in our -pure-cpp2 "import std;" simulation mode... if you need this,
         // use mixed mode (not -pure-cpp2) and #include all the headers you need
         // including this one
-        // 
+        //
         // #include <execution>
     #endif
 
@@ -483,7 +483,7 @@ template<typename T>
 auto Typeid() -> decltype(auto) {
 #ifdef CPP2_NO_RTTI
     Type.expects(
-        !"'any' dynamic casting is disabled with -fno-rtti", // more likely to appear on console 
+        !"'any' dynamic casting is disabled with -fno-rtti", // more likely to appear on console
          "'any' dynamic casting is disabled with -fno-rtti"  // make message available to hooked handlers
     );
 #else
@@ -829,7 +829,7 @@ inline auto to_string(std::string const& s) -> std::string const&
 
 template<typename T>
 inline auto to_string(T const& sv) -> std::string
-    requires (std::is_convertible_v<T, std::string_view> 
+    requires (std::is_convertible_v<T, std::string_view>
               && !std::is_convertible_v<T, const char*>)
 {
     return std::string{sv};
@@ -952,17 +952,17 @@ auto is( X const& ) -> bool {
 
 template< typename C, typename X >
     requires (
-        ( std::is_base_of_v<X, C> || 
-          ( std::is_polymorphic_v<C> && std::is_polymorphic_v<X>) 
+        ( std::is_base_of_v<X, C> ||
+          ( std::is_polymorphic_v<C> && std::is_polymorphic_v<X>)
         ) && !std::is_same_v<C,X>)
 auto is( X const& x ) -> bool {
     return Dynamic_cast<C const*>(&x) != nullptr;
 }
 
 template< typename C, typename X >
     requires (
-        ( std::is_base_of_v<X, C> || 
-          ( std::is_polymorphic_v<C> && std::is_polymorphic_v<X>) 
+        ( std::is_base_of_v<X, C> ||
+          ( std::is_polymorphic_v<C> && std::is_polymorphic_v<X>)
         ) && !std::is_same_v<C,X>)
 auto is( X const* x ) -> bool {
     return Dynamic_cast<C const*>(x) != nullptr;
@@ -1593,7 +1593,7 @@ constexpr auto unsafe_narrow( X&& x ) noexcept -> decltype(auto)
 //  Returns a function object that takes a 'value' of the same type as
 //  'flags', and evaluates to true if and only if 'value' has set all of
 //  the bits set in 'flags'
-// 
+//
 //-----------------------------------------------------------------------
 //
 template <typename T>

regression-tests/pure2-concept-definition-no-pitfall-1.cpp2

@@ -0,0 +1,7 @@
+// https://youtu.be/CXn02MPkn8Y?t=2337
+negatable: <T> concept = requires(t: T)
+{
+  _ = -t is T; // Hopefully obviously wrong. Should be `{ -t } is T;`.
+};
+
+main: () = static_assert(negatable<char>);

regression-tests/pure2-concept-definition-no-pitfall-2.cpp2

@@ -0,0 +1,8 @@
+// https://youtu.be/CXn02MPkn8Y?t=2418
+int_sized: <T> concept = requires(t: T)
+{
+  _ = sizeof(T) == 4; // Hopefully obviously wrong. Should be `requires (sizeof(T) == 4);`.
+};
+// Could also be `int_sized: <T> concept = sizeof(T) == 4;`.
+
+main: () = static_assert(int_sized<char>);

regression-tests/pure2-concept-definition-no-pitfall-3.cpp2

@@ -0,0 +1,7 @@
+// https://youtu.be/CXn02MPkn8Y?t=2455
+nothrow_incrementable: <T> concept = requires(inout t: T)
+{
+  _ = noexcept(t++); // Hopefully obviously wrong. Should be `requires noexcept(t++);` or `{ t++ } !throws;`.
+};
+
+main: () = { static_assert(nothrow_incrementable<char>); }

regression-tests/pure2-concept-definition-pit-of-success-1.cpp2

@@ -0,0 +1,22 @@
+// https://quuxplusone.github.io/blog/2021/06/09/another-concepts-chest-mimic/
+has_a_but_not_b: <T> concept = requires(t: T)
+{
+  _           = a(t);
+  !requires _ = b(t); // In Cpp2, this works and does the correct thing.
+};
+
+s1: @struct type = { }
+s2: @struct type = { }
+a: (_: s2)       = { }
+s3: @struct type = { }
+b: (_: s3)       = { }
+s4: @struct type = { }
+a: (_: s4)       = { }
+b: (_: s4)       = { }
+
+main: () = {
+  static_assert(!has_a_but_not_b<s1>); // as expected
+  static_assert(has_a_but_not_b<s2>);  // as expected
+  static_assert(!has_a_but_not_b<s3>); // as expected
+  static_assert(!has_a_but_not_b<s4>); // pit of success!
+}

regression-tests/pure2-concept-definition.cpp2

@@ -1,5 +1,26 @@
 arithmetic: <T> concept = std::integral<T> || std::floating_point<T>;
-main: ()                = {
-  [[assert Testing: arithmetic<i32>]]
-  [[assert Testing: arithmetic<float>]]
+number_difference_t: <T> type == std::type_identity_t<decltype(T() - T())>;
+number: <T> concept = std::regular<T> && requires(c: T)
+{
+  !requires std::iter_reference_t<T>;                   // Negative requirement.
+  {c + c} is std::common_with<T>;                       // Compound requirement.
+  number_difference_t<T>;                               // Type requirement.
+  _ = c - c;                                            // Expression requirement.
+  requires std::common_with<number_difference_t<T>, T>; // Nested requirement.
+};
+test_nonthrowing_requirements: <T> concept = requires
+{ // clang-format off
+  { T() } !throws;
+  { -T() } !throws, is std::same_as<T>;
+}; // clang-format on
+main: () = {
+  static_assert(arithmetic<i32>);
+  static_assert(arithmetic<float>);
+  static_assert(number<i32>);
+  static_assert(number<float>);
+  static_assert(number<std::chrono::seconds>);
+  static_assert(!number<* i32>);
+  static_assert(!number<std::reverse_iterator<* i32>>);
+  static_assert(test_nonthrowing_requirements<i32>);
+  static_assert(!test_nonthrowing_requirements<std::chrono::seconds>);
 }

regression-tests/test-results/clang-18/clang-version.output

@@ -0,0 +1,4 @@
+clang version 18.0.0 (https://github.com/llvm/llvm-project.git 3723ede3cf5324827f8fbbe7f484c2ee4d7a7204)
+Target: x86_64-pc-linux-gnu
+Thread model: posix
+InstalledDir: /home/johel/root/clang-main/bin