Add support for return expression lists, closes #325

Author: hsutter

source/cppfront.cpp

@@ -2201,7 +2201,19 @@ class cppfront
                 }
             }
 
-            emit(*n.expression);
+            //  If this expression is just a single expression-list, we can
+            //  take over direct control of emitting it without needing to
+            //  go through the whole grammar, and surround it with braces
+            if (n.expression->is_expression_list()) {
+                printer.print_cpp2( "{ ", n.position() );
+                emit(*n.expression->get_expression_list(), false);
+                printer.print_cpp2( " }", n.position() );
+            }
+            //  Otherwise, just emit the general expression as usual
+            else {
+                emit(*n.expression);
+            }
+
             if (
                 function_returns.empty()
                 || function_returns.back().param_list != &single_anon
@@ -3446,12 +3458,16 @@ class cppfront
 
     //-----------------------------------------------------------------------
     //
-    auto emit(expression_list_node const& n)
+    auto emit(
+        expression_list_node const& n,
+        bool                        parens_ok = true
+    )
         -> void
     {
         auto add_parens =
             should_add_expression_list_parens()
             && !n.inside_initializer
+            && parens_ok
             ;
         if (add_parens) {
             printer.print_cpp2( *n.open_paren, n.position());
@@ -3520,18 +3536,35 @@ class cppfront
         -> void
     {
         assert(n.expr);
+        auto generating_return = false;
 
         if (function_body_start != source_position{}) {
             emit_prolog_mem_inits(function_prolog, n.position().colno);
             printer.print_cpp2(" { ", function_body_start);
             emit_prolog_statements(function_prolog, n.position().colno);
             if (!function_void_ret) {
                 printer.print_cpp2("return ", n.position());
+                generating_return = true;
             }
         }
 
         if (!emitted) {
-            emit(*n.expr);
+            //  When generating 'return' of a single expression-list, we can
+            //  take over direct control of emitting it without needing to
+            //  go through the whole grammar, and surround it with braces
+            if (
+                generating_return
+                && n.expr->is_expression_list()
+                )
+            {
+                printer.print_cpp2( "{ ", n.position() );
+                emit(*n.expr->get_expression_list(), false);
+                printer.print_cpp2( " }", n.position() );
+            }
+            //  Otherwise, just emit the general expression as usual
+            else {
+                emit(*n.expr);
+            }
             if (can_have_semicolon) {
                 printer.print_cpp2(";", n.position());
             }

source/parse.h

@@ -144,6 +144,12 @@ struct primary_expression_node
         std::unique_ptr<literal_node>
     > expr;
 
+    auto is_expression_list() const
+        -> bool;
+
+    auto get_expression_list() const
+        -> expression_list_node const*;
+
     auto template_args_count() -> int;
     auto get_token() const -> token const*;
     auto position() const -> source_position;
@@ -188,6 +194,12 @@ struct prefix_expression_node
     std::vector<token const*> ops;
     std::unique_ptr<postfix_expression_node> expr;
 
+    auto is_expression_list() const
+        -> bool;
+
+    auto get_expression_list() const
+        -> expression_list_node const*;
+
     auto get_postfix_expression_node() const
         -> postfix_expression_node *
     {
@@ -217,6 +229,23 @@ struct binary_expression_node
     };
     std::vector<term> terms;
 
+    //  API
+    //
+    auto is_expression_list() const
+        -> bool
+    {
+        return terms.empty() && expr->is_expression_list();
+    }
+
+    auto get_expression_list() const
+        -> expression_list_node const*
+    {
+        if (is_expression_list()) {
+            return expr->get_expression_list();
+        }
+        return {};
+    }
+
     //  Get left-hand postfix-expression
     auto get_postfix_expression_node() const
         -> postfix_expression_node *
@@ -325,6 +354,21 @@ struct expression_node
 
     // API
     //
+    auto is_expression_list() const
+        -> bool
+    {
+        return expr->is_expression_list();
+    }
+
+    auto get_expression_list() const
+        -> expression_list_node const*
+    {
+        if (is_expression_list()) {
+            return expr->get_expression_list();
+        }
+        return {};
+    }
+
     auto get_lhs_rhs_if_simple_assignment() const
         -> assignment_expression_lhs_rhs;
 
@@ -408,6 +452,21 @@ struct expression_list_node
     }
 };
 
+auto primary_expression_node::is_expression_list() const
+    -> bool
+{
+    return expr.index() == expression_list;
+}
+
+auto primary_expression_node::get_expression_list() const
+    -> expression_list_node const*
+{
+    if (is_expression_list()) {
+        return std::get<expression_list>(expr).get();
+    }
+    return {};
+}
+
 
 struct expression_statement_node
 {
@@ -483,6 +542,21 @@ struct postfix_expression_node
 
     //  API
     //
+    auto is_expression_list() const
+        -> bool
+    {
+        return ops.empty() && expr->is_expression_list();
+    }
+
+    auto get_expression_list() const
+        -> expression_list_node const*
+    {
+        if (is_expression_list()) {
+            return expr->get_expression_list();
+        }
+        return {};
+    }
+
     auto get_first_token_ignoring_this() const
         -> token const*;
 
@@ -506,6 +580,21 @@ struct postfix_expression_node
     auto visit(auto& v, int depth) -> void;
 };
 
+auto prefix_expression_node::is_expression_list() const
+    -> bool
+{
+    return ops.empty() && expr->is_expression_list();
+}
+
+auto prefix_expression_node::get_expression_list() const
+    -> expression_list_node const*
+{
+    if (is_expression_list()) {
+        return expr->get_expression_list();
+    }
+    return {};
+}
+
 auto prefix_expression_node::is_result_a_temporary_variable() const -> bool {
     if (ops.empty()) {
         return expr->is_result_a_temporary_variable();
@@ -833,6 +922,21 @@ struct is_as_expression_node
     };
     std::vector<term> ops;
 
+    auto is_expression_list() const
+        -> bool
+    {
+        return ops.empty() && expr->is_expression_list();
+    }
+
+    auto get_expression_list() const
+        -> expression_list_node const*
+    {
+        if (is_expression_list()) {
+            return expr->get_expression_list();
+        }
+        return {};
+    }
+
     auto get_postfix_expression_node() const
         -> postfix_expression_node *
     {