Start work on inferring via partial types

This is still very incomplete.

Author: JukkaL

mypy/checker.py

@@ -29,7 +29,7 @@
 from mypy.types import (
     Type, AnyType, CallableType, Void, FunctionLike, Overloaded, TupleType,
     Instance, NoneTyp, UnboundType, ErrorType, TypeTranslator, strip_type,
-    UnionType, TypeVarType,
+    UnionType, TypeVarType, PartialType
 )
 from mypy.sametypes import is_same_type
 from mypy.messages import MessageBuilder
@@ -332,7 +332,8 @@ class TypeChecker(NodeVisitor[Type]):
     breaking_out = False
     # Do weak type checking in this file
     weak_opts = set()        # type: Set[str]
-
+    # Stack of collections of variables with partial types.
+    partial_types = None  # type: List[Set[Var]]
     globals = None  # type: SymbolTable
     locals = None  # type: SymbolTable
     modules = None  # type: Dict[str, MypyFile]
@@ -358,6 +359,7 @@ def __init__(self, errors: Errors, modules: Dict[str, MypyFile],
         self.dynamic_funcs = []
         self.function_stack = []
         self.weak_opts = set()  # type: Set[str]
+        self.partial_types = []
 
     def visit_file(self, file_node: MypyFile, path: str) -> None:
         """Type check a mypy file with the given path."""
@@ -367,10 +369,12 @@ def visit_file(self, file_node: MypyFile, path: str) -> None:
         self.globals = file_node.names
         self.locals = None
         self.weak_opts = file_node.weak_opts
+        self.enter_partial_types()
 
         for d in file_node.defs:
             self.accept(d)
 
+        self.leave_partial_types()
         self.errors.set_ignored_lines(set())
 
     def accept(self, node: Node, type_context: Type = None) -> Type:
@@ -1238,10 +1242,13 @@ def infer_variable_type(self, name: Var, lvalue: Node,
             self.check_not_void(init_type, context)
             self.set_inference_error_fallback_type(name, lvalue, init_type, context)
         elif not self.is_valid_inferred_type(init_type):
-            # We cannot use the type of the initialization expression for type
-            # inference (it's not specific enough).
-            self.fail(messages.NEED_ANNOTATION_FOR_VAR, context)
-            self.set_inference_error_fallback_type(name, lvalue, init_type, context)
+            # We cannot use the type of the initialization expression for full type
+            # inference (it's not specific enough), but we might be able to give
+            # partial type which will be made more specific later. A partial type
+            # gets generated in assignment like 'x = []' where item type is not known.
+            if not self.infer_partial_type(name, lvalue, init_type):
+                self.fail(messages.NEED_ANNOTATION_FOR_VAR, context)
+                self.set_inference_error_fallback_type(name, lvalue, init_type, context)
         else:
             # Infer type of the target.
 
@@ -1250,6 +1257,16 @@ def infer_variable_type(self, name: Var, lvalue: Node,
 
             self.set_inferred_type(name, lvalue, init_type)
 
+    def infer_partial_type(self, name: Var, lvalue: Node, init_type: Type) -> bool:
+        if not isinstance(init_type, Instance):
+            return False
+        if init_type.type.fullname() == 'builtins.list' and isinstance(init_type.args[0], NoneTyp):
+            partial_type = PartialType(init_type.type, name)
+            self.set_inferred_type(name, lvalue, partial_type)
+            self.partial_types[-1].add(name)
+            return True
+        return False
+
     def set_inferred_type(self, var: Var, lvalue: Node, type: Type) -> None:
         """Store inferred variable type.
 
@@ -2032,6 +2049,12 @@ def enter(self) -> None:
     def leave(self) -> None:
         self.locals = None
 
+    def enter_partial_types(self) -> None:
+        self.partial_types.append(set())
+
+    def leave_partial_types(self) -> None:
+        self.partial_types.pop()
+
     def is_within_function(self) -> bool:
         """Are we currently type checking within a function?
 

mypy/checkexpr.py

@@ -14,7 +14,7 @@
     ListComprehension, GeneratorExpr, SetExpr, MypyFile, Decorator,
     ConditionalExpr, ComparisonExpr, TempNode, SetComprehension,
     DictionaryComprehension, ComplexExpr, EllipsisExpr, LITERAL_TYPE,
-    TypeAliasExpr, YieldExpr, BackquoteExpr
+    TypeAliasExpr, YieldExpr, BackquoteExpr, ARG_POS
 )
 from mypy.errors import Errors
 from mypy.nodes import function_type
@@ -110,13 +110,28 @@ def visit_call_expr(self, e: CallExpr) -> Type:
         if e.analyzed:
             # It's really a special form that only looks like a call.
             return self.accept(e.analyzed)
+        self.try_infer_partial_type(e)
         self.accept(e.callee)
         # Access callee type directly, since accept may return the Any type
         # even if the type is known (in a dynamically typed function). This
         # way we get a more precise callee in dynamically typed functions.
         callee_type = self.chk.type_map[e.callee]
         return self.check_call_expr_with_callee_type(callee_type, e)
 
+    def try_infer_partial_type(self, e: CallExpr) -> None:
+        partial_types = self.chk.partial_types[-1]
+        if not partial_types:
+            # Fast path leave -- no partial types in the current scope.
+            return
+        if isinstance(e.callee, MemberExpr) and isinstance(e.callee.expr, RefExpr):
+            var = e.callee.expr.node
+            if var in partial_types and e.callee.name == 'append' and e.arg_kinds == [ARG_POS]:
+                # We can infer a full type for a partial List type.
+                item_type = self.accept(e.args[0])
+                var.type = self.chk.named_generic_type('builtins.list', [item_type])
+                partial_types.remove(var)
+        return
+
     def check_call_expr_with_callee_type(self, callee_type: Type,
                                          e: CallExpr) -> Type:
         """Type check call expression.

mypy/checkmember.py

@@ -4,7 +4,7 @@
 
 from mypy.types import (
     Type, Instance, AnyType, TupleType, CallableType, FunctionLike, TypeVarDef,
-    Overloaded, TypeVarType, TypeTranslator, UnionType
+    Overloaded, TypeVarType, TypeTranslator, UnionType, PartialType
 )
 from mypy.nodes import TypeInfo, FuncBase, Var, FuncDef, SymbolNode, Context
 from mypy.nodes import ARG_POS, function_type, Decorator, OverloadedFuncDef

mypy/expandtype.py

@@ -2,7 +2,8 @@
 
 from mypy.types import (
     Type, Instance, CallableType, TypeVisitor, UnboundType, ErrorType, AnyType,
-    Void, NoneTyp, TypeVarType, Overloaded, TupleType, UnionType, ErasedType, TypeList
+    Void, NoneTyp, TypeVarType, Overloaded, TupleType, UnionType, ErasedType, TypeList,
+    PartialType
 )
 
 
@@ -92,6 +93,9 @@ def visit_tuple_type(self, t: TupleType) -> Type:
     def visit_union_type(self, t: UnionType) -> Type:
         return UnionType(self.expand_types(t.items), t.line)
 
+    def visit_partial_type(self, t: PartialType) -> Type:
+        return t
+
     def expand_types(self, types: List[Type]) -> List[Type]:
         a = []  # type: List[Type]
         for t in types:

mypy/sametypes.py

@@ -2,7 +2,7 @@
 
 from mypy.types import (
     Type, UnboundType, ErrorType, AnyType, NoneTyp, Void, TupleType, UnionType, CallableType,
-    TypeVarType, Instance, TypeVisitor, ErasedType, TypeList, Overloaded
+    TypeVarType, Instance, TypeVisitor, ErasedType, TypeList, Overloaded, PartialType
 )
 
 
@@ -97,3 +97,8 @@ def visit_overloaded(self, left: Overloaded) -> bool:
             return is_same_types(left.items(), self.right.items())
         else:
             return False
+
+    def visit_partial_type(self, left: PartialType) -> bool:
+        # A partial type is not fully defined, so the result is indeterminate. We shouldn't
+        # get here.
+        raise RuntimeError

mypy/subtypes.py

@@ -3,7 +3,7 @@
 from mypy.types import (
     Type, AnyType, UnboundType, TypeVisitor, ErrorType, Void, NoneTyp,
     Instance, TypeVarType, CallableType, TupleType, UnionType, Overloaded, ErasedType, TypeList,
-    is_named_instance
+    PartialType, is_named_instance
 )
 import mypy.applytype
 import mypy.constraints
@@ -184,6 +184,10 @@ def visit_union_type(self, left: UnionType) -> bool:
         return all(is_subtype(item, self.right, self.check_type_parameter)
                    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.
+        raise RuntimeError
+
 
 def is_callable_subtype(left: CallableType, right: CallableType,
                         ignore_return: bool = False) -> bool:

mypy/test/data/check-inference.test

@@ -1012,3 +1012,15 @@ a = x1
 a = x2
 a = x3 # E: Incompatible types in assignment (expression has type List[B], variable has type List[A])
 [builtins fixtures/list.py]
+
+
+-- Inferring type of variable when initialized to an empty collection
+-- ------------------------------------------------------------------
+
+
+[case testInferListInitializedToEmpty]
+a = []
+a.append(1)
+a.append('')  # E: Argument 1 to "append" of "list" has incompatible type "str"; expected "int"
+[builtins fixtures/list.py]
+[out]

mypy/test/data/fixtures/list.py

@@ -14,6 +14,7 @@ class list(Iterable[T], Generic[T]):
     def __iter__(self) -> Iterator[T]: pass
     def __mul__(self, x: int) -> list[T]: pass
     def __getitem__(self, x: int) -> T: pass
+    def append(self, x: T) -> None: pass
 
 class tuple: pass
 class function: pass

mypy/typeanal.py

@@ -4,7 +4,7 @@
 
 from mypy.types import (
     Type, UnboundType, TypeVarType, TupleType, UnionType, Instance, AnyType, CallableType,
-    Void, NoneTyp, TypeList, TypeVarDef, TypeVisitor, StarType, EllipsisType
+    Void, NoneTyp, TypeList, TypeVarDef, TypeVisitor, StarType, PartialType, EllipsisType
 )
 from mypy.nodes import (
     GDEF, TYPE_ALIAS, TypeInfo, Context, SymbolTableNode, BOUND_TVAR, TypeVarExpr, Var, Node,
@@ -193,6 +193,9 @@ def visit_star_type(self, t: StarType) -> Type:
     def visit_union_type(self, t: UnionType) -> Type:
         return UnionType(self.anal_array(t.items), t.line)
 
+    def visit_partial_type(self, t: PartialType) -> Type:
+        assert False, "Internal error: Unexpected partial type"
+
     def visit_ellipsis_type(self, t: EllipsisType) -> Type:
         self.fail("Unexpected '...'", t)
         return AnyType()
@@ -355,3 +358,6 @@ def visit_type_list(self, t: TypeList) -> None:
 
     def visit_type_var(self, t: TypeVarType) -> None:
         pass
+
+    def visit_partial_type(self, t: PartialType) -> None:
+        pass

mypy/types.py

@@ -501,6 +501,26 @@ def has_readable_member(self, name: str) -> bool:
                    for x in self.items)
 
 
+class PartialType(Type):
+    """Type such as List[?] where type arguments are unknown.
+
+    These are used for inferring types in multiphase initialization such as this:
+
+      x = []       # x gets a partial type List[?], as item type is unknown
+      x.append(1)  # partial type gets replaced with normal type List[int]
+    """
+
+    type = None  # type: mypy.nodes.TypeInfo
+    var = None  # type: mypy.nodes.Var
+
+    def __init__(self, type: 'mypy.nodes.TypeInfo', var: 'mypy.nodes.Var') -> None:
+        self.type = type
+        self.var = var
+
+    def accept(self, visitor: 'TypeVisitor[T]') -> T:
+        return visitor.visit_partial_type(self)
+
+
 class EllipsisType(Type):
     """The type ... (ellipsis).
 
@@ -581,6 +601,10 @@ def visit_star_type(self, t: StarType) -> T:
     def visit_union_type(self, t: UnionType) -> T:
         pass
 
+    @abstractmethod
+    def visit_partial_type(self, t: PartialType) -> T:
+        pass
+
     def visit_ellipsis_type(self, t: EllipsisType) -> T:
         raise self._notimplemented_helper()
 
@@ -619,6 +643,9 @@ def visit_instance(self, t: Instance) -> Type:
     def visit_type_var(self, t: TypeVarType) -> Type:
         return t
 
+    def visit_partial_type(self, t: PartialType) -> Type:
+        return t
+
     def visit_callable_type(self, t: CallableType) -> Type:
         return t.copy_modified(arg_types=self.translate_types(t.arg_types),
                                ret_type=t.ret_type.accept(self),
@@ -773,6 +800,9 @@ def visit_union_type(self, t):
         s = self.list_str(t.items)
         return 'Union[{}]'.format(s)
 
+    def visit_partial_type(self, t: PartialType) -> str:
+        return '{}[{}]'.format(t.info.name(), ', '.join(['?'] * len(t.info.type_vars)))
+
     def visit_ellipsis_type(self, t):
         return '...'
 
@@ -840,6 +870,9 @@ def visit_erased_type(self, t: ErasedType) -> bool:
     def visit_type_var(self, t: TypeVarType) -> bool:
         return self.default
 
+    def visit_partial_type(self, t: PartialType) -> bool:
+        return self.default
+
     def visit_instance(self, t: Instance) -> bool:
         return self.query_types(t.args)