python · JukkaL · Dec 3, 2019 · Nov 19, 2019 · Nov 21, 2019 · Nov 21, 2019
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -4027,7 +4027,9 @@ def check_subtype(self,
 
         subtype = get_proper_type(subtype)
         supertype = get_proper_type(supertype)
-
+        if self.check_long_tuple_assignment(subtype, supertype, context, msg,
+                                       subtype_label, supertype_label, code=code):
+            return False
         if self.should_suppress_optional_error([subtype]):
             return False
         extra_info = []  # type: List[str]
@@ -4378,6 +4380,75 @@ def infer_issubclass_maps(self, node: CallExpr,
         yes_map, no_map = map(convert_to_typetype, (yes_map, no_map))
         return yes_map, no_map
 
+    def check_long_tuple_assignment(self,
+                                    subtype: ProperType,
+                                    supertype: ProperType,
+                                    context: Context,
+                                    msg: str = message_registry.INCOMPATIBLE_TYPES,
+                                    subtype_label: Optional[str] = None,
+                                    supertype_label: Optional[str] = None,
+                                    code: Optional[ErrorCode] = None) -> bool:
+        """Check if assignment error using long tuple initializers."""
+        if isinstance(subtype, TupleType):
+            if (len(subtype.items) > 10 and
+                isinstance(supertype, Instance) and
+                    supertype.type.fullname == 'builtins.tuple'):
+                lhs_type = supertype.args[0]
+                lhs_types = [lhs_type] * len(subtype.items)
+                self.generate_imcompatiable_tuple_error(lhs_types,
+                                    subtype.items, context, msg, code)
+                return True
+            elif (isinstance(supertype, TupleType) and
+                    (len(subtype.items) > 10 or len(supertype.items) > 10)):
+                if len(subtype.items) != len(supertype.items):
+                    if supertype_label is not None and subtype_label is not None:
+                        error_msg = "{} ({} {}, {} {})".format(msg, subtype_label,
+                                        self.format_long_tuple_type(subtype), supertype_label,
+                                        self.format_long_tuple_type(supertype))
+                        self.fail(error_msg, context, code=code)
+                        return True
+                self.generate_imcompatiable_tuple_error(supertype.items,
+                                    subtype.items, context, msg, code)
+                return True
+        return False
+
+    def format_long_tuple_type(self, typ: TupleType) -> str:
+        """Format very long tuple type using in ellipsis notation"""
+        item_cnt = len(typ.items)
+        if item_cnt > 10:
+            return 'Tuple[{}, {}, ... <{} more items>]'\
+                    .format(format_type_bare(typ.items[0]),
+                        format_type_bare(typ.items[1]), str(item_cnt - 2))
+        else:
+            return format_type_bare(typ)
+
+    def generate_imcompatiable_tuple_error(self,
+                                           lhs_types: List[Type],
+                                           rhs_types: List[Type],
+                                           context: Context,
+                                           msg: str = message_registry.INCOMPATIBLE_TYPES,
+                                           code: Optional[ErrorCode] = None) -> None:
+        """Generate error message for individual imcompatiable tuple pairs"""
+        error_cnt = 0
+        notes = []  # List[str]
+        notes_items = []  # List[Type]
+        for i, (lhs_t, rhs_t) in enumerate(zip(lhs_types, rhs_types)):
+            if not is_subtype(lhs_t, rhs_t):
+                if error_cnt < 3:
+                    notes.append('Expression Tuple item {} has type "{}"; "{}" expected; '
+                        .format(str(i), format_type_bare(rhs_t), format_type_bare(lhs_t)))
+                    notes_items.append(rhs_t)
+                error_cnt += 1
+
+        error_msg = msg + ' ({} tuple items are incompatible'.format(str(error_cnt))
+        if error_cnt - 3 > 0:
+            error_msg += '; {} items are omitted)'.format(str(error_cnt - 3))
+        else:
+            error_msg += ')'
+        self.fail(error_msg, context, code=code)
+        for note, item in zip(notes, notes_items):
+            self.note(note, context, code=code)
+
 
 def conditional_type_map(expr: Expression,
                          current_type: Optional[Type],

diff --git a/test-data/unit/check-tuples.test b/test-data/unit/check-tuples.test
@@ -1241,3 +1241,46 @@ b = ("bar", 7)
 reveal_type(a + b)  # N: Revealed type is 'Tuple[builtins.int, builtins.str, builtins.int, builtins.str, builtins.int]'
 
 [builtins fixtures/tuple.pyi]
+
+[case testAssigningWithLongTupleInitializer]
+from typing import Tuple
+
+# long initializer assignment with few mismatches
+t: Tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", 11) \
+                                                                    # E: Incompatible types in assignment (3 tuple items are incompatible) \
+                                                                    # N: Expression Tuple item 8 has type "str"; "int" expected; \
+                                                                    # N: Expression Tuple item 9 has type "str"; "int" expected; \
+                                                                    # N: Expression Tuple item 10 has type "str"; "int" expected;
+
+# long initializer assignment with more mismatches
+t1: Tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str") \
+                                                                    # E: Incompatible types in assignment (4 tuple items are incompatible; 1 items are omitted) \
+                                                                    # N: Expression Tuple item 8 has type "str"; "int" expected; \
+                                                                    # N: Expression Tuple item 9 has type "str"; "int" expected; \
+                                                                    # N: Expression Tuple item 10 has type "str"; "int" expected;
+
+# short tuple initializer assignment
+t2: Tuple[int, ...] = (1, 2, "s", 4) \
+                                # E: Incompatible types in assignment (expression has type "Tuple[int, int, str, int]", variable has type "Tuple[int, ...]")
+
+# long initializer assignment with few mismatches, no ellipsis
+t3: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "str", "str") \
+                                                                    # E: Incompatible types in assignment (2 tuple items are incompatible) \
+                                                                    # N: Expression Tuple item 10 has type "str"; "int" expected; \
+                                                                    # N: Expression Tuple item 11 has type "str"; "int" expected;
+
+# long initializer assignment with more mismatches, no ellipsis
+t4: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str") \
+                                                                    # E: Incompatible types in assignment (4 tuple items are incompatible; 1 items are omitted) \
+                                                                    # N: Expression Tuple item 8 has type "str"; "int" expected; \
+                                                                    # N: Expression Tuple item 9 has type "str"; "int" expected; \
+                                                                    # N: Expression Tuple item 10 has type "str"; "int" expected;
+
+# short tuple initializer assignment, no ellipsis
+t5: Tuple[int, int] = (1, 2, "s", 4)  # E: Incompatible types in assignment (expression has type "Tuple[int, int, str, int]", variable has type "Tuple[int, int]")
+
+# long initializer assignment with mismatched pairs
+t6: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str", 1, 1, 1, 1, 1) \
+                                                                    # E: Incompatible types in assignment (expression has type Tuple[int, int, ... <15 more items>], variable has type Tuple[int, int, ... <10 more items>]) 
+
+[builtins fixtures/tuple.pyi]