Add basic _requires-clause_ support

Should merge user-written _requires-clause_ expressions with any generated from `forward` parameters

Author: hsutter

regression-tests/pure2-requires-clauses.cpp2

@@ -0,0 +1,21 @@
+
+X:  <T: type, U: type>
+    type
+    requires std::is_same_v<T, int>
+              && std::is_same_v<U, int>
+= {
+    operator=: (out this) = { }
+}
+
+f:  <T: type, U: type>
+    (forward a: int, forward b: int) -> int
+    requires std::is_same_v<T, int>
+              && std::is_same_v<U, int>
+= {
+    return a * b;
+}
+
+main: () = {
+    x: X<int,int> = ();
+    std::cout << f<int,int>(2,5);
+}

regression-tests/test-results/clang-12/pure2-requires-clauses.cpp.execution

@@ -0,0 +1 @@
+10

regression-tests/test-results/clang-12/pure2-requires-clauses.cpp.output

@@ -0,0 +1 @@
+abc

regression-tests/test-results/gcc-10/pure2-function-multiple-forward-arguments.cpp.execution

@@ -0,0 +1 @@
+10

regression-tests/test-results/gcc-10/pure2-function-multiple-forward-arguments.cpp.output

@@ -36,14 +36,14 @@ auto use(auto const& x) -> void{}
 
 // invoking each of these with an rvalue std::pair argument ...
 auto apply_implicit_forward(auto&& t) -> void
-requires std::is_same_v<CPP2_TYPEOF(t), std::pair<X,X>>
+requires (std::is_same_v<CPP2_TYPEOF(t), std::pair<X,X>>)
 #line 16 "mixed-forwarding.cpp2"
                                                      {
     copy_from(t.first);             // copies
     copy_from(CPP2_FORWARD(t).second);// moves
 }
 auto apply_explicit_forward(auto&& t) -> void
-requires std::is_same_v<CPP2_TYPEOF(t), std::pair<X,X>>
+requires (std::is_same_v<CPP2_TYPEOF(t), std::pair<X,X>>)
 #line 20 "mixed-forwarding.cpp2"
                                                      {
     copy_from(        CPP2_FORWARD(t).first);// moves

regression-tests/test-results/gcc-10/pure2-requires-clauses.cpp.execution

@@ -34,7 +34,7 @@ auto parameter_styles(
     std::string&& d, 
     auto&&   e
     ) -> void
-requires std::is_same_v<CPP2_TYPEOF(e), std::string>
+requires (std::is_same_v<CPP2_TYPEOF(e), std::string>)
 #line 15 "mixed-parameter-passing-with-forward.cpp2"
 {
     int z {12}; 

regression-tests/test-results/gcc-10/pure2-requires-clauses.cpp.output

@@ -0,0 +1 @@
+abc

regression-tests/test-results/mixed-forwarding.cpp

@@ -0,0 +1 @@
+pure2-function-multiple-forward-arguments.cpp

regression-tests/test-results/mixed-parameter-passing-with-forward.cpp

@@ -0,0 +1 @@
+10

regression-tests/test-results/msvc-2022/pure2-function-multiple-forward-arguments.cpp.execution

@@ -0,0 +1 @@
+pure2-requires-clauses.cpp

regression-tests/test-results/msvc-2022/pure2-function-multiple-forward-arguments.cpp.output

@@ -3,9 +3,9 @@
 
 #include "cpp2util.h"
 
-
 #line 1 "pure2-function-multiple-forward-arguments.cpp2"
 auto fun(auto&& s1,             auto&&   s2,              auto&&   s3) -> void;
+
 #line 5 "pure2-function-multiple-forward-arguments.cpp2"
 auto main() -> int;
 
@@ -14,8 +14,9 @@ auto main() -> int;
 #line 1 "pure2-function-multiple-forward-arguments.cpp2"
 auto fun(auto&& s1,             auto&&   s2,              auto&&   s3) -> void
 requires (std::is_same_v<CPP2_TYPEOF(s1), std::string> && std::is_same_v<CPP2_TYPEOF(s2), std::string> && std::is_same_v<CPP2_TYPEOF(s3), std::string>)
-#line 2 "pure2-function-multiple-forward-arguments.cpp2"
-{   std::cout << CPP2_FORWARD(s1) << CPP2_FORWARD(s2) << CPP2_FORWARD(s3) << std::endl;
+#line 1 "pure2-function-multiple-forward-arguments.cpp2"
+                                                                                    {
+    std::cout << CPP2_FORWARD(s1) << CPP2_FORWARD(s2) << CPP2_FORWARD(s3) << std::endl;
 }
 
 auto main() -> int{

regression-tests/test-results/msvc-2022/pure2-requires-clauses.cpp.execution

@@ -0,0 +1,44 @@
+
+#define CPP2_USE_MODULES         Yes
+
+#include "cpp2util.h"
+
+#line 2 "pure2-requires-clauses.cpp2"
+template<typename T, typename U> 
+
+    requires( std::is_same_v<T,int> 
+              && std::is_same_v<U,int>)
+class X;
+
+#line 10 "pure2-requires-clauses.cpp2"
+template<typename T, typename U> [[nodiscard]] auto f
+        (auto&& a,   auto&&   b) ->     int;
+
+#line 18 "pure2-requires-clauses.cpp2"
+auto main() -> int;
+
+//=== Cpp2 definitions ==========================================================
+
+
+#line 2 "pure2-requires-clauses.cpp2"
+template<typename T, typename U> 
+
+    requires( std::is_same_v<T,int> 
+              && std::is_same_v<U,int>)
+class X {
+    public: X  (){}
+};
+
+template<typename T, typename U> [[nodiscard]] auto f
+        (auto&& a,   auto&&   b) ->     int
+requires (std::is_same_v<T,int> && std::is_same_v<U,int> && std::is_same_v<CPP2_TYPEOF(a), int> && std::is_same_v<CPP2_TYPEOF(b), int>)
+#line 14 "pure2-requires-clauses.cpp2"
+{
+    return CPP2_FORWARD(a) * CPP2_FORWARD(b); 
+}
+
+auto main() -> int{
+    X<int,int> x {}; 
+    std::cout << f<int,int>(2, 5);
+}
+

regression-tests/test-results/msvc-2022/pure2-requires-clauses.cpp.output

@@ -0,0 +1,2 @@
+pure2-requires-clauses.cpp2... ok (all Cpp2, passes safety checks)
+

regression-tests/test-results/pure2-function-multiple-forward-arguments.cpp

@@ -4256,6 +4256,7 @@ class cppfront
         }
     }
 
+
     //-----------------------------------------------------------------------
     //
     auto emit(
@@ -4337,6 +4338,12 @@ class cppfront
         //  User-defined type
         if (n.is_type())
         {
+            if (n.requires_clause_expression) {
+                printer.print_cpp2("requires( ", n.requires_pos);
+                emit(*n.requires_clause_expression);
+                printer.print_cpp2(")\n", n.requires_pos);
+            }
+
             printer.print_cpp2("class ", n.position());
             emit(*n.identifier);
 
@@ -4636,7 +4643,7 @@ class cppfront
                 }
             }
 
-            //  Function declaration
+            //  End function declaration
             if (printer.doing_declarations_only()) {
                 printer.print_cpp2( ";\n", n.position() );
                 return;
@@ -4724,28 +4731,32 @@ class cppfront
 
             printer.preempt_position_push( n.equal_sign );
 
-            // TODO: something like this to get rid of extra blank lines
-            //       inside the start of bodies of functions that have
-            //       multiple contracts
-            //printer.skip_lines( std::ssize(current_functions.back().prolog.statements) );
-
-            //  If processing the parameters generated any requires conditions,
-            //  emit them here
-            if (!function_requires_conditions.empty()) {
-                printer.ignore_alignment( true, n.position().colno + 4 );
+            //  Handle requires expression - an explicit one plus any generated
+            //  from processing the parameters
+            if (
+                n.requires_clause_expression
+                || !function_requires_conditions.empty()
+                )
+            {
                 printer.print_extra("\n");
-                auto is_multi_fwd = function_requires_conditions.size() > 1;
-                printer.print_extra("requires ");
-                if (is_multi_fwd) {
-                    printer.print_extra("(");
-                }
-                printer.print_extra(function_requires_conditions.front());
-                for (auto it = std::cbegin(function_requires_conditions)+1; it != std::cend(function_requires_conditions); ++it) {
-                    printer.print_extra(" && " + *it);
+                printer.ignore_alignment( true, n.position().colno + 4 );
+                printer.print_extra("requires (");
+
+                if (n.requires_clause_expression) {
+                    emit(*n.requires_clause_expression);
+                    if (!function_requires_conditions.empty()) {
+                        printer.print_extra(" && ");
+                    }
                 }
-                if (is_multi_fwd) {
-                    printer.print_extra(")");
+
+                if (!function_requires_conditions.empty()) {
+                    printer.print_extra(function_requires_conditions.front());
+                    for (auto it = std::cbegin(function_requires_conditions)+1; it != std::cend(function_requires_conditions); ++it) {
+                        printer.print_extra(" && " + *it);
+                    }
                 }
+
+                printer.print_extra(")");
                 function_requires_conditions = {};
                 printer.ignore_alignment( false );
             }

regression-tests/test-results/pure2-function-multiple-forward-arguments.cpp2

@@ -1509,6 +1509,8 @@ struct declaration_node
     > type;
 
     std::unique_ptr<parameter_declaration_list_node> template_parameters;
+    source_position                                  requires_pos = {};
+    std::unique_ptr<expression_node>                 requires_clause_expression;
 
     source_position                 equal_sign = {};
     std::unique_ptr<statement_node> initializer;
@@ -2827,6 +2829,10 @@ class parser
             {
                 typename Binary::term t{};
 
+                //  Remember current position, because we may need to backtrack if this next
+                //  t.op might be valid but isn't followed by a valid term and so isn't for us
+                auto term_pos = pos;
+
                 //  Most of these predicates only look at the current token and return
                 //  true/false == whether this is a valid operator for this production
                 if constexpr( requires{ bool{ validate_op(curr()) }; } ) {
@@ -2860,11 +2866,16 @@ class parser
                     assert (!"ICE: validate_op should take one token and return bool, or two tokens and return token const* ");
                 }
 
-                //  At this point we have a valid t.op, so try to parse the next term
+                //  At this point we may have a valid t.op, so try to parse the next term...
+                //  If it's not a valid term, then this t.op wasn't for us, pop it and return
+                //  what we found (e.g., with "requires expression = {...}" the = is a grammar
+                //  element and not an operator, it isn't and can't be part of the expression)
                 if ( !(t.expr = term()) ) {
-                    error("invalid expression after " + peek(-1)->to_string(true), true, {}, true);
+                    pos = term_pos;    // backtrack
                     return n;
                 }
+
+                //  We got a term, so this op + term was for us
                 n->terms.push_back( std::move(t) );
             }
             return n;
@@ -4646,12 +4657,15 @@ class parser
 
 
     //G unnamed-declaration:
-    //G     ':' template-parameter-declaration-list? function-type '=' statement
-    //G     ':' template-parameter-declaration-list? type-id? '=' statement
+    //G     ':' template-parameter-declaration-list? function-type requires-clause? '=' statement
+    //G     ':' template-parameter-declaration-list? type-id? requires-clause? '=' statement
     //G     ':' template-parameter-declaration-list? type-id
-    //G     ':' template-parameter-declaration-list? 'type' meta-constraints? '=' statement
+    //G     ':' template-parameter-declaration-list? 'type' meta-constraints? requires-clause? '=' statement
     //G     ':' 'namespace' '=' statement
     //G
+    //G requires-clause:
+    //G     'requires' expression
+    //G
     //G template-parameter-declaration-list
     //G     '<' parameter-declaration-seq '>'
     //G
@@ -4825,6 +4839,18 @@ class parser
             deduced_type = true;
         }
 
+        //  Next is optionally a requires clause
+        if (curr() == "requires") {
+            n->requires_pos = curr().position();
+            next();
+            auto e = expression();
+            if (!e) {
+                error("'requires' must be followed by an expression");
+                return {};
+            }
+            n->requires_clause_expression = std::move(e);
+        }
+
         //  Next is optionally = followed by an initializer
 
         //  If there is no =