feat: recognize requires expressions

Author: JohelEGP

regression-tests/pure2-concept-definition.cpp2

@@ -1,24 +1,26 @@
 arithmetic: <T> concept = std::integral<T> || std::floating_point<T>;
-number: <T> concept     = std::regular<T> && requires(c: T)
+number_difference_t: <T> type == std::type_identity_t<decltype(T() - T())>;
+number: <T> concept = std::regular<T> && requires(c: T)
 {
-  !requires std::input_or_output_iterator<T>;
+  !requires(c*);
   {c + c} throws is std::common_with<T>;
   number_difference_t<T>;
   (c - c);
   {c - c} throws;
   requires std::common_with<number_difference_t<T>, T>;
 };
-number_difference_t: <T> type == std::type_identity_t<T() - T()>;
 test_nonthrowing_requirements: <T> concept = requires(c: T)
 {
   {T()};
   {-T()} is std::same_as<T>;
 };
 main: () = {
-  [[assert Testing: arithmetic<i32>]]
-  [[assert Testing: arithmetic<float>]]
-  [[assert Testing: number<i32>]]
-  [[assert Testing: number<float>]]
-  [[assert Testing: number<std::chrono::seconds>]]
-  [[assert Testing: test_nonthrowing_requirements<i32>]]
+  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(test_nonthrowing_requirements<i32>);
+  static_assert(!test_nonthrowing_requirements<std::chrono::seconds>);
 }

regression-tests/test-results/clang-18/pure2-concept-definition.cpp.execution

@@ -12,13 +12,21 @@
 
 #line 1 "pure2-concept-definition.cpp2"
 template<typename T> concept arithmetic = std::integral<T> || std::floating_point<T>; 
-template<typename T> concept number = std::regular<T> && ; 
-
-#line 11 "pure2-concept-definition.cpp2"
-template<typename T> using number_difference_t = std::type_identity_t<T() - T()>;
-template<typename T> concept test_nonthrowing_requirements = ; 
-
-#line 17 "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 { (*cpp2::assert_not_null(c));  };
+  { c + c } -> std::common_with<T>;
+  typename number_difference_t<T>;
+  (c - c);
+  { c - c };
+  requires std::common_with<number_difference_t<T>,T>;
+}; 
+template<typename T> concept test_nonthrowing_requirements = requires(T const& c) {
+
+  { T() } noexcept;
+  { -T() } noexcept -> std::same_as<T>;
+}; 
 auto main() -> int;
 
 
@@ -27,11 +35,13 @@ auto main() -> int;
 
 #line 17 "pure2-concept-definition.cpp2"
 auto main() -> int{
-  cpp2::Testing.expects(arithmetic<cpp2::i32>, "");
-  cpp2::Testing.expects(arithmetic<float>, "");
-  cpp2::Testing.expects(number<cpp2::i32>, "");
-  cpp2::Testing.expects(number<float>, "");
-  cpp2::Testing.expects(number<std::chrono::seconds>, "");
-  cpp2::Testing.expects(test_nonthrowing_requirements<cpp2::i32>, "");
+  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(test_nonthrowing_requirements<cpp2::i32>);
+  static_assert(!(test_nonthrowing_requirements<std::chrono::seconds>));
 }
 

regression-tests/test-results/clang-18/pure2-concept-definition.cpp.output

@@ -2029,6 +2029,101 @@ class cppfront
     }
 
 
+    //-----------------------------------------------------------------------
+    //
+    struct type_requirement_tag {};
+    struct simple_requirement_tag {};
+    struct nested_requirement_tag {};
+    struct negative_requirement_tag {};
+
+    auto emit(
+        type_id_node const& n,
+        type_requirement_tag
+    )
+        -> void
+    {
+        printer.print_cpp2("typename ", n.position());
+        emit(n);
+        printer.print_cpp2(";", n.position());
+    }
+
+    auto emit(
+        expression_node const& n,
+        simple_requirement_tag
+    )
+        -> void
+    {
+        emit(n);
+        printer.print_cpp2(";", n.position());
+    }
+
+    auto emit(requires_expression_node::compound_requirement_node const& n)
+        -> void
+    {
+        assert(n.expression);
+        printer.print_cpp2("{ ", n.expression->position());
+        emit(*n.expression);
+        printer.print_cpp2(" }", n.expression->position());
+        if (!n.throws) {
+            printer.print_cpp2(" noexcept", n.expression->position());
+        }
+        if (n.type_constraint) {
+          printer.print_cpp2(" -> ", n.expression->position());
+          emit(*n.type_constraint);
+        }
+        printer.print_cpp2(";", n.expression->position());
+    }
+
+    auto emit(
+        logical_or_expression_node const& n,
+        nested_requirement_tag
+    )
+        -> void
+    {
+        printer.print_cpp2("requires ", n.position());
+        emit(n);
+        printer.print_cpp2(";", n.position());
+    }
+
+    auto emit(
+        requires_expression_node::requirement_node const& n,
+        negative_requirement_tag
+        )
+        -> void
+    {
+        printer.print_cpp2("requires ", n.position());
+        printer.print_cpp2("!requires { ", n.position());
+        emit(n);
+        printer.print_cpp2(" };", n.position());
+    }
+
+    auto emit(requires_expression_node::requirement_node const& n)
+        -> void
+    {
+        try_emit<requires_expression_node::requirement_node::type      >(n.requirement, type_requirement_tag{});
+        try_emit<requires_expression_node::requirement_node::expression>(n.requirement, simple_requirement_tag{});
+        try_emit<requires_expression_node::requirement_node::compound  >(n.requirement);
+        try_emit<requires_expression_node::requirement_node::nested    >(n.requirement, nested_requirement_tag{});
+        try_emit<requires_expression_node::requirement_node::negative  >(n.requirement, negative_requirement_tag{});
+    }
+
+    auto emit(requires_expression_node const& n)
+        -> void
+    {
+        assert(n.identifier);
+        emit(*n.identifier);
+        if (n.parameters) {
+            emit(*n.parameters);
+        }
+        printer.print_cpp2(" {", n.position());
+        for (auto const& x : n.requirements) {
+            assert(x);
+            emit(*x);
+        }
+        printer.print_cpp2("\n}", n.position(), true);
+    }
+
+
     //-----------------------------------------------------------------------
     //
     auto emit(selection_statement_node const& n)
@@ -2480,6 +2575,7 @@ class cppfront
         try_emit<primary_expression_node::expression_list>(n.expr);
         try_emit<primary_expression_node::id_expression  >(n.expr);
         try_emit<primary_expression_node::inspect        >(n.expr, true);
+        try_emit<primary_expression_node::requires_      >(n.expr);
         try_emit<primary_expression_node::literal        >(n.expr);
 
         if (n.expr.index() == primary_expression_node::declaration)