Unpack to toplevel list of variables.

So
```
a, b, c = (1, 2, 3)
```
is properly assigned to variables a, b and c.

Author: hzeller

bant/frontend/elaboration_test.cc

@@ -128,7 +128,7 @@ cc_library(
   EXPECT_EQ(result.first, result.second);
 }
 
-TEST_F(ElaborationTest, IdentifiersAssignedInTuplesAreUsable) {
+TEST_F(ElaborationTest, UnpackIntoTuple) {
   auto result = ElabAndPrint(
     R"(
 (a, b) = (42, 123)
@@ -146,6 +146,23 @@ d = 170
   EXPECT_EQ(result.first, result.second);
 }
 
+TEST_F(ElaborationTest, UnpackIntoToplevelListIsTreatedAsAssignmentToTuple) {
+  // Essentially the same as tuple
+  auto result = ElabAndPrint(
+    R"(
+a, b = (42, 123)
+x, y = (a, b)
+d = x + y
+)",
+    R"(
+(a, b) = (42, 123)
+(x, y) = (42, 123)
+d = 165
+)");
+
+  EXPECT_EQ(result.first, result.second);
+}
+
 TEST_F(ElaborationTest, ConcatLists) {
   auto result = ElabAndPrint(
     R"(

bant/frontend/parser.cc

@@ -158,6 +158,18 @@ class Parser::Impl {
           node_arena_,
           ParseIdAssignRhs(Make<Identifier>(tok.text), after_id.text));
         break;
+      case TokenType::kComma: {  // toplevel unpack assignment
+        List *started_list = Make<List>(List::Type::kTuple);
+        started_list->Append(node_arena_, Make<Identifier>(tok.text));
+        // List ends with assignment.
+        Token assign;
+        List *const lhs = ParseList(
+          started_list, [&]() { return ParseOptionalIdentifier(); },
+          TokenType::kAssign, &assign);
+        statement_list->Append(node_arena_,
+                               ParseNodeAssignRhs(lhs, tok.text, assign.text));
+        break;
+      }
       case TokenType::kOpenParen:
         statement_list->Append(node_arena_, ParseFunCall(tok));
         break;
@@ -204,10 +216,10 @@ class Parser::Impl {
   }
 
   // Parse expressions produced by element_parse up to and including end_tok
-  // is reached.
+  // is reached. If save_last_tok is non-null, last token will be stored there
   using ListElementParse = std::function<Node *()>;
   List *ParseList(List *result, const ListElementParse &element_parse,
-                  TokenType end_tok) {
+                  TokenType end_tok, Token *save_last_tok = nullptr) {
     LOG_ENTER();
     // Opening list-token (e.g. '[', '(', '{') already consumed.
     Token upcoming = scanner_->Peek();
@@ -223,7 +235,8 @@ class Parser::Impl {
         return result;
       }
     }
-    scanner_->Next();  // consume end_tok
+    const Token closing_list = scanner_->Next();  // consume end_tok
+    if (save_last_tok) *save_last_tok = closing_list;
     return result;
   }
 

bant/frontend/parser_test.cc

@@ -203,13 +203,15 @@ TEST_F(ParserTest, AssignmentToTuple) {
   Node *const expected = List({
     Assign(Tuple({Id("a"), Id("b")}), Tuple({Str("foo"), Str("bar")})),
     Assign(Tuple({Id("x"), Id("y")}), Call("foo", Tuple({}))),
+    Assign(Tuple({Id("q"), Id("u")}), Tuple({Int(1), Int(2)})),
     Assign("A", Id("B")),
     Assign(Tuple({Id("c"), Id("d")}), Tuple({Int(1), Int(2)})),
   });
 
   EXPECT_EQ(Print(expected), Print(Parse(R"(
 (a, b) = ("foo", "bar")
 (x, y) = foo()
+q, u = (1, 2)  # Unpack
 A = B    # scalar assignment, the following parenthesis are not a fun call
 (c, d) = (1, 2)
 #a = ((u, v) = foo())   # should this work ? Right now we only do toplevel.