feat: recognize requires expressions

Author: JohelEGP

include/cpp2util.h

@@ -116,7 +116,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>
         #ifdef __cpp_lib_expected
             #include <expected>
@@ -525,7 +525,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
@@ -901,7 +901,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};
@@ -1041,17 +1041,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;
@@ -1682,7 +1682,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/pure2-print.cpp2

@@ -84,6 +84,19 @@ outer: @print type = {
             is 43 = "forty-and-three";
             is _  = "default case";
         } << "\n";
+
+        _ =
+          requires { std::vector<int>; }
+          + requires { _ = 0; }
+          + requires {
+              requires true;
+              !requires std::vector<int>;
+              !requires _ = 0;
+              { 0 };
+              { 0 } !throws;
+              { 0 } is std::regular;
+              { 0 } !throws, is std::regular;
+            };
     }
 
     x: <Ts...: type> type = {

regression-tests/pure2-requires-clauses.cpp2

@@ -17,6 +17,9 @@ f:  <T: type, U: type>
 
 v: <T> const T requires std::same_as<T, i32> = 0;
 
+g: <T> () requires true = { }
+g: () (requires { _ = 0; });
+
 main: () = {
     x: X<int,int> = ();
     std::cout << f<int,int>(2,5);

regression-tests/test-results/gcc-13/pure2-concept-definition-no-pitfall-1.cpp.execution

@@ -0,0 +1,28 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+// https://youtu.be/CXn02MPkn8Y?t=2337
+#line 2 "pure2-concept-definition-no-pitfall-1.cpp2"
+template<typename T> concept negatable = requires(T const& t) {
+
+  cpp2::is<T>(-t);
+};             // Hopefully obviously wrong. Should be `{ -t } is T;`.
+
+auto main() -> int;
+
+
+//=== Cpp2 function definitions =================================================
+
+
+#line 7 "pure2-concept-definition-no-pitfall-1.cpp2"
+auto main() -> int { static_assert(negatable<char>);  }
+

regression-tests/test-results/gcc-13/pure2-concept-definition-no-pitfall-1.cpp.output

@@ -0,0 +1,2 @@
+pure2-concept-definition-no-pitfall-1.cpp2... ok (all Cpp2, passes safety checks)
+

regression-tests/test-results/gcc-13/pure2-concept-definition-no-pitfall-2.cpp.execution

@@ -0,0 +1,29 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+// https://youtu.be/CXn02MPkn8Y?t=2418
+#line 2 "pure2-concept-definition-no-pitfall-2.cpp2"
+template<typename T> concept int_sized = requires(T const& t) {
+
+  sizeof(T) == 4;
+};                    // Hopefully obviously wrong. Should be `requires (sizeof(T) == 4);`.
+// Could also be `int_sized: <T> concept = sizeof(T) == 4;`.
+
+auto main() -> int;
+
+
+//=== Cpp2 function definitions =================================================
+
+
+#line 8 "pure2-concept-definition-no-pitfall-2.cpp2"
+auto main() -> int { static_assert(int_sized<char>);  }
+

regression-tests/test-results/gcc-13/pure2-concept-definition-no-pitfall-2.cpp.output

@@ -0,0 +1,2 @@
+pure2-concept-definition-no-pitfall-2.cpp2... ok (all Cpp2, passes safety checks)
+

regression-tests/test-results/gcc-13/pure2-concept-definition-no-pitfall-3.cpp.execution

@@ -0,0 +1,28 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+// https://youtu.be/CXn02MPkn8Y?t=2455
+#line 2 "pure2-concept-definition-no-pitfall-3.cpp2"
+template<typename T> concept nothrow_incrementable = requires(T& t) {
+
+  noexcept(++t);
+};                   // Hopefully obviously wrong. Should be `requires noexcept(t++);` or `{ t++ } !throws;`.
+
+auto main() -> int;
+
+
+//=== Cpp2 function definitions =================================================
+
+
+#line 7 "pure2-concept-definition-no-pitfall-3.cpp2"
+auto main() -> int{static_assert(nothrow_incrementable<char>); }
+

regression-tests/test-results/gcc-13/pure2-concept-definition-no-pitfall-3.cpp.output

@@ -0,0 +1,2 @@
+pure2-concept-definition-no-pitfall-3.cpp2... ok (all Cpp2, passes safety checks)
+

regression-tests/test-results/gcc-13/pure2-concept-definition-pit-of-success-1.cpp.execution

@@ -0,0 +1,58 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+
+#line 8 "pure2-concept-definition-pit-of-success-1.cpp2"
+class s1;
+class s2;
+
+class s3;
+
+class s4;
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+// https://quuxplusone.github.io/blog/2021/06/09/another-concepts-chest-mimic/
+#line 2 "pure2-concept-definition-pit-of-success-1.cpp2"
+template<typename T> concept has_a_but_not_b = requires(T const& t) {
+
+                a(t);
+  requires !requires { b(t);  };
+};                    // In Cpp2, this works and does the correct thing.
+
+class s1 {};
+class s2 {};
+auto a([[maybe_unused]] cpp2::in<s2> param1) -> void;
+class s3 {};
+auto b([[maybe_unused]] cpp2::in<s3> param1) -> void;
+class s4 {};
+auto a([[maybe_unused]] cpp2::in<s4> param1) -> void;
+auto b([[maybe_unused]] cpp2::in<s4> param1) -> void;
+
+auto main() -> int;
+  
+
+//=== Cpp2 function definitions =================================================
+
+
+#line 10 "pure2-concept-definition-pit-of-success-1.cpp2"
+auto a([[maybe_unused]] cpp2::in<s2> param1) -> void{}
+
+auto b([[maybe_unused]] cpp2::in<s3> param1) -> void{}
+
+auto a([[maybe_unused]] cpp2::in<s4> param1) -> void{}
+auto b([[maybe_unused]] cpp2::in<s4> param1) -> void{}
+
+auto main() -> int{
+  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/test-results/gcc-13/pure2-concept-definition-pit-of-success-1.cpp.output

@@ -0,0 +1,2 @@
+pure2-concept-definition-pit-of-success-1.cpp2... ok (all Cpp2, passes safety checks)
+

regression-tests/test-results/pure2-concept-definition-no-pitfall-1.cpp

@@ -11,15 +11,36 @@
 //=== Cpp2 type definitions and function declarations ===========================
 
 template<typename T> concept arithmetic = std::integral<T> || std::floating_point<T>; 
+template<typename T> using number_difference_t = std::type_identity_t<decltype(T() - T())>;
+template<typename T> concept number = std::regular<T> && requires(T const& c) {
+
+  requires !requires { typename std::iter_reference_t<T>;  };// Negative requirement.
+  { c + c } -> std::common_with<T>;                     // Compound requirement.
+  typename number_difference_t<T>;                      // Type requirement.
+  c - c;                                                // Expression requirement.
+  requires std::common_with<number_difference_t<T>,T>;
+};                                                      // Nested requirement.
+template<typename T> concept test_nonthrowing_requirements = requires {
+  // clang-format off
+  { T() } noexcept;
+  { -T() } noexcept -> std::same_as<T>;
+}; // clang-format on
 auto main() -> int;
 
 
 //=== Cpp2 function definitions =================================================
 
 
-#line 2 "pure2-concept-definition.cpp2"
-  auto main() -> int    {
-  cpp2::Testing.expects(arithmetic<cpp2::i32>, "");
-  cpp2::Testing.expects(arithmetic<float>, "");
+#line 16 "pure2-concept-definition.cpp2"
+auto main() -> int{
+  static_assert(arithmetic<cpp2::i32>);
+  static_assert(arithmetic<float>);
+  static_assert(number<cpp2::i32>);
+  static_assert(number<float>);
+  static_assert(number<std::chrono::seconds>);
+  static_assert(!(number<cpp2::i32*>));
+  static_assert(!(number<std::reverse_iterator<cpp2::i32*>>));
+  static_assert(test_nonthrowing_requirements<cpp2::i32>);
+  static_assert(!(test_nonthrowing_requirements<std::chrono::seconds>));
 }