Fix postponed fallback join

JukkaL · Sep 27, 2017 · Aug 31, 2017 · Sep 1, 2017 · Sep 11, 2017 · Sep 11, 2017
commit ec454415918385a94e3320ad52f8b5fff2a3e903
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -2361,11 +2361,6 @@ def build_namedtuple_typeinfo(self, name: str, items: List[str], types: List[Typ
         # Actual signature should return OrderedDict[str, Union[types]]
         ordereddictype = (self.named_type_or_none('builtins.dict', [strtype, implicit_any])
                           or self.object_type())
-        # 'builtins.tuple' has only one type parameter.
-        #
-        # TODO: The corresponding type argument in the fallback instance should be a join of
-        #       all item types, but we can't do joins during this pass of semantic analysis
-        #       and we are using Any as a workaround.
         fallback = self.named_type('__builtins__.tuple', [implicit_any])
         # Note: actual signature should accept an invariant version of Iterable[UnionType[types]].
         # but it can't be expressed. 'new' and 'len' should be callable types.
@@ -2376,6 +2371,15 @@ def build_namedtuple_typeinfo(self, name: str, items: List[str], types: List[Typ
         info.is_named_tuple = True
         info.tuple_type = TupleType(types, fallback)
 
+        def patch() -> None:
+            # Calculate the correct value type for the fallback Mapping.
+            fallback.args[0] = join.join_type_list(list(info.tuple_type.items))
+
+        # We can't calculate the complete fallback type until after semantic
+        # analysis, since otherwise MROs might be incomplete. Postpone a callback
+        # function that patches the fallback.
+        self.patches.append(patch)
+
         def add_field(var: Var, is_initialized_in_class: bool = False,
                       is_property: bool = False) -> None:
             var.info = info
@@ -2595,19 +2599,18 @@ def build_typeddict_typeinfo(self, name: str, items: List[str],
         fallback = (self.named_type_or_none('typing.Mapping',
                                             [self.str_type(), self.object_type()])
                     or self.object_type())
+        info = self.basic_new_typeinfo(name, fallback)
+        info.typeddict_type = TypedDictType(OrderedDict(zip(items, types)), required_keys,
+                                            fallback)
 
         def patch() -> None:
             # Calculate the correct value type for the fallback Mapping.
-            fallback.args[1] = join.join_type_list(types)
+            fallback.args[1] = join.join_type_list(list(info.typeddict_type.items.values()))
 
         # We can't calculate the complete fallback type until after semantic
         # analysis, since otherwise MROs might be incomplete. Postpone a callback
         # function that patches the fallback.
         self.patches.append(patch)
-
-        info = self.basic_new_typeinfo(name, fallback)
-        info.typeddict_type = TypedDictType(OrderedDict(zip(items, types)), required_keys,
-                                            fallback)
         return info
 
     def check_classvar(self, s: AssignmentStmt) -> None:
@@ -4223,15 +4226,11 @@ def perform_transform(self, node: Node, transform) -> None:
             node.types = [transform(t) for t in node.types]
 
     def remove_forward_refs(self, tp: Type) -> Type:
-        # print("BEFORE", tp)
         tp = tp.accept(ForwardRefRemover())
-        # print("AFTER", tp)
         return tp
 
     def replace_synthetic(self, tp: Type) -> Type:
-        print("BEFORE", tp)
         tp = tp.accept(SyntheticReplacer())
-        print("AFTER", tp)
         return tp
 
     def analyze(self, type: Optional[Type], node: Optional[Node]) -> None:

diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test
@@ -415,7 +415,7 @@ b = B._make([''])  # type: B
 [case testNamedTupleIncompatibleRedefinition]
 from typing import NamedTuple
 class Crash(NamedTuple):
-    count: int  # E: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[Any, ...], Any], int]")
+    count: int  # E: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[int, ...], Any], int]")
 [builtins fixtures/tuple.pyi]
 
 [case testNamedTupleInClassNamespace]