fix(parse): add pretty_print_visualize for _requires-expression_

Author: JohelEGP

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/test-results/pure2-print.cpp

@@ -57,31 +57,31 @@ 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 93 "pure2-print.cpp2"
+#line 106 "pure2-print.cpp2"
     ;
 
 
-#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;
@@ -186,20 +186,33 @@ requires ((std::is_convertible_v<CPP2_TYPEOF(x), int> && ...))
             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 93 "pure2-print.cpp2"
+#line 106 "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-print.cpp2.output

@@ -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 = 
     {

source/cppfront.cpp

@@ -2061,11 +2061,6 @@ 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

source/parse.h

@@ -4112,6 +4112,11 @@ struct translation_unit_node
 };
 
 
+struct type_requirement_tag {};
+struct simple_requirement_tag {};
+struct nested_requirement_tag {};
+struct negative_requirement_tag {};
+
 //-----------------------------------------------------------------------
 //
 //  pretty_print_visualize: pretty-prints Cpp2 ASTs
@@ -4162,6 +4167,20 @@ auto pretty_print_visualize(alternative_node const& n, int indent)
     -> std::string;
 auto pretty_print_visualize(inspect_expression_node const& n, int indent)
     -> std::string;
+auto pretty_print_visualize(type_id_node const& n, type_requirement_tag, int indent)
+    -> std::string;
+auto pretty_print_visualize(expression_node const& n, simple_requirement_tag, int indent)
+    -> std::string;
+auto pretty_print_visualize(requires_expression_node::compound_requirement_node const& n, int indent)
+    -> std::string;
+auto pretty_print_visualize(logical_or_expression_node const& n, nested_requirement_tag, int indent)
+    -> std::string;
+auto pretty_print_visualize(requires_expression_node::requirement_node const& n, negative_requirement_tag, int indent)
+    -> std::string;
+auto pretty_print_visualize(requires_expression_node::requirement_node const& n, int indent)
+    -> std::string;
+auto pretty_print_visualize(requires_expression_node const& n, int indent)
+    -> std::string;
 auto pretty_print_visualize(contract_node const& n, int indent)
     -> std::string;
 auto pretty_print_visualize(jump_statement_node const& n, int indent)
@@ -4241,6 +4260,7 @@ auto pretty_print_visualize(primary_expression_node const& n, int indent)
     ret += try_pretty_print_visualize<primary_expression_node::id_expression  >(n.expr, indent);
     ret += try_pretty_print_visualize<primary_expression_node::declaration    >(n.expr, indent);
     ret += try_pretty_print_visualize<primary_expression_node::inspect        >(n.expr, indent);
+    ret += try_pretty_print_visualize<primary_expression_node::requires_      >(n.expr, indent);
     ret += try_pretty_print_visualize<primary_expression_node::literal        >(n.expr, indent);
 
     return ret;
@@ -4629,6 +4649,100 @@ auto pretty_print_visualize(inspect_expression_node const& n, int indent)
 }
 
 
+auto pretty_print_visualize(type_id_node const& n, type_requirement_tag, int indent)
+    -> std::string
+{
+    return pretty_print_visualize(n, indent) + ";";
+}
+
+auto pretty_print_visualize(expression_node const& n, simple_requirement_tag, int indent)
+    -> std::string
+{
+    return "_ = " + pretty_print_visualize(n, indent) + ';';
+}
+
+auto pretty_print_visualize(requires_expression_node::compound_requirement_node const& n, int indent)
+    -> std::string
+{
+    auto ret = "{ " + pretty_print_visualize(*n.expression, indent) + " }";
+
+    if (!n.throws) {
+        ret += " !throws";
+        if (n.type_constraint) {
+            ret += ",";
+        }
+    }
+
+    if (n.type_constraint) {
+        ret += " is " + pretty_print_visualize(*n.type_constraint, indent);
+    }
+
+    ret += ';';
+
+    return ret;
+}
+
+
+auto pretty_print_visualize(logical_or_expression_node const& n, nested_requirement_tag, int indent)
+    -> std::string
+{
+    return "requires " + pretty_print_visualize(n, indent) + ';';
+}
+
+auto pretty_print_visualize(requires_expression_node::requirement_node const& n, negative_requirement_tag, int indent)
+    -> std::string
+{
+    return "!requires " + pretty_print_visualize(n, indent);
+}
+
+auto pretty_print_visualize(requires_expression_node::requirement_node const& n, int indent)
+    -> std::string
+{
+    auto ret = std::string{};
+
+    ret += try_pretty_print_visualize<requires_expression_node::requirement_node::type      >(n.requirement, type_requirement_tag{}, indent);
+    ret += try_pretty_print_visualize<requires_expression_node::requirement_node::expression>(n.requirement, simple_requirement_tag{}, indent);
+    ret += try_pretty_print_visualize<requires_expression_node::requirement_node::compound  >(n.requirement, indent);
+    ret += try_pretty_print_visualize<requires_expression_node::requirement_node::nested    >(n.requirement, nested_requirement_tag{}, indent);
+    ret += try_pretty_print_visualize<requires_expression_node::requirement_node::negative  >(n.requirement, negative_requirement_tag{}, indent);
+
+    return ret;
+}
+
+auto pretty_print_visualize(requires_expression_node const& n, int indent)
+    -> std::string
+{
+    assert (n.identifier);
+
+    auto ret = std::string{"requires"};
+
+    if (n.parameters) {
+        ret += pretty_print_visualize(*n.parameters, indent+1);
+    }
+
+    ret += " {";
+
+    auto requirement_indent = pre(indent + 1);
+    char separator = '\n';
+    if (n.requirements.size() <= 1) {
+        requirement_indent = {};
+        separator = ' ';
+    }
+
+    ret += separator;
+
+    for (auto& req: n.requirements) {
+        assert(req);
+        ret += requirement_indent + pretty_print_visualize(*req, indent+2) + separator;
+    }
+
+    ret += requirement_indent;
+    ret += '}';
+
+    return ret;
+}
+
+
 auto pretty_print_visualize(contract_node const& n, int indent)
     -> std::string
 {