Some more ideas

python · ilevkivskyi · Nov 14, 2019 · Nov 8, 2019 · Nov 8, 2019 · Nov 9, 2019
commit 51a63a41a62c49c3912f8f4e7e9e63c7686ba9ff
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -92,8 +92,7 @@ def infer_constraints(template: Type, actual: Type,
     """
     if any(get_proper_type(template) == get_proper_type(t) for t in TypeState._inferring):
         return []
-    if (isinstance(template, TypeAliasType) and isinstance(actual, TypeAliasType) and
-            template.is_recursive and actual.is_recursive):
+    if isinstance(template, TypeAliasType) and template.is_recursive:
         # This case requires special care because it may cause infinite recursion.
         TypeState._inferring.append(template)
         res = _infer_constraints(template, actual, direction)
@@ -105,6 +104,7 @@ def infer_constraints(template: Type, actual: Type,
 def _infer_constraints(template: Type, actual: Type,
                        direction: int) -> List[Constraint]:
 
+    orig_template = template
     template = get_proper_type(template)
     actual = get_proper_type(actual)
 
@@ -129,7 +129,7 @@ def _infer_constraints(template: Type, actual: Type,
     if direction == SUPERTYPE_OF and isinstance(actual, UnionType):
         res = []
         for a_item in actual.items:
-            res.extend(infer_constraints(template, a_item, direction))
+            res.extend(infer_constraints(orig_template, a_item, direction))
         return res
 
     # Now the potential subtype is known not to be a Union or a type

diff --git a/mypy/messages.py b/mypy/messages.py
@@ -23,7 +23,7 @@
     Type, CallableType, Instance, TypeVarType, TupleType, TypedDictType, LiteralType,
     UnionType, NoneType, AnyType, Overloaded, FunctionLike, DeletedType, TypeType,
     UninhabitedType, TypeOfAny, UnboundType, PartialType, get_proper_type, ProperType,
-    get_proper_types
+    get_proper_types, TypeAliasType
 )
 from mypy.typetraverser import TypeTraverserVisitor
 from mypy.nodes import (
@@ -1413,6 +1413,8 @@ def format(typ: Type) -> str:
         return format_type_inner(typ, verbosity, fullnames)
 
     # TODO: show type alias names in errors.
+    if isinstance(typ, TypeAliasType) and typ.is_recursive:
+        return str(typ)
     typ = get_proper_type(typ)
 
     if isinstance(typ, Instance):

diff --git a/mypy/sametypes.py b/mypy/sametypes.py
@@ -10,8 +10,6 @@
 
 def is_same_type(left: Type, right: Type) -> bool:
     """Is 'left' the same type as 'right'?"""
-    left = get_proper_type(left)
-    right = get_proper_type(right)
 
     if isinstance(right, UnboundType):
         # Make unbound types same as anything else to reduce the number of
@@ -32,7 +30,6 @@ def is_same_type(left: Type, right: Type) -> bool:
 
 
 def simplify_union(t: Type) -> ProperType:
-    t = get_proper_type(t)
     if isinstance(t, UnionType):
         return make_simplified_union(t.items)
     return t

diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -1911,14 +1911,18 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
             return
 
         tag = self.track_incomplete_refs()
+        self.no_applications = True
         s.rvalue.accept(self)
+        self.no_applications = False
         if self.found_incomplete_ref(tag) or self.should_wait_rhs(s.rvalue):
             # Initializer couldn't be fully analyzed. Defer the current node and give up.
             # Make sure that if we skip the definition of some local names, they can't be
             # added later in this scope, since an earlier definition should take precedence.
+            s.rvalue.accept(self)
             for expr in names_modified_by_assignment(s):
                 self.mark_incomplete(expr.name, expr)
             return
+        s.rvalue.accept(self)
 
         # The r.h.s. is now ready to be classified, first check if it is a special form:
         special_form = False
@@ -2510,9 +2514,6 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
 
         if existing:
             # An alias gets updated.
-            if self.final_iteration:
-                self.cannot_resolve_name(lvalue.name, 'iiiname', s)
-                return True
             updated = False
             if isinstance(existing.node, TypeAlias):
                 if existing.node.target != res:
@@ -2527,9 +2528,13 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
                 existing.node = alias_node
                 updated = True
             if updated:
-                self.progress = True
-                # We need to defer so that this change can get propagated to base classes.
-                self.defer(s)
+                if self.final_iteration:
+                    self.cannot_resolve_name(lvalue.name, 'name', s)
+                    return True
+                else:
+                    self.progress = True
+                    # We need to defer so that this change can get propagated to base classes.
+                    self.defer(s)
         else:
             self.add_symbol(lvalue.name, alias_node, s)
         if isinstance(rvalue, RefExpr) and isinstance(rvalue.node, TypeAlias):
@@ -3645,8 +3650,8 @@ def visit_index_expr(self, expr: IndexExpr) -> None:
                 and isinstance(base.node, TypeInfo)
                 and not base.node.is_generic()):
             expr.index.accept(self)
-        elif ((isinstance(base, RefExpr) and isinstance(base.node, TypeAlias))
-              or refers_to_class_or_function(base)):
+        elif (((isinstance(base, RefExpr) and isinstance(base.node, TypeAlias))
+              or refers_to_class_or_function(base)) and not getattr(self, 'no_applications', False)):
             # We need to do full processing on every iteration, since some type
             # arguments may contain placeholder types.
             self.analyze_type_application(expr)

diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -103,6 +103,8 @@ def _is_subtype(left: Type, right: Type,
                 ignore_pos_arg_names: bool = False,
                 ignore_declared_variance: bool = False,
                 ignore_promotions: bool = False) -> bool:
+    orig_right = right
+    orig_left = left
     left = get_proper_type(left)
     right = get_proper_type(right)
 
@@ -113,7 +115,7 @@ def _is_subtype(left: Type, right: Type,
         # Normally, when 'left' is not itself a union, the only way
         # 'left' can be a subtype of the union 'right' is if it is a
         # subtype of one of the items making up the union.
-        is_subtype_of_item = any(is_subtype(left, item,
+        is_subtype_of_item = any(is_subtype(orig_left, item,
                                             ignore_type_params=ignore_type_params,
                                             ignore_pos_arg_names=ignore_pos_arg_names,
                                             ignore_declared_variance=ignore_declared_variance,
@@ -130,7 +132,7 @@ def _is_subtype(left: Type, right: Type,
         elif is_subtype_of_item:
             return True
         # otherwise, fall through
-    return left.accept(SubtypeVisitor(right,
+    return left.accept(SubtypeVisitor(orig_right,
                                       ignore_type_params=ignore_type_params,
                                       ignore_pos_arg_names=ignore_pos_arg_names,
                                       ignore_declared_variance=ignore_declared_variance,
@@ -155,13 +157,14 @@ def is_equivalent(a: Type, b: Type,
 
 class SubtypeVisitor(TypeVisitor[bool]):
 
-    def __init__(self, right: ProperType,
+    def __init__(self, right: Type,
                  *,
                  ignore_type_params: bool,
                  ignore_pos_arg_names: bool = False,
                  ignore_declared_variance: bool = False,
                  ignore_promotions: bool = False) -> None:
-        self.right = right
+        self.right = get_proper_type(right)
+        self.orig_right = right
         self.ignore_type_params = ignore_type_params
         self.ignore_pos_arg_names = ignore_pos_arg_names
         self.ignore_declared_variance = ignore_declared_variance
@@ -449,7 +452,7 @@ def visit_overloaded(self, left: Overloaded) -> bool:
             return False
 
     def visit_union_type(self, left: UnionType) -> bool:
-        return all(self._is_subtype(item, self.right) for item in left.items)
+        return all(self._is_subtype(item, self.orig_right) for item in left.items)
 
     def visit_partial_type(self, left: PartialType) -> bool:
         # This is indeterminate as we don't really know the complete type yet.
@@ -1139,22 +1142,26 @@ def is_proper_subtype(left: Type, right: Type, *, ignore_promotions: bool = Fals
 
 def _is_proper_subtype(left: Type, right: Type, *, ignore_promotions: bool = False,
                        erase_instances: bool = False) -> bool:
+    orig_left = left
+    orig_right = right
     left = get_proper_type(left)
     right = get_proper_type(right)
 
     if isinstance(right, UnionType) and not isinstance(left, UnionType):
-        return any([is_proper_subtype(left, item, ignore_promotions=ignore_promotions,
+        return any([is_proper_subtype(orig_left, item, ignore_promotions=ignore_promotions,
                                       erase_instances=erase_instances)
                     for item in right.items])
-    return left.accept(ProperSubtypeVisitor(right, ignore_promotions=ignore_promotions,
+    return left.accept(ProperSubtypeVisitor(orig_right,
+                                            ignore_promotions=ignore_promotions,
                                             erase_instances=erase_instances))
 
 
 class ProperSubtypeVisitor(TypeVisitor[bool]):
-    def __init__(self, right: ProperType, *,
+    def __init__(self, right: Type, *,
                  ignore_promotions: bool = False,
                  erase_instances: bool = False) -> None:
-        self.right = right
+        self.right = get_proper_type(right)
+        self.orig_right = right
         self.ignore_promotions = ignore_promotions
         self.erase_instances = erase_instances
         self._subtype_kind = ProperSubtypeVisitor.build_subtype_kind(
@@ -1313,7 +1320,7 @@ def visit_overloaded(self, left: Overloaded) -> bool:
         return False
 
     def visit_union_type(self, left: UnionType) -> bool:
-        return all([self._is_proper_subtype(item, self.right) for item in left.items])
+        return all([self._is_proper_subtype(item, self.orig_right) for item in left.items])
 
     def visit_partial_type(self, left: PartialType) -> bool:
         # TODO: What's the right thing to do here?

diff --git a/mypy/type_visitor.py b/mypy/type_visitor.py
@@ -337,6 +337,7 @@ def query_types(self, types: Iterable[Type]) -> T:
         for t in types:
             if isinstance(t, TypeAliasType):
                 # Avoid infinite recursion for recursive type aliases.
+                # TODO: Ideally we should fire subvisitors if we care about duplicates.
                 if t in self.seen_aliases:
                     continue
                 self.seen_aliases.add(t)

diff --git a/mypy/typeops.py b/mypy/typeops.py
@@ -303,12 +303,11 @@ def make_simplified_union(items: Sequence[Type],
     Note: This must NOT be used during semantic analysis, since TypeInfos may not
           be fully initialized.
     """
-    items = get_proper_types(items)
     while any(isinstance(typ, UnionType) for typ in items):
-        all_items = []  # type: List[ProperType]
+        all_items = []  # type: List[Type]
         for typ in items:
             if isinstance(typ, UnionType):
-                all_items.extend(get_proper_types(typ.items))
+                all_items.extend(typ.items)
             else:
                 all_items.append(typ)
         items = all_items

diff --git a/mypy/types.py b/mypy/types.py
@@ -2188,6 +2188,21 @@ def visit_type_var(self, typ: TypeVarType) -> Type:
     def visit_placeholder_type(self, typ: PlaceholderType) -> Type:
         return typ
 
+    def visit_callable_argument(self, t: CallableArgument) -> Type:
+        pass
+
+    def visit_ellipsis_type(self, t: EllipsisType) -> Type:
+        pass
+
+    def visit_raw_expression_type(self, t: RawExpressionType) -> Type:
+        pass
+
+    def visit_star_type(self, t: StarType) -> Type:
+        pass
+
+    def visit_type_list(self, t: TypeList) -> Type:
+        pass
+
 
 def replace_alias_tvars(tp: Type, vars: List[str], subs: List[Type],
                         newline: int, newcolumn: int) -> Type:

diff --git a/test-data/unit/check-type-aliases.test b/test-data/unit/check-type-aliases.test
@@ -638,19 +638,26 @@ except E as e:
 
 [case testTryFancyAliases]
 from typing import Sequence, TypeVar, List, Union, Tuple
-dummy: C
+
 T = TypeVar('T')
 
-Nested = Union[int, List[Nested]]
+NestedA = List[Union[T, NestedA[T]]]
+NestedB = Union[T, List[NestedB[T]]]
 
-x: Nested = [1, [2, [3]]]
-reveal_type(x)
+xa: NestedA[int] = [1, [2, [3]]]
+xb: NestedB[int] = [1, [2, [3]]]
+reveal_type(xa)
+reveal_type(xb)
 
-B = Tuple[int, B]
-y: B
-reveal_type(y)
-class C:
-    x: D
+def fun_a(x: NestedA[T]) -> T: ...
+def fun_b(x: NestedB[T]) -> T: ...
+
+reveal_type(fun_a([1, 2, 3]))
+reveal_type(fun_b([1, 2, 3]))
+
+reveal_type(fun_a(xa))
+reveal_type(fun_b(xb))
 
-class D: ...
+xbf: NestedB[float]
+reveal_type([xb, xbf])
 [builtins fixtures/list.pyi]