fix: lower nested _braced-init-list_

Author: JohelEGP

regression-tests/pure2-bugfix-for-nested-lists.cpp2

@@ -13,14 +13,14 @@ main: () = {
     assert(check((17, 29)).x == 17);
     assert(check((17, 29)).y == 29);
 
-  //board: std::array<std::array<u8, 3>, 3> = ((
-  //                                        ('O', 'X', 'O'),
-  //                                        (' ', 'X', 'X'),
-  //                                        ('X', 'O', 'O')
-  //));
-  //assert(board[0] == :std::array<u8, 3> = ('O', 'X', 'O'));
-  //assert(board[1] == :std::array<u8, 3> = (' ', 'X', 'X'));
-  //assert(board[2] == :std::array<u8, 3> = ('X', 'O', 'O'));
+    board: std::array<std::array<u8, 3>, 3> = ((
+                                            ('O', 'X', 'O'),
+                                            (' ', ('X'), 'X'),
+                                            ('X', 'O', 'O')
+    ));
+    assert(board[0] == :std::array<u8, 3> = ('O', 'X', 'O'));
+    assert(board[1] == :std::array<u8, 3> = (' ', 'X', 'X'));
+    assert(board[2] == :std::array<u8, 3> = ('X', 'O', 'O'));
 
     // Still parentheses
     assert((:std::vector = (17, 29)).size() == 2);

regression-tests/test-results/pure2-bugfix-for-nested-lists.cpp

@@ -70,14 +70,14 @@ auto main() -> int{
     if (cpp2::Default.has_handler() && !(check({17, 29}).x == 17) ) { cpp2::Default.report_violation(""); }
     if (cpp2::Default.has_handler() && !(check({17, 29}).y == 29) ) { cpp2::Default.report_violation(""); }
 
-  //board: std::array<std::array<u8, 3>, 3> = ((
-  //                                        ('O', 'X', 'O'),
-  //                                        (' ', 'X', 'X'),
-  //                                        ('X', 'O', 'O')
-  //));
-  //assert(board[0] == :std::array<u8, 3> = ('O', 'X', 'O'));
-  //assert(board[1] == :std::array<u8, 3> = (' ', 'X', 'X'));
-  //assert(board[2] == :std::array<u8, 3> = ('X', 'O', 'O'));
+    std::array<std::array<cpp2::u8,3>,3> board {{ { 
+                                            'O', 'X', 'O' }, { 
+                                            ' ', { 'X' }, 'X' }, { 
+                                            'X', 'O', 'O' } }}; 
+
+    if (cpp2::Default.has_handler() && !(CPP2_ASSERT_IN_BOUNDS(board, 0) == std::array<cpp2::u8,3>{'O', 'X', 'O'}) ) { cpp2::Default.report_violation(""); }
+    if (cpp2::Default.has_handler() && !(CPP2_ASSERT_IN_BOUNDS(board, 1) == std::array<cpp2::u8,3>{' ', 'X', 'X'}) ) { cpp2::Default.report_violation(""); }
+    if (cpp2::Default.has_handler() && !(CPP2_ASSERT_IN_BOUNDS(std::move(board), 2) == std::array<cpp2::u8,3>{'X', 'O', 'O'}) ) { cpp2::Default.report_violation(""); }
 
     // Still parentheses
     if (cpp2::Default.has_handler() && !(CPP2_UFCS(size)((std::vector{17, 29})) == 2) ) { cpp2::Default.report_violation(""); }

source/parse.h

@@ -6241,8 +6241,28 @@ class parser
             return n;
         }
 
+        auto add_expression = [&](expression_list_node::term t) {
+            std::function<void(expression_list_node::term&)> mark_nested_inside_initializer{
+                [&](expression_list_node::term& u) {
+                    if (
+                        inside_initializer
+                        && u.expr->is_expression_list()
+                        )
+                    {
+                        auto l = const_cast<expression_list_node*>(u.expr->get_expression_list());
+                        l->inside_initializer = true;
+                        for (auto& e : l->expressions) {
+                            mark_nested_inside_initializer(e);
+                        }
+                    }
+                }
+            };
+            mark_nested_inside_initializer(t);
+            n->expressions.push_back(std::move(t));
+        };
+
         //  Otherwise remember the first expression
-        n->expressions.push_back( { pass, std::move(x) } );
+        add_expression( { pass, std::move(x) } );
         //  and see if there are more...
         while (curr().type() == lexeme::Comma) {
             next();
@@ -6261,7 +6281,7 @@ class parser
                 error("invalid text in expression list", true, {}, true);
                 return {};
             }
-            n->expressions.push_back( { pass, std::move(expr) } );
+            add_expression( { pass, std::move(expr) } );
         }
         return n;
     }

source/to_cpp1.h

@@ -3929,7 +3929,22 @@ class cppfront
 
             assert(x.expr);
             current_args.push_back( {x.pass} );
-            emit(*x.expr);
+            //  In a nested expression-list in an initializer, we can
+            //  take over direct control of emitting it without needing to
+            //  go through the whole grammar, and surround it with braces
+            if (
+                n.inside_initializer
+                && x.expr->is_expression_list()
+                )
+            {
+                printer.print_cpp2( "{ ", n.position() );
+                emit(*x.expr->get_expression_list(), false);
+                printer.print_cpp2( " }", n.position() );
+            }
+            //  Otherwise, just emit the general expression as usual
+            else {
+                emit(*x.expr);
+            }
             current_args.pop_back();
 
             if (is_out) {