Changed index of for-stmt and generator expressions to be a single node (possibly a tuple) instead of a list. Updated tests accordingly.

Author: spkersten

mypy/checker.py

@@ -1537,21 +1537,10 @@ def analyse_iterable_item_type(self, expr: Node) -> Type:
                                                          expr)
             return echk.check_call(method, [], [], expr)[0]
 
-    def analyse_index_variables(self, index: List[Node],
-                                item_type: Type, context: Context) -> None:
+    def analyse_index_variables(self, index: Node, item_type: Type,
+                                context: Context) -> None:
         """Type check or infer for loop or list comprehension index vars."""
-        # Create a temporary copy of variables with Node item type.
-        # TODO this is ugly
-        node_index = []  # type: List[Node]
-        for i in index:
-            node_index.append(i)
-
-        if len(node_index) == 1:
-            self.check_assignment(node_index[0], self.temp_node(item_type, context))
-        else:
-            self.check_multi_assignment(node_index,
-                               self.temp_node(item_type, context),
-                               context)
+        self.check_assignment(index, self.temp_node(item_type, context))
 
     def visit_del_stmt(self, s: DelStmt) -> Type:
         if isinstance(s.expr, IndexExpr):

mypy/noderepr.py

@@ -144,10 +144,9 @@ def __init__(self, while_tok: Any, else_tok: Any) -> None:
 
 
 class ForStmtRepr:
-    def __init__(self, for_tok: Any, commas: Any, in_tok: Any,
+    def __init__(self, for_tok: Any, in_tok: Any,
                  else_tok: Any) -> None:
         self.for_tok = for_tok
-        self.commas = commas
         self.in_tok = in_tok
         self.else_tok = else_tok
 
@@ -331,10 +330,9 @@ def __init__(self, langle: Any, commas: Any, rangle: Any) -> None:
 
 
 class GeneratorExprRepr:
-    def __init__(self, for_toks: List[Token], commas: List[Token], in_toks: List[Token],
+    def __init__(self, for_toks: List[Token], in_toks: List[Token],
                  if_toklists: List[List[Token]]) -> None:
         self.for_toks = for_toks
-        self.commas = commas
         self.in_toks = in_toks
         self.if_toklists = if_toklists
 

mypy/nodes.py

@@ -568,13 +568,13 @@ def accept(self, visitor: NodeVisitor[T]) -> T:
 
 class ForStmt(Node):
     # Index variables
-    index = Undefined(List['Node'])
+    index = Undefined(Node)
     # Expression to iterate
     expr = Undefined(Node)
     body = Undefined(Block)
     else_body = Undefined(Block)
 
-    def __init__(self, index: List['Node'], expr: Node, body: Block,
+    def __init__(self, index: Node, expr: Node, body: Block,
                  else_body: Block) -> None:
         self.index = index
         self.expr = expr
@@ -1192,9 +1192,9 @@ class GeneratorExpr(Node):
     left_expr = Undefined(Node)
     sequences_expr = Undefined(List[Node])
     condlists = Undefined(List[List[Node]])
-    indices = Undefined(List[List[Node]])
+    indices = Undefined(List[Node])
 
-    def __init__(self, left_expr: Node, indices: List[List[Node]],
+    def __init__(self, left_expr: Node, indices: List[Node],
                  sequences: List[Node], condlists: List[List[Node]]) -> None:
         self.left_expr = left_expr
         self.sequences = sequences

mypy/output.py

@@ -262,9 +262,7 @@ def visit_while_stmt(self, o):
     def visit_for_stmt(self, o):
         r = o.repr
         self.token(r.for_tok)
-        for i in range(len(o.index)):
-            self.node(o.index[i])
-            self.token(r.commas[i])
+        self.node(o.index)
         self.token(r.in_tok)
         self.node(o.expr)
 
@@ -450,10 +448,7 @@ def visit_generator_expr(self, o):
         self.node(o.left_expr)
         for i in range(len(o.indices)):
             self.token(r.for_toks[i])
-            for j in range(len(o.indices[i])):
-                self.node(o.indices[i][j])
-                if j < len(o.indices[i]) - 1:
-                    self.token(r.commas[0])
+            self.node(o.indices[i])
             self.token(r.in_toks[i])
             self.node(o.sequences[i])
             for cond, if_tok in zip(o.condlists[i], r.if_toklists[i]):

mypy/parse.py

@@ -852,7 +852,7 @@ def parse_while_stmt(self) -> WhileStmt:
 
     def parse_for_stmt(self) -> ForStmt:
         for_tok = self.expect('for')
-        index, commas = self.parse_for_index_variables()
+        index = self.parse_for_index_variables()
         in_tok = self.expect('in')
         expr = self.parse_expression()
 
@@ -866,13 +866,12 @@ def parse_for_stmt(self) -> ForStmt:
             else_tok = none
 
         node = ForStmt(index, expr, body, else_body)
-        self.set_repr(node, noderepr.ForStmtRepr(for_tok, commas, in_tok,
-                                                 else_tok))
+        self.set_repr(node, noderepr.ForStmtRepr(for_tok, in_tok, else_tok))
         return node
 
-    def parse_for_index_variables(self) -> Tuple[List[Node], List[Token]]:
+    def parse_for_index_variables(self) -> Node:
         # Parse index variables of a 'for' statement.
-        index = List[Node]()
+        index_items = List[Node]()
         commas = List[Token]()
 
         is_paren = self.current_str() == '('
@@ -881,7 +880,7 @@ def parse_for_index_variables(self) -> Tuple[List[Node], List[Token]]:
 
         while True:
             v = self.parse_expression(precedence['in'], star_expr_allowed=True)  # prevent parsing of for-stmt's 'in'
-            index.append(v)
+            index_items.append(v)
             if self.current_str() != ',':
                 commas.append(none)
                 break
@@ -890,7 +889,14 @@ def parse_for_index_variables(self) -> Tuple[List[Node], List[Token]]:
         if is_paren:
             self.expect(')')
 
-        return index, commas
+        if len(index_items) == 1:
+            index = index_items[0]
+        else:
+            index = TupleExpr(index_items)
+            index.set_line(index_items[0].get_line())
+            self.set_repr(index, noderepr.TupleExprRepr(none, commas, none))
+
+        return index
 
     def parse_if_stmt(self) -> IfStmt:
         is_error = False
@@ -1196,7 +1202,7 @@ def parse_generator_expr(self, left_expr: Node) -> GeneratorExpr:
             if_toks = List[Token]()
             conds = List[Node]()
             for_toks.append(self.expect('for'))
-            index, commas = self.parse_for_index_variables()
+            index = self.parse_for_index_variables()
             indices.append(index)
             in_toks.append(self.expect('in'))
             sequence = self.parse_expression_list()
@@ -1209,8 +1215,7 @@ def parse_generator_expr(self, left_expr: Node) -> GeneratorExpr:
 
         gen = GeneratorExpr(left_expr, indices, sequences, condlists)
         gen.set_line(for_toks[0])
-        self.set_repr(gen, noderepr.GeneratorExprRepr(for_toks, commas, in_toks,
-                                                      if_toklists))
+        self.set_repr(gen, noderepr.GeneratorExprRepr(for_toks, in_toks, if_toklists))
         return gen
 
     def parse_expression_list(self) -> Node:

mypy/semanal.py

@@ -1055,8 +1055,7 @@ def visit_for_stmt(self, s: ForStmt) -> None:
         s.expr.accept(self)
 
         # Bind index variables and check if they define new names.
-        for n in s.index:
-            self.analyse_lvalue(n)
+        self.analyse_lvalue(s.index)
 
         self.loop_depth += 1
         self.visit_block(s.body)
@@ -1333,8 +1332,7 @@ def visit_generator_expr(self, expr: GeneratorExpr) -> None:
                                                expr.condlists):
             sequence.accept(self)
             # Bind index variables.
-            for n in index:
-                self.analyse_lvalue(n)
+            self.analyse_lvalue(index)
             for cond in conditions:
                 cond.accept(self)
 
@@ -1595,8 +1593,7 @@ def visit_var_def(self, d: VarDef) -> None:
                                                          self.sem.cur_mod_id)
 
     def visit_for_stmt(self, s: ForStmt) -> None:
-        for n in s.index:
-            self.sem.analyse_lvalue(n, add_global=True)
+        self.sem.analyse_lvalue(s.index, add_global=True)
 
     def visit_with_stmt(self, s: WithStmt) -> None:
         for n in s.name:

mypy/test/data/parse.test

@@ -843,11 +843,12 @@ MypyFile:1(
     Block:1(
       PassStmt:2()))
   ForStmt:3(
-    NameExpr(x)
-    ParenExpr:3(
-      TupleExpr:3(
-        NameExpr(y)
-        NameExpr(w)))
+    TupleExpr:3(
+      NameExpr(x)
+      ParenExpr:3(
+        TupleExpr:3(
+          NameExpr(y)
+          NameExpr(w))))
     NameExpr(z)
     Block:3(
       ExpressionStmt:4(
@@ -1196,11 +1197,12 @@ MypyFile:1(
   ExpressionStmt:1(
     GeneratorExpr:1(
       NameExpr(x)
-      NameExpr(y)
-      ParenExpr:1(
-        TupleExpr:1(
-          NameExpr(p)
-          NameExpr(q)))
+      TupleExpr:1(
+        NameExpr(y)
+        ParenExpr:1(
+          TupleExpr:1(
+            NameExpr(p)
+            NameExpr(q))))
       NameExpr(z))))
 
 [case testListComprehension]
@@ -1227,8 +1229,9 @@ MypyFile:1(
           TupleExpr:1(
             NameExpr(x)
             NameExpr(y)))
-        NameExpr(y)
-        NameExpr(z)
+        TupleExpr:1(
+          NameExpr(y)
+          NameExpr(z))
         TupleExpr:1(
           IntExpr(1)
           IntExpr(2))))))
@@ -1458,8 +1461,9 @@ for (i, j) in x:
 [out]
 MypyFile:1(
   ForStmt:1(
-    NameExpr(i)
-    NameExpr(j)
+    TupleExpr:1(
+      NameExpr(i)
+      NameExpr(j))
     NameExpr(x)
     Block:1(
       PassStmt:2())))
@@ -2787,16 +2791,18 @@ MypyFile:1(
     Block:1(
       PassStmt:2()))
   ForStmt:4(
-    NameExpr(a)
-    StarExpr:4(
-      NameExpr(b))
+    TupleExpr:4(
+      NameExpr(a)
+      StarExpr:4(
+        NameExpr(b)))
     NameExpr(c)
     Block:4(
       PassStmt:5()))
   ForStmt:7(
-    StarExpr:7(
-      NameExpr(a))
-    NameExpr(b)
+    TupleExpr:7(
+      StarExpr:7(
+        NameExpr(a))
+      NameExpr(b))
     NameExpr(c)
     Block:7(
       PassStmt:8())))
@@ -2810,22 +2816,25 @@ MypyFile:1(
   ExpressionStmt:1(
     GeneratorExpr:1(
       NameExpr(x)
-      NameExpr(y)
-      StarExpr:1(
-        NameExpr(p))
+      TupleExpr:1(
+        NameExpr(y)
+        StarExpr:1(
+          NameExpr(p)))
       NameExpr(z)))
   ExpressionStmt:2(
     GeneratorExpr:2(
       NameExpr(x)
-      StarExpr:2(
-        NameExpr(p))
-      NameExpr(y)
+      TupleExpr:2(
+        StarExpr:2(
+          NameExpr(p))
+        NameExpr(y))
       NameExpr(z)))
   ExpressionStmt:3(
     GeneratorExpr:3(
       NameExpr(x)
-      NameExpr(y)
-      StarExpr:3(
-        NameExpr(p))
-      NameExpr(q)
+      TupleExpr:3(
+        NameExpr(y)
+        StarExpr:3(
+          NameExpr(p))
+        NameExpr(q))
       NameExpr(z))))

mypy/test/data/semanal-errors.test

@@ -419,6 +419,7 @@ main, line 7: Two starred expressions in assignment
 (a for a, (*b, *c) in [])
 [out]
 main, line 1: Two starred expressions in assignment
+main, line 1: Name 'a' is not defined
 main, line 3: Two starred expressions in assignment
 
 [case testStarExpressionRhs]

mypy/test/data/semanal-expressions.test

@@ -261,11 +261,12 @@ MypyFile:1(
   ExpressionStmt:2(
     GeneratorExpr:2(
       NameExpr(x [l])
-      NameExpr(x* [l])
-      ParenExpr:2(
-        TupleExpr:2(
-          NameExpr(y* [l])
-          NameExpr(z* [l])))
+      TupleExpr:2(
+        NameExpr(x* [l])
+        ParenExpr:2(
+          TupleExpr:2(
+            NameExpr(y* [l])
+            NameExpr(z* [l]))))
       NameExpr(a [__main__.a]))))
 
 [case testLambda]

mypy/test/data/semanal-statements.test

@@ -113,8 +113,9 @@ for x, y in []:
 [out]
 MypyFile:1(
   ForStmt:1(
-    NameExpr(x* [__main__.x])
-    NameExpr(y* [__main__.y])
+    TupleExpr:1(
+      NameExpr(x* [__main__.x])
+      NameExpr(y* [__main__.y]))
     ListExpr:1()
     Block:1(
       ExpressionStmt:2(