Support for covariant and contravariant TypeVar's

lib-typing/2.7/typing.py

@@ -156,7 +156,7 @@ def NamedTuple(typename, fields):
 
 
 class TypeVar(object):
-    def __init__(self, name, *values):
+    def __init__(self, name, *values, **kwargs):
         self.name = name
         if not values:
             values = None
@@ -204,6 +204,7 @@ def overload(func):
 T = TypeVar('T')
 KT = TypeVar('KT')
 VT = TypeVar('VT')
+VT_co = TypeVar('VT_co', covariant=True)
 
 
 class SupportsInt(_Protocol):
@@ -231,7 +232,7 @@ class Sized(_Protocol):
     def __len__(self): pass
 
 
-class Container(_Protocol[T]):
+class Container(_Protocol[VT_co]):
     @abstractmethod
     def __contains__(self, x): pass
 
@@ -241,12 +242,12 @@ class Iterable(_Protocol[T]):
     def __iter__(self): pass
 
 
-class Iterator(Iterable[T], _Protocol[T]):
+class Iterator(Iterable[VT_co], _Protocol[VT_co]):
     @abstractmethod
     def next(self): pass
 
 
-class Sequence(Sized, Iterable[T], Container[T], Generic[T]):
+class Sequence(Sized, Iterable[VT_co], Container[VT_co], Generic[VT_co]):
     @abstractmethod
     def __getitem__(self, i): pass
 
@@ -267,7 +268,7 @@ def count(self, x): pass
     Sequence.register(t)
 
 
-class AbstractSet(Sized, Iterable[T], Generic[T]):
+class AbstractSet(Sized, Iterable[VT_co], Generic[VT_co]):
     @abstractmethod
     def __contains__(self, x): pass
     @abstractmethod

lib-typing/3.2/typing.py

@@ -1374,7 +1374,7 @@ class MutableSet(AbstractSet[T], extra=collections_abc.MutableSet):
     pass
 
 
-class Mapping(Sized, Iterable[KT_co], Container[KT_co], Generic[KT_co, VT_co],
+class Mapping(Sized, Iterable[KT], Container[KT], Generic[KT, VT_co],
               extra=collections_abc.Mapping):
     pass
 

mypy/checkmember.py

@@ -235,8 +235,8 @@ def add_class_tvars(t: Type, info: TypeInfo, is_classmethod: bool,
                     builtin_type: Callable[[str], Instance]) -> Type:
     if isinstance(t, CallableType):
         # TODO: Should we propagate type variable values?
-        vars = [TypeVarDef(n, i + 1, None, builtin_type('builtins.object'))
-                for i, n in enumerate(info.type_vars)]
+        vars = [TypeVarDef(n, i + 1, None, builtin_type('builtins.object'), tv.variance)
+                for (i, n), tv in zip(enumerate(info.type_vars), info.defn.type_vars)]
         arg_types = t.arg_types
         arg_kinds = t.arg_kinds
         arg_names = t.arg_names
@@ -290,7 +290,7 @@ def class_callable(init_type: CallableType, info: TypeInfo, type_type: Instance)
     """Create a type object type based on the signature of __init__."""
     variables = []  # type: List[TypeVarDef]
     for i, tvar in enumerate(info.defn.type_vars):
-        variables.append(TypeVarDef(tvar.name, i + 1, tvar.values, tvar.upper_bound))
+        variables.append(TypeVarDef(tvar.name, i + 1, tvar.values, tvar.upper_bound, tvar.variance))
 
     initvars = init_type.variables
     variables.extend(initvars)
@@ -319,7 +319,7 @@ def visit_type_var(self, t: TypeVarType) -> Type:
         if t.id < 0:
             return t
         else:
-            return TypeVarType(t.name, -t.id - self.num_func_tvars, t.values, t.upper_bound)
+            return TypeVarType(t.name, -t.id - self.num_func_tvars, t.values, t.upper_bound, t.variance)
 
     def translate_variables(self,
                             variables: List[TypeVarDef]) -> List[TypeVarDef]:
@@ -329,7 +329,7 @@ def translate_variables(self,
         for v in variables:
             if v.id > 0:
                 items.append(TypeVarDef(v.name, -v.id - self.num_func_tvars,
-                                        v.values, v.upper_bound))
+                                        v.values, v.upper_bound, v.variance))
             else:
                 items.append(v)
         return items

mypy/join.py

@@ -8,7 +8,7 @@
     UnionType, FunctionLike
 )
 from mypy.maptype import map_instance_to_supertype
-from mypy.subtypes import is_subtype, is_equivalent
+from mypy.subtypes import is_subtype, is_equivalent, is_subtype_ignoring_tvars
 
 
 def join_simple(declaration: Type, s: Type, t: Type) -> Type:
@@ -179,7 +179,7 @@ def join_instances(t: Instance, s: Instance) -> Type:
     if t.type == s.type:
         # Simplest case: join two types with the same base type (but
         # potentially different arguments).
-        if is_subtype(t, s):
+        if is_subtype(t, s) or is_subtype(s, t):
             # Compatible; combine type arguments.
             args = []  # type: List[Type]
             for i in range(len(t.args)):
@@ -188,7 +188,7 @@ def join_instances(t: Instance, s: Instance) -> Type:
         else:
             # Incompatible; return trivial result object.
             return object_from_instance(t)
-    elif t.type.bases and is_subtype(t, s):
+    elif t.type.bases and is_subtype_ignoring_tvars(t, s):
         return join_instances_via_supertype(t, s)
     else:
         # Now t is not a subtype of s, and t != s. Now s could be a subtype

mypy/meet.py

@@ -23,7 +23,7 @@ def meet_types(s: Type, t: Type) -> Type:
     return t.accept(TypeMeetVisitor(s))
 
 
-def meet_simple(s: Type, t: Type, default_right: bool = True) -> Type:
+def meet_simple(s: Type, t: Type, default_right: bool=True) -> Type:
     if s == t:
         return s
     if isinstance(s, UnionType):
@@ -131,7 +131,7 @@ def visit_instance(self, t: Instance) -> Type:
         if isinstance(self.s, Instance):
             si = cast(Instance, self.s)
             if t.type == si.type:
-                if is_subtype(t, self.s):
+                if is_subtype(t, self.s) or is_subtype(self.s, t):
                     # Combine type arguments. We could have used join below
                     # equivalently.
                     args = []  # type: List[Type]

mypy/nodes.py

@@ -1292,6 +1292,10 @@ def accept(self, visitor: NodeVisitor[T]) -> T:
         return visitor.visit_type_application(self)
 
 
+INVARIANT = 0  # type: int
+COVARIANT = 1  # type: int
+CONTRAVARIANT = 2  # type: int
+
 class TypeVarExpr(SymbolNode):
     """Type variable expression TypeVar(...)."""
 
@@ -1300,12 +1304,15 @@ class TypeVarExpr(SymbolNode):
     # Value restriction: only types in the list are valid as values. If the
     # list is empty, there is no restriction.
     values = None  # type: List[mypy.types.Type]
+    variance = INVARIANT
 
     def __init__(self, name: str, fullname: str,
-                 values: List['mypy.types.Type']) -> None:
+                 values: List['mypy.types.Type'],
+                 variance: int=INVARIANT) -> None:
         self._name = name
         self._fullname = fullname
         self.values = values
+        self.variance = variance
 
     def name(self) -> str:
         return self._name