Replace class/function distinction with plain/metavariable distinction

Fixes #603.

Author: rwbarton

mypy/checkexpr.py

@@ -4,7 +4,7 @@
 
 from mypy.types import (
     Type, AnyType, CallableType, Overloaded, NoneTyp, Void, TypeVarDef,
-    TupleType, Instance, TypeVarType, ErasedType, UnionType,
+    TupleType, Instance, TypeVarId, TypeVarType, ErasedType, UnionType,
     PartialType, DeletedType, UnboundType, UninhabitedType, TypeType
 )
 from mypy.nodes import (
@@ -22,7 +22,7 @@
 import mypy.checker
 from mypy import types
 from mypy.sametypes import is_same_type
-from mypy.erasetype import replace_func_type_vars
+from mypy.erasetype import replace_meta_vars
 from mypy.messages import MessageBuilder
 from mypy import messages
 from mypy.infer import infer_type_arguments, infer_function_type_arguments
@@ -34,6 +34,7 @@
 from mypy.semanal import self_type
 from mypy.constraints import get_actual_type
 from mypy.checkstrformat import StringFormatterChecker
+from mypy.expandtype import expand_type
 
 from mypy import experiments
 
@@ -234,6 +235,7 @@ def check_call(self, callee: Type, args: List[Node],
                 lambda i: self.accept(args[i]))
 
             if callee.is_generic():
+                callee = freshen_generic_callable(callee)
                 callee = self.infer_function_type_arguments_using_context(
                     callee, context)
                 callee = self.infer_function_type_arguments(
@@ -394,12 +396,12 @@ def infer_function_type_arguments_using_context(
         ctx = self.chk.type_context[-1]
         if not ctx:
             return callable
-        # The return type may have references to function type variables that
+        # The return type may have references to type metavariables that
         # we are inferring right now. We must consider them as indeterminate
         # and they are not potential results; thus we replace them with the
         # special ErasedType type. On the other hand, class type variables are
         # valid results.
-        erased_ctx = replace_func_type_vars(ctx, ErasedType())
+        erased_ctx = replace_meta_vars(ctx, ErasedType())
         ret_type = callable.ret_type
         if isinstance(ret_type, TypeVarType):
             if ret_type.values or (not isinstance(ctx, Instance) or
@@ -1362,7 +1364,7 @@ def infer_lambda_type_using_context(self, e: FuncExpr) -> CallableType:
         # they must be considered as indeterminate. We use ErasedType since it
         # does not affect type inference results (it is for purposes like this
         # only).
-        ctx = replace_func_type_vars(ctx, ErasedType())
+        ctx = replace_meta_vars(ctx, ErasedType())
 
         callable_ctx = cast(CallableType, ctx)
 
@@ -1779,3 +1781,14 @@ def overload_arg_similarity(actual: Type, formal: Type) -> int:
         return 2
     # Fall back to a conservative equality check for the remaining kinds of type.
     return 2 if is_same_type(erasetype.erase_type(actual), erasetype.erase_type(formal)) else 0
+
+
+def freshen_generic_callable(callee: CallableType) -> CallableType:
+    tvdefs = []
+    tvmap = {}  # type: Dict[TypeVarId, Type]
+    for v in callee.variables:
+        tvdef = TypeVarDef.new_unification_variable(v)
+        tvdefs.append(tvdef)
+        tvmap[v.id] = TypeVarType(tvdef)
+
+    return cast(CallableType, expand_type(callee, tvmap)).copy_modified(variables=tvdefs)

mypy/erasetype.py

@@ -116,9 +116,9 @@ def erase_id(id: TypeVarId) -> bool:
     return t.accept(TypeVarEraser(erase_id, AnyType()))
 
 
-def replace_func_type_vars(t: Type, target_type: Type) -> Type:
-    """Replace function type variables in a type with the target type."""
-    return t.accept(TypeVarEraser(lambda id: id.is_func_var(), target_type))
+def replace_meta_vars(t: Type, target_type: Type) -> Type:
+    """Replace unification variables in a type with the target type."""
+    return t.accept(TypeVarEraser(lambda id: id.is_meta_var(), target_type))
 
 
 class TypeVarEraser(TypeTranslator):

mypy/types.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 from typing import (
-    Any, TypeVar, Dict, List, Tuple, cast, Generic, Set, Sequence, Optional
+    Any, TypeVar, Dict, List, Tuple, cast, Generic, Set, Sequence, Optional, Union
 )
 
 import mypy.nodes
@@ -49,32 +49,43 @@ def deserialize(cls, data: JsonDict) -> 'Type':
 
 class TypeVarId:
     # 1, 2, ... for type-related, -1, ... for function-related
-
     raw_id = 0  # type: int
 
-    def __init__(self, raw_id: int) -> None:
+    # Level of the variable in type inference. Currently either 0 for
+    # declared types, or 1 for type inference unification variables.
+    meta_level = 0  # type: int
+
+    # Used for allocating fresh ids
+    next_raw_id = 1  # type: int
+
+    def __init__(self, raw_id: int, meta_level: int = 0) -> None:
         self.raw_id = raw_id
+        self.meta_level = meta_level
+
+    @staticmethod
+    def new(meta_level: int) -> 'TypeVarId':
+        raw_id = TypeVarId.next_raw_id
+        TypeVarId.next_raw_id += 1
+        return TypeVarId(raw_id, meta_level)
 
     def __repr__(self) -> str:
         return self.raw_id.__repr__()
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, TypeVarId):
-            return self.raw_id == other.raw_id
+            return (self.raw_id == other.raw_id and
+                    self.meta_level == other.meta_level)
         else:
             return False
 
     def __ne__(self, other: object) -> bool:
         return not (self == other)
 
     def __hash__(self) -> int:
-        return hash(self.raw_id)
-
-    def is_class_var(self) -> bool:
-        return self.raw_id > 0
+        return hash((self.raw_id, self.meta_level))
 
-    def is_func_var(self) -> bool:
-        return self.raw_id < 0
+    def is_meta_var(self) -> bool:
+        return self.meta_level > 0
 
 
 class TypeVarDef(mypy.nodes.Context):
@@ -87,15 +98,23 @@ class TypeVarDef(mypy.nodes.Context):
     variance = INVARIANT  # type: int
     line = 0
 
-    def __init__(self, name: str, raw_id: int, values: Optional[List[Type]],
+    def __init__(self, name: str, id: Union[TypeVarId, int], values: Optional[List[Type]],
                  upper_bound: Type, variance: int = INVARIANT, line: int = -1) -> None:
         self.name = name
-        self.id = TypeVarId(raw_id)
+        if isinstance(id, int):
+            id = TypeVarId(id)
+        self.id = id
         self.values = values
         self.upper_bound = upper_bound
         self.variance = variance
         self.line = line
 
+    @staticmethod
+    def new_unification_variable(old: 'TypeVarDef') -> 'TypeVarDef':
+        new_id = TypeVarId.new(meta_level=1)
+        return TypeVarDef(old.name, new_id, old.values,
+                          old.upper_bound, old.variance, old.line)
+
     def get_line(self) -> int:
         return self.line
 
@@ -108,6 +127,7 @@ def __repr__(self) -> str:
             return self.name
 
     def serialize(self) -> JsonDict:
+        assert not self.id.is_meta_var()
         return {'.class': 'TypeVarDef',
                 'name': self.name,
                 'id': self.id.raw_id,
@@ -424,6 +444,7 @@ def erase_to_union_or_bound(self) -> Type:
             return self.upper_bound
 
     def serialize(self) -> JsonDict:
+        assert not self.id.is_meta_var()
         return {'.class': 'TypeVarType',
                 'name': self.name,
                 'id': self.id.raw_id,

test-data/unit/check-inference-context.test

@@ -748,3 +748,11 @@ def f2(iterable: Iterable[Tuple[str, Any]], **kw: Any) -> None:
     pass
 [builtins fixtures/dict.py]
 [out]
+
+[case testInferenceInGenericFunction]
+from typing import TypeVar, List
+T = TypeVar('T')
+def f(a: T) -> None:
+    l = []  # type: List[T]
+    l.append(a)
+[builtins fixtures/list.py]