WIP: Towards supporting Type[T].

The TypeC tests no pass except for one ProUser* that should be ProUser; but something's seriously wrong because many other tests now fail.
python · JukkaL · Jun 8, 2016 · May 18, 2016 · May 20, 2016 · May 20, 2016
commit 371e42545fa188d4a94609f871623fb1e8c3391a
diff --git a/mypy/applytype.py b/mypy/applytype.py
@@ -43,6 +43,10 @@ def apply_generic_arguments(callable: CallableType, types: List[Type],
             else:
                 msg.incompatible_typevar_value(callable, i + 1, type, context)
 
+        # Translate constructor fn back to class.
+        if isinstance(type, CallableType) and type.is_type_obj():
+            types[i] = type = type.ret_type
+
         upper_bound = callable.variables[i].upper_bound
         if type and not mypy.subtypes.satisfies_upper_bound(type, upper_bound):
             msg.incompatible_typevar_value(callable, i + 1, type, context)

diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -278,20 +278,35 @@ def check_call(self, callee: Type, args: List[Node],
             return self.check_call(callee.upper_bound, args, arg_kinds, context, arg_names,
                                    callable_node, arg_messages)
         elif isinstance(callee, TypeType):
-            item = self.analyze_type_type(callee.item, context)
+            item = self.analyze_type_type_callee(callee.item, context)
             return self.check_call(item, args, arg_kinds, context, arg_names,
                                    callable_node, arg_messages)
         else:
             return self.msg.not_callable(callee, context), AnyType()
 
-    def analyze_type_type(self, arg: Type, context: Context) -> Type:
-        """Given the arg from (x: Type[arg]), return the type for x."""
-        if isinstance(arg, AnyType):
+    # What's a good name for this method?
+    def analyze_type_type_callee(self, item: Type, context: Context) -> Type:
+        """Analyze the callee X in X(...) where X is Type[item].
+
+        Return a Y that we can pass to check_call(Y, ...).
+        """
+        if isinstance(item, AnyType):
             return AnyType()
-        if isinstance(arg, Instance):
-            return type_object_type(arg.type, self.named_type)
        if isinstance(arg, UnionType):
-            return UnionType([self.analyze_type_type(item, context) for item in arg.items], arg.line)
+        if isinstance(item, Instance):
+            return type_object_type(item.type, self.named_type)
+        if isinstance(item, UnionType):
+            return UnionType([self.analyze_type_type_callee(item, context)
+                              for item in item.items], item.line)
+        if isinstance(item, TypeVarType):
+            # Pretend we're calling the typevar's upper bound,
+            # i.e. its constructor (a poor approximation for reality,
+            # but better than AnyType...), but replace the return type
+            # with typevar.
+            callee = self.analyze_type_type_callee(item.upper_bound, context)
+            if isinstance(callee, CallableType):
+                callee = callee.copy_modified(ret_type=item)
+            return callee
+    
         # XXX Do we need to handle other forms?
         # XXX Make a nicely formatted error message.
         self.msg.fail("XXX Bad arg to Type[]", context)

diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -348,14 +348,14 @@ def infer_against_any(self, types: List[Type]) -> List[Constraint]:
             res.extend(infer_constraints(t, AnyType(), self.direction))
         return res
 
-    def visit_overloaded(self, type: Overloaded) -> List[Constraint]:
+    def visit_overloaded(self, template: Overloaded) -> List[Constraint]:
         res = []  # type: List[Constraint]
-        for t in type.items():
+        for t in template.items():
             res.extend(infer_constraints(t, self.actual, self.direction))
         return res
 
-    def visit_type_type(self, type: TypeType) -> List[Constraint]:
-        return []  # XXX What else to do?
+    def visit_type_type(self, template: TypeType) -> List[Constraint]:
+        return infer_constraints(template.item, self.actual, self.direction)
 
 
 def neg_op(op: int) -> int:

diff --git a/mypy/expandtype.py b/mypy/expandtype.py
@@ -95,7 +95,8 @@ def visit_partial_type(self, t: PartialType) -> Type:
         return t
 
     def visit_type_type(self, t: TypeType) -> Type:
-        return TypeType(t.item.accept(self))
+        item = t.item.accept(self)
+        return TypeType(item)
 
     def expand_types(self, types: List[Type]) -> List[Type]:
         a = []  # type: List[Type]

diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -144,10 +144,11 @@ def visit_callable_type(self, left: CallableType) -> bool:
             return all(is_subtype(left, item, self.check_type_parameter)
                        for item in right.items())
         elif isinstance(right, Instance):
+            if left.is_type_obj():
+                return is_subtype(left.ret_type, right)
             return is_subtype(left.fallback, right)
         elif isinstance(right, TypeType):
-            # XXX Or left.is_type_obj()?
-            return left.is_concrete_type_obj() and is_subtype(left.ret_type, right.item)
+            return left.is_type_obj() and is_subtype(left.ret_type, right.item)
         else:
             return False
 
@@ -204,8 +205,7 @@ def visit_overloaded(self, left: Overloaded) -> bool:
         elif isinstance(right, TypeType):
             # All the items must have the same type object status, so
             # it's sufficient to query only (any) one of them.
-            # XXX Or left.is_type_obj()?
-            return left.is_concrete_type_obj() and is_subtype(left.items()[0].ret_type, right.item)
+            return left.is_type_obj() and is_subtype(left.items()[0].ret_type, right.item)
         else:
             return False
 
@@ -222,8 +222,7 @@ def visit_type_type(self, left: TypeType) -> bool:
         if isinstance(right, TypeType):
             return is_subtype(left.item, right.item)
         if isinstance(right, CallableType):
-            # XXX Or is_type_obj()?
-            return right.is_concrete_type_obj() and is_subtype(left.item, right.ret_type)
+            return right.is_type_obj() and is_subtype(left.item, right.ret_type)
         # XXX Others? Union, Any, TypeVar
         return False
 

diff --git a/mypy/test/data/check-classes.test b/mypy/test/data/check-classes.test
@@ -1443,11 +1443,16 @@ class ProUser(User): pass
 class BasicUser(User): pass
 U = TypeVar('U', bound=User)
 def new_user(user_class: Type[U]) -> U:
-    return user_class()
-reveal_type(new_user(ProUser))
-[out]
+    user = user_class()
+    reveal_type(user)
+    return user
+pro_user = new_user(ProUser)
+reveal_type(pro_user)
+[out]
+main: note: In function "new_user":
+main:8: error: Revealed type is 'U`-1'
 main: note: At top level:
-main:8: error: Revealed type is '__main__.ProUser'
+main:11: error: Revealed type is '__main__.ProUser'
 
 [case testTypeUsingTypeCCovariance]
 from typing import Type, TypeVar

diff --git a/mypy/types.py b/mypy/types.py
@@ -967,6 +967,9 @@ def visit_overloaded(self, t: Overloaded) -> Type:
                 raise RuntimeError('CallableType expectected, but got {}'.format(type(new)))
         return Overloaded(items=items)
 
+    def visit_type_type(self, t: TypeType) -> Type:
+        return t
+
 
 class TypeStrVisitor(TypeVisitor[str]):
     """Visitor for pretty-printing types into strings.