add support for iterable

Author: LiuYuHui

mypy/checker.py

@@ -2482,17 +2482,38 @@ def check_assignment_to_multiple_lvalues(self, lvalues: List[Lvalue], rvalue: Ex
             # using the type of rhs, because this allowed more fine grained
             # control in cases like: a, b = [int, str] where rhs would get
             # type List[object]
-
             rvalues = []  # type: List[Expression]
+            lhs_len = len(lvalues)
+            idx_of_iterable = []
+            item_type_of_iterable = []  # type: List['mypy.types.Type']
+            idx = 0
             for rval in rvalue.items:
                 if isinstance(rval, StarExpr):
-                    typs = get_proper_type(self.expr_checker.visit_star_expr(rval).type)
+                    typs = get_proper_type(self.expr_checker.visit_star_expr(rval).type)  # type: ProperType
                     if isinstance(typs, TupleType):
                         rvalues.extend([TempNode(typ) for typ in typs.items])
+                        lhs_len -= len(typs.items)
+                        idx += len(typs.items)
+                    elif self.type_is_iterable(typs):
+                        item_type_of_iterable.append(self.iterable_item_type(typs))
+                        idx_of_iterable.append(idx)
                     else:
-                        rvalues.append(TempNode(typs))
+                        self.fail("StarExpr should not be a '{}'".format(typs), context)
                 else:
                     rvalues.append(rval)
+                    lhs_len -= 1
+                    idx += 1
+            num_every_iterable = 0
+            num_last_iterable = 0
+            if len(idx_of_iterable):
+                num_every_iterable = int(lhs_len / len(idx_of_iterable))
+                num_last_iterable = lhs_len - (len(idx_of_iterable) - 1) * int(num_every_iterable)
+            for i, (idx, item_type) in enumerate(zip(idx_of_iterable, item_type_of_iterable)):
+                if i == (len(idx_of_iterable) - 1):
+                    rvalues[idx:idx] = [TempNode(item_type) for _ in range(num_last_iterable)]
+                else:
+                    rvalues[idx:idx] = [TempNode(item_type) for _ in range(num_every_iterable)]
+                    
             if self.check_rvalue_count_in_assignment(lvalues, len(rvalues), context):
                 star_index = next((i for i, lv in enumerate(lvalues) if
                                    isinstance(lv, StarExpr)), len(lvalues))

test-data/unit/check-tuples.test

@@ -1423,8 +1423,26 @@ t6: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3
 [builtins fixtures/tuple.pyi]
 
 [case testTupleWithStarExpr]
-from typing import Tuple
-points = (1, 2)  # type: Tuple[int, int]
+from typing import Tuple, List
+points = (1, "test")  # type: Tuple[int, str]
 x, y, z = *points, 0
+reveal_type(x) # N: Revealed type is 'builtins.int'
+reveal_type(y) # N: Revealed type is 'builtins.str'
+reveal_type(z) # N: Revealed type is 'builtins.int'
+
+points2 = [1,2]
+x2, y2, z2= *points2, "test"
+
+reveal_type(x2) # N: Revealed type is 'builtins.int*'
+reveal_type(y2) # N: Revealed type is 'builtins.int*'
+reveal_type(z2) # N: Revealed type is 'builtins.str'
+
+x3, x4, y3, y4, z3 = *points, *points2, "test"
+
+reveal_type(x3) # N: Revealed type is 'builtins.int'
+reveal_type(x4) # N: Revealed type is 'builtins.str'
+reveal_type(y3) # N: Revealed type is 'builtins.int*'
+reveal_type(y4) # N: Revealed type is 'builtins.int*'
+reveal_type(z3) # N: Revealed type is 'builtins.str'
 
 [builtins fixtures/tuple.pyi]