Restore missing parens to expression_list_node output

Except where externally provided, by `f(list)` (provides parens) or `x[list]` (provides brackets) or `type var = {list}` (provides braces)
This corrects cases like `(1+2)*3` and `a<(b>c)>`which had been emitted without parens
See new regression test `mixed-test-parens.cpp2` to exercise these cases in one place

Author: hsutter

regression-tests/mixed-test-parens.cpp2

@@ -0,0 +1,10 @@
+#include <vector>
+
+template<bool>
+auto f(auto, auto) -> void { }
+
+main: () -> int = {
+    v : std::vector<int> = ( 1, 2, 3 );
+    std::cout << (1+2)*(3+v[0]);
+    f<(1>2)>(3,4);
+}

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

@@ -0,0 +1,20 @@
+// ----- Cpp2 support -----
+#include "cpp2util.h"
+
+#line 1 "mixed-test-parens.cpp2"
+#include <vector>
+
+template<bool>
+auto f(auto, auto) -> void { }
+
+[[nodiscard]] auto main() -> int;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 5 "mixed-test-parens.cpp2"
+
+[[nodiscard]] auto main() -> int{
+    std::vector<int> v { 1, 2, 3 }; 
+    std::cout << (1 + 2) * (3 + v[0]);
+    f<(1 > 2)>(3, 4);
+}

regression-tests/test-results/mixed-test-parens.cpp2.output

@@ -0,0 +1,2 @@
+mixed-test-parens.cpp2... ok (mixed Cpp1/Cpp2, Cpp2 code passes safety checks)
+

source/cppfront.cpp

@@ -631,6 +631,15 @@ class cppfront
         //  special value - hack for now to note single-anon-return type kind in this function_returns working list
     std::vector<std::string>                      function_requires_conditions;
 
+    std::vector<bool>                             need_expression_list_parens = { true };
+    auto push_need_expression_list_parens( bool b ) -> void { need_expression_list_parens.push_back(b);            }
+    auto pop_need_expression_list_parens()          -> void { assert(std::ssize(need_expression_list_parens) > 1);
+                                                              need_expression_list_parens.pop_back();              }
+    auto should_add_expression_list_parens()        -> bool { assert(!need_expression_list_parens.empty());
+                                                              return need_expression_list_parens.back();           }
+    auto consumed_expression_list_parens()          -> void { if( std::ssize(need_expression_list_parens) > 1 )
+                                                                  need_expression_list_parens.back() = false;      }
+
 public:
     //-----------------------------------------------------------------------
     //  Constructor
@@ -1677,7 +1686,9 @@ class cppfront
             //  Then tack on any additional arguments
             if (!n.ops[1].expr_list->expressions.empty()) {
                 printer.print_cpp2(", ", n.position());
+                push_need_expression_list_parens(false);
                 emit(*n.ops[1].expr_list);
+                pop_need_expression_list_parens();
             }
             printer.print_cpp2(")", n.position());
 
@@ -1773,7 +1784,9 @@ class cppfront
                 if (i->expr_list) {
                     auto text = std::vector<text_with_pos>{};
                     printer.emit_to_text_chunks(&text);
+                    push_need_expression_list_parens(false);
                     emit(*i->expr_list);
+                    pop_need_expression_list_parens();
                     printer.emit_to_text_chunks();
                     for (auto&& e: text) {
                         suffix.push_back(e);
@@ -1971,6 +1984,10 @@ class cppfront
     //
     auto emit(expression_list_node const& n) -> void
     {
+        if (should_add_expression_list_parens() && !n.expressions.empty()) {
+            printer.print_cpp2("(", n.position());
+        }
+
         auto first = true;
         for (auto const& x : n.expressions) {
             if (!first) {
@@ -2000,6 +2017,12 @@ class cppfront
                 printer.print_cpp2(")", n.position());
             }
         }
+
+        if (should_add_expression_list_parens() && !n.expressions.empty()) {
+            printer.print_cpp2(")", n.position());
+        }
+        //  We want to consume only one of these
+        consumed_expression_list_parens();
     }
 
 
@@ -2519,16 +2542,17 @@ class cppfront
             printer.print_cpp2( " ", n.position());
             assert(n.identifier);
             emit(*n.identifier);
-            //printer.print_cpp2( *n.identifier->identifier, n.position() );
 
             //  If there's an initializer, emit it
             if (n.initializer)
             {
                 printer.add_pad_in_this_line(-100);
                 printer.print_cpp2( " { ", n.position() );
 
+                push_need_expression_list_parens(false);
                 assert( n.initializer );
                 emit( *n.initializer, false );
+                pop_need_expression_list_parens();
 
                 printer.print_cpp2( " }", n.position() );
             }

source/parse.h

@@ -255,11 +255,11 @@ auto to_string_view(passing_style pass) -> std::string_view {
 
 struct expression_list_node
 {
-    source_position open_paren  = {};   // TODO: these should probably be in primary_expression_node
+    source_position open_paren  = {};
     source_position close_paren = {};
 
     struct term {
-        passing_style                    pass = {}; // for `out`
+        passing_style                    pass = {};
         std::unique_ptr<expression_node> expr;
     };
     std::vector< term > expressions;
@@ -269,10 +269,6 @@ struct expression_list_node
         //  Make sure this got set
         assert (open_paren != source_position());
         return open_paren;
-
-        //  TODO this could be removed now that we're tracking position via open_paren
-        //assert (std::ssize(expressions) > 0 && expressions.front().expr);
-        //return expressions.front().expr->position();
     }
 
     auto visit(auto& v, int depth) -> void
@@ -1765,8 +1761,8 @@ class parser
     //G     template-argument-list , template-argument
     //G
     //G template-argument:
-    //G     expression
     //G     id-expression
+    //G     expression
     //G
     auto unqualified_id() -> std::unique_ptr<unqualified_id_node>
     {
@@ -2481,7 +2477,6 @@ class parser
         next();
         auto s = std::unique_ptr<statement_node>();
 
-
         while (curr().type() != lexeme::RightBrace) {
             auto s = statement(true);
             if (!s) {