Fix crashes and fails in forward references

mypy/semanal.py

@@ -4120,8 +4120,14 @@ def visit_class_def(self, tdef: ClassDef) -> None:
         # NamedTuple base classes are validated in check_namedtuple_classdef; we don't have to
         # check them again here.
         if not tdef.info.is_named_tuple:
+            types = list(tdef.info.bases)  # type: List[Type]
+            for tvar in tdef.type_vars:
+                if tvar.upper_bound:
+                    types.append(tvar.upper_bound)
+                if tvar.values:
+                    types.extend(tvar.values)
+            self.analyze_types(types, tdef.info)
             for type in tdef.info.bases:
-                self.analyze(type, tdef.info)
                 if tdef.info.is_protocol:
                     if not isinstance(type, Instance) or not type.type.is_protocol:
                         if type.type.fullname() != 'builtins.object':
@@ -4212,6 +4218,13 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
             analyzed = s.rvalue.analyzed
             if isinstance(analyzed, NewTypeExpr):
                 self.analyze(analyzed.old_type, analyzed)
+            if isinstance(analyzed, TypeVarExpr):
+                types = []
+                if analyzed.upper_bound:
+                    types.append(analyzed.upper_bound)
+                if analyzed.values:
+                    types.extend(analyzed.values)
+                self.analyze_types(types, analyzed)
             if isinstance(analyzed, TypedDictExpr):
                 self.analyze(analyzed.info.typeddict_type, analyzed, warn=True)
             if isinstance(analyzed, NamedTupleExpr):
@@ -4267,6 +4280,11 @@ def perform_transform(self, node: Union[Node, SymbolTableNode],
             node.type = transform(node.type)
         if isinstance(node, NewTypeExpr):
             node.old_type = transform(node.old_type)
+        if isinstance(node, TypeVarExpr):
+            if node.upper_bound:
+                node.upper_bound = transform(node.upper_bound)
+            if node.values:
+                node.values = [transform(v) for v in node.values]
         if isinstance(node, TypedDictExpr):
             node.info.typeddict_type = cast(TypedDictType,
                                             transform(node.info.typeddict_type))
@@ -4278,6 +4296,11 @@ def perform_transform(self, node: Union[Node, SymbolTableNode],
         if isinstance(node, SymbolTableNode):
             node.type_override = transform(node.type_override)
         if isinstance(node, TypeInfo):
+            for tvar in node.defn.type_vars:
+                if tvar.upper_bound:
+                    tvar.upper_bound = transform(tvar.upper_bound)
+                if tvar.values:
+                    tvar.values = [transform(v) for v in tvar.values]
             new_bases = []
             for base in node.bases:
                 new_base = transform(base)
@@ -4317,6 +4340,21 @@ def patch() -> None:
                                                                              node, warn)))
                 self.patches.append(patch)
 
+    def analyze_types(self, types: List[Type], node: Node) -> None:
+        # Similar to above but for nodes with multiple types.
+        indicator = {}  # type: Dict[str, bool]
+        for type in types:
+            analyzer = TypeAnalyserPass3(self.fail, self.options, self.is_typeshed_file,
+                                         self.sem, indicator)
+            type.accept(analyzer)
+            self.check_for_omitted_generics(type)
+        if indicator.get('forward') or indicator.get('synthetic'):
+            def patch() -> None:
+                self.perform_transform(node,
+                                       lambda tp: tp.accept(TypeReplacer(self.fail,
+                                                                         node, warn=False)))
+            self.patches.append(patch)
+
     def check_for_omitted_generics(self, typ: Type) -> None:
         if 'generics' not in self.options.disallow_any or self.is_typeshed_file:
             return

mypy/typeanal.py

@@ -660,6 +660,7 @@ def visit_instance(self, t: Instance) -> None:
             t.invalid = True
         elif info.defn.type_vars:
             # Check type argument values.
+            # TODO: Calling is_subtype and is_same_types in semantic analysis is a bad idea
             for (i, arg), tvar in zip(enumerate(t.args), info.defn.type_vars):
                 if tvar.values:
                     if isinstance(arg, TypeVarType):
@@ -672,12 +673,28 @@ def visit_instance(self, t: Instance) -> None:
                     else:
                         arg_values = [arg]
                     self.check_type_var_values(info, arg_values, tvar.name, tvar.values, i + 1, t)
+                # TODO: These hacks will be not necessary when this will be moved to later stage.
                 if isinstance(arg, ForwardRef):
                     arg = arg.link
-                if not is_subtype(arg, tvar.upper_bound):
+                bound = tvar.upper_bound
+                if isinstance(bound, ForwardRef):
+                    bound = bound.link
+                if isinstance(bound, Instance) and bound.type.replaced:
+                    replaced = bound.type.replaced
+                    if replaced.tuple_type:
+                        bound = replaced.tuple_type
+                    if replaced.typeddict_type:
+                        bound = replaced.typeddict_type
+                if isinstance(arg, Instance) and arg.type.replaced:
+                    replaced = arg.type.replaced
+                    if replaced.tuple_type:
+                        arg = replaced.tuple_type
+                    if replaced.typeddict_type:
+                        arg = replaced.typeddict_type
+                if not is_subtype(arg, bound):
                     self.fail('Type argument "{}" of "{}" must be '
                               'a subtype of "{}"'.format(
-                                  arg, info.name(), tvar.upper_bound), t)
+                                  arg, info.name(), bound), t)
         for arg in t.args:
             arg.accept(self)
         if info.is_newtype:

test-data/unit/check-namedtuple.test

@@ -440,7 +440,7 @@ T = TypeVar('T', bound='M')
 class G(Generic[T]):
     x: T
 
-yb: G[int]
+yb: G[int] # E: Type argument "builtins.int" of "G" must be a subtype of "Tuple[builtins.int, fallback=__main__.M]"
 yg: G[M]
 z: int = G[M]().x.x
 z = G[M]().x[0]

test-data/unit/check-typeddict.test

@@ -1333,9 +1333,9 @@ T = TypeVar('T', bound='M')
 class G(Generic[T]):
     x: T
 
-yb: G[int]
+yb: G[int] # E: Type argument "builtins.int" of "G" must be a subtype of "TypedDict({'x': builtins.int}, fallback=typing.Mapping[builtins.str, builtins.object])"
 yg: G[M]
-z: int = G().x['x']
+z: int = G[M]().x['x']
 
 class M(TypedDict):
     x: int