fix some potential errors and add more unit test

Author: LiuYuHui

mypy/checker.py

@@ -2483,36 +2483,47 @@ def check_assignment_to_multiple_lvalues(self, lvalues: List[Lvalue], rvalue: Ex
             # 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:
+            iterable_type = None  # type: Optional[Type]
+            last_idx = None  # type: Optional[int]
+            for idx_rval, rval in enumerate(rvalue.items):
                 if isinstance(rval, StarExpr):
                     typs = get_proper_type(self.expr_checker.visit_star_expr(rval).type)
                     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) and isinstance(typs, Instance):
-                        item_type_of_iterable.append(self.iterable_item_type(typs))
-                        idx_of_iterable.append(idx)
+                        if (iterable_type is not None
+                                and iterable_type != self.iterable_item_type(typs)):
+                            self.fail("Contiguous iterable with same type expected", context)
+                        else:
+                            if last_idx is None or last_idx + 1 == idx_rval:
+                                rvalues.append(rval)
+                                last_idx = idx_rval
+                                iterable_type = self.iterable_item_type(typs)
+                            else:
+                                self.fail("Contiguous iterable with same type expected", context)
                     else:
-                        self.fail("StarExpr should not be a '{}'".format(typs), context)
+                        self.fail("Invalid type '{}' for *expr (iterable expected)".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)]
+            iterable_start = None  # type: Optional[int]
+            iterable_end = None  # type: Optional[int]
+            for i, rval in enumerate(rvalues):
+                if isinstance(rval, StarExpr):
+                    typs = get_proper_type(self.expr_checker.visit_star_expr(rval).type)
+                    if self.type_is_iterable(typs) and isinstance(typs, Instance):
+                        if iterable_start is None:
+                            iterable_start = i
+                        iterable_end = i
+            if (iterable_start is not None
+                    and iterable_end is not None
+                    and iterable_type is not None):
+                iterable_num = iterable_end - iterable_start + 1
+                rvalue_needed = len(lvalues) - (len(rvalues) - iterable_num)
+                if rvalue_needed > 0:
+                    rvalues = rvalues[0: iterable_start] + [TempNode(iterable_type)
+                        for i in range(rvalue_needed)] + rvalues[iterable_end + 1:]
+
             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

@@ -1445,4 +1445,16 @@ 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'
 
+x5, x6, y5, y6, z4 = *points2, *points2, "test"
+
+reveal_type(x5) # N: Revealed type is 'builtins.int*'
+reveal_type(x6) # N: Revealed type is 'builtins.int*'
+reveal_type(y5) # N: Revealed type is 'builtins.int*'
+reveal_type(y6) # N: Revealed type is 'builtins.int*'
+reveal_type(z4) # N: Revealed type is 'builtins.str'
+
+points3 = ["test1", "test2"]
+x7, x8, y7, y8 = *points2, *points3 # E: Contiguous iterable with same type expected
+
+x9, y9, x10, y10, z5 = *points2, 1, *points2 # E: Contiguous iterable with same type expected
 [builtins fixtures/tuple.pyi]