Second part of review comments

python · JukkaL · Jul 7, 2017 · Jun 10, 2017 · Jun 10, 2017 · Jun 10, 2017
commit 7e7c1b70e1cfff4f09e200bc2d3b298497891239
diff --git a/mypy/fixup.py b/mypy/fixup.py
@@ -88,8 +88,6 @@ def visit_symbol_table(self, symtab: SymbolTable) -> None:
                     if stnode is not None:
                         value.node = stnode.node
                         value.type_override = stnode.type_override
-                        if not value.type_override and self.quick_and_dirty:
-                            value.type_override = Instance(stale_info(), [])
                         value.alias_tvars = stnode.alias_tvars or []
                     elif not self.quick_and_dirty:
                         assert stnode is not None, "Could not find cross-ref %s" % (cross_ref,)

diff --git a/mypy/nodes.py b/mypy/nodes.py
@@ -2268,6 +2268,8 @@ class SymbolTableNode:
     mod_id = ''  # type: Optional[str]
     # If this not None, override the type of the 'node' attribute.
     type_override = None  # type: Optional[mypy.types.Type]
+    # For generic aliases this stores the (qualified) names of type variables.
+    # (For example see testGenericAliasWithTypeVarsFromDifferentModules.)
        alias_tvars = None  # type: Optional[List[str]]
     # If False, this name won't be imported via 'from <module> import *'.
     # This has no effect on names within classes.

diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -1626,6 +1626,11 @@ def alias_fallback(self, tp: Type) -> Instance:
 
     def analyze_alias(self, rvalue: Expression,
                       allow_unnormalized: bool) -> Tuple[Optional[Type], List[str]]:
+        """Check if 'rvalue' represents a valid type allowed for aliasing
+        (e.g. not a type variable). If yes, return the corresponding type and a list of
+        qualified type variable names for generic aliases.
+        If 'allow_unnormalized' is True, allow types like builtins.list[T].
+        """
         res = analyze_type_alias(rvalue,
                                  self.lookup_qualified,
                                  self.lookup_fully_qualified,
@@ -1643,9 +1648,13 @@ def analyze_alias(self, rvalue: Expression,
         return res, alias_tvars
 
     def check_and_set_up_type_alias(self, s: AssignmentStmt) -> None:
-        """Check if assignment creates a type alias and set it up as needed."""
-        # Type aliases are created only at module scope, at class and function scopes
-        # assignments create class valued members and local variables with type object types.
+        """Check if assignment creates a type alias and set it up as needed.
+        For simple aliases like L = List we use a simpler mechanism, just copying TypeInfo.
+        For subscripted (including generic) aliases we mark corresponding node as TYPE_ALIAS
+        and store the corresponding type in node.override and in rvalue.analyzed.
+        """
+        # Type aliases are created only at module scope and class scope (for subscripted types),
+        # at function scope assignments always create local variables with type object types.
         if (len(s.lvalues) == 1 and not self.is_func_scope() and
                 not (self.type and isinstance(s.rvalue, NameExpr) and s.lvalues[0].is_def)
                 and not s.type):
@@ -1668,6 +1677,8 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> None:
                     # so we need to replace it with non-explicit Anys
                     res = make_any_non_explicit(res)
                     if isinstance(res, Instance) and not res.args and isinstance(rvalue, RefExpr):
+                        # For simple (on-generic) aliases we use aliasing TypeInfo's
+                        # to allow using them in runtime context where it makes sense.
                         node.node = res.type
                         if isinstance(rvalue, RefExpr):
                             sym = self.lookup_type_node(rvalue)
@@ -1678,6 +1689,8 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> None:
                     node.type_override = res
                     node.alias_tvars = alias_tvars
                     if isinstance(s.rvalue, IndexExpr):
+                        # We only need this for subscripted aliases, since simple aliases
+                        # are already processed using aliasing TypeInfo's above.
                         s.rvalue.analyzed = TypeAliasExpr(res, node.alias_tvars,
                                                           fallback=self.alias_fallback(res))
                         s.rvalue.analyzed.line = s.rvalue.line

diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test
@@ -935,7 +935,7 @@ from typing import TypeVar, List, Tuple
 import a
 import b
 T = TypeVar('T')
-Alias = List[Tuple[T, a.T, b.T, b.B.T]]
+Alias = List[Tuple[T, a.T, b.T, b.B.T]]  # alias_tvars here will be ['T', 'a.T', 'b.T', 'b.B.T']
 
 [file a.py]
 from typing import TypeVar