feat: recognize requires expressions

Author: JohelEGP

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<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,30 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-concept-definition-no-pitfall-1.cpp2"
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-concept-definition-no-pitfall-1.cpp2"
+// 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 1 "pure2-concept-definition-no-pitfall-1.cpp2"
+
+#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,31 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-concept-definition-no-pitfall-2.cpp2"
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-concept-definition-no-pitfall-2.cpp2"
+// 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 1 "pure2-concept-definition-no-pitfall-2.cpp2"
+
+#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,30 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-concept-definition-no-pitfall-3.cpp2"
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-concept-definition-no-pitfall-3.cpp2"
+// 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 1 "pure2-concept-definition-no-pitfall-3.cpp2"
+
+#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,60 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-concept-definition-pit-of-success-1.cpp2"
+
+#line 8 "pure2-concept-definition-pit-of-success-1.cpp2"
+class s1;
+class s2;
+
+class s3;
+
+class s4;
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-concept-definition-pit-of-success-1.cpp2"
+// 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> unnamed_param_1) -> void;
+class s3 {};
+auto b([[maybe_unused]] cpp2::in<s3> unnamed_param_1) -> void;
+class s4 {};
+auto a([[maybe_unused]] cpp2::in<s4> unnamed_param_1) -> void;
+auto b([[maybe_unused]] cpp2::in<s4> unnamed_param_1) -> void;
+
+auto main() -> int;
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-concept-definition-pit-of-success-1.cpp2"
+
+#line 10 "pure2-concept-definition-pit-of-success-1.cpp2"
+auto a([[maybe_unused]] cpp2::in<s2> unnamed_param_1) -> void{}
+
+auto b([[maybe_unused]] cpp2::in<s3> unnamed_param_1) -> void{}
+
+auto a([[maybe_unused]] cpp2::in<s4> unnamed_param_1) -> void{}
+auto b([[maybe_unused]] cpp2::in<s4> unnamed_param_1) -> 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

@@ -14,15 +14,36 @@
 #line 1 "pure2-concept-definition.cpp2"
 template<typename T> concept arithmetic = std::integral<T> || std::floating_point<T>; 
 #line 2 "pure2-concept-definition.cpp2"
+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 1 "pure2-concept-definition.cpp2"
 
-#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>));
 }
 

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

@@ -53,27 +53,27 @@ CPP2_REQUIRES_ ((std::is_convertible_v<CPP2_TYPEOF(x), int> && ...)) ;
 
     public: static auto test() -> void;
 
-#line 89 "pure2-print.cpp2"
+#line 102 "pure2-print.cpp2"
     public: template<typename ...Ts> class x {
         private: std::tuple<Ts...> tup {}; 
         public: x() = default;
         public: x(x const&) = delete; /* No 'that' constructor, suppress copy */
         public: auto operator=(x const&) -> void = delete;
 
-#line 91 "pure2-print.cpp2"
+#line 104 "pure2-print.cpp2"
     };
 
     public: template<typename ...Args> static auto print(std::ostream& out, Args const& ...args) -> void
 CPP2_REQUIRES_ (cpp2::cmp_greater_eq(sizeof(Args)...,0)) ;
 
-#line 97 "pure2-print.cpp2"
+#line 110 "pure2-print.cpp2"
     public: template<typename ...Args> [[nodiscard]] static auto all(Args const& ...args) -> bool;
     public: outer() = default;
     public: outer(outer const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(outer const&) -> void = delete;
 
 
-#line 100 "pure2-print.cpp2"
+#line 113 "pure2-print.cpp2"
 };
 
 auto main() -> int;
@@ -173,19 +173,32 @@ requires ((std::is_convertible_v<CPP2_TYPEOF(x), int> && ...)) {(std::cout << ..
             if (cpp2::is(_expr, 43)) { if constexpr( requires{"forty-and-three";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("forty-and-three")),namespace_alias::string> ) return "forty-and-three"; else return namespace_alias::string{}; else return namespace_alias::string{}; }
             else return "default case"; }
         () << "\n";
+
+        static_cast<void>(
+          requires {typename std::vector<int>; 
+} + requires {0; 
+} + requires {
+              requires true;
+              requires !requires { typename std::vector<int>;  };
+              requires !requires { 0;  };
+              { 0 };
+              { 0 } noexcept;
+              { 0 } -> std::regular;
+              { 0 } noexcept -> std::regular;
+});
     }
 
-#line 93 "pure2-print.cpp2"
+#line 106 "pure2-print.cpp2"
     template<typename ...Args> auto outer::print(std::ostream& out, Args const& ...args) -> void
 requires (cpp2::cmp_greater_eq(sizeof(Args)...,0)) {
-#line 94 "pure2-print.cpp2"
+#line 107 "pure2-print.cpp2"
         (out << ... << args);
     }
 
     template<typename ...Args> [[nodiscard]] auto outer::all(Args const& ...args) -> bool { 
         return (... && args);  }
 
-#line 102 "pure2-print.cpp2"
+#line 115 "pure2-print.cpp2"
 auto main() -> int{
     outer::test();
 }

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

@@ -130,6 +130,15 @@ outer: 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 = 
     {