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) {