Allow trailing commas in lists

See also #115, and the comment there that goes with this commit: #115 (comment)

Author: hsutter

regression-tests/pure2-bugfix-for-parameter-decl-list-error.cpp2

@@ -0,0 +1,21 @@
+f: (a, b, ) a + b;
+
+g: <T, U, > (a: T, b: U) a + b;
+
+doubler: (a: int,) -> (i : int,) = {
+    i = a * 2;
+}
+
+vals: @struct type = { i: int; }
+
+main: () -> int = {
+    (copy a := 42,) while false { a++; }
+    _ = g(1, 2,);
+
+    grouping: std::vector = (0, 1, 2,);
+
+    array: std::array = (0, 1, 2,);
+
+    _ = array;
+    _ = grouping;
+}

regression-tests/pure2-trailing-commas.cpp2

@@ -0,0 +1 @@
+pure2-trailing-commas.cpp

regression-tests/test-results/clang-12/pure2-trailing-commas.cpp.execution

@@ -0,0 +1,65 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-trailing-commas.cpp2"
+
+#line 9 "pure2-trailing-commas.cpp2"
+class vals;
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-trailing-commas.cpp2"
+[[nodiscard]] auto f(auto const& a, auto const& b) -> auto;
+
+#line 3 "pure2-trailing-commas.cpp2"
+template<typename T, typename U> [[nodiscard]] auto g(T const& a, U const& b) -> auto;
+using doubler_ret = int;
+
+
+#line 5 "pure2-trailing-commas.cpp2"
+[[nodiscard]] auto doubler(cpp2::impl::in<int> a) -> doubler_ret;
+
+#line 9 "pure2-trailing-commas.cpp2"
+class vals {public: int i; };
+
+[[nodiscard]] auto main() -> int;
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-trailing-commas.cpp2"
+[[nodiscard]] auto f(auto const& a, auto const& b) -> auto { return a + b;  }
+
+#line 3 "pure2-trailing-commas.cpp2"
+template<typename T, typename U> [[nodiscard]] auto g(T const& a, U const& b) -> auto { return a + b;  }
+
+#line 5 "pure2-trailing-commas.cpp2"
+[[nodiscard]] auto doubler(cpp2::impl::in<int> a) -> doubler_ret{
+        cpp2::impl::deferred_init<int> i;
+#line 6 "pure2-trailing-commas.cpp2"
+    i.construct(a * 2);
+return std::move(i.value()); }
+
+#line 11 "pure2-trailing-commas.cpp2"
+[[nodiscard]] auto main() -> int{
+{
+auto a{42};
+#line 12 "pure2-trailing-commas.cpp2"
+    while( false ) {++a; }
+}
+#line 13 "pure2-trailing-commas.cpp2"
+    static_cast<void>(g(1, 2));
+
+    std::vector grouping {0, 1, 2}; 
+
+    std::array array {0, 1, 2}; 
+
+    static_cast<void>(std::move(array));
+    static_cast<void>(std::move(grouping));
+}
+

regression-tests/test-results/clang-12/pure2-trailing-commas.cpp.output

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

regression-tests/test-results/gcc-10/pure2-trailing-commas.cpp.execution

@@ -6360,6 +6360,12 @@ class parser
         //  and see if there are more...
         while (curr().type() == lexeme::Comma) {
             next();
+
+            //  Allow a trailing comma in the list
+            if (curr().type() == lexeme::RightParen) {
+                break;
+            }
+
             pass = passing_style::in;
             if (auto dir = to_passing_style(curr());
                 dir == passing_style::out
@@ -6377,6 +6383,7 @@ class parser
             }
             n->expressions.push_back( { pass, std::move(expr) } );
         }
+
         return n;
     }
 
@@ -7809,11 +7816,9 @@ class parser
         auto param = std::make_unique<parameter_declaration_node>();
 
         auto count = 1;
-        auto expect_another_param_decl = false;
 
         while ((param = parameter_declaration(is_returns, is_named, is_template, is_statement)) != nullptr)
         {
-            expect_another_param_decl = false;
             param->ordinal = count;
             ++count;
 
@@ -7830,6 +7835,17 @@ class parser
             if (curr().type() == closer) {
                 break;
             }
+
+            //  Allow a trailing comma in the list
+            else if (
+                curr().type() == lexeme::Comma
+                && peek(1)->type() == closer
+                )
+            {
+                next();
+                break;
+            }
+
             else if (curr().type() != lexeme::Comma) {
                 if (is_statement) {
                     pos = start_pos;    // backtrack
@@ -7840,14 +7856,9 @@ class parser
                 return {};
             }
 
-            expect_another_param_decl = true;
             next();
         }
 
-        if (expect_another_param_decl) {
-            error("invalid parameter list: a comma must be followed by another parameter", true, {}, true);
-        }
-
         if (curr().type() != closer) {
             if (is_statement) {
                 pos = start_pos;    // backtrack