Some cleanup and fixup (not done).

- Add tests for Type[Any] and plain Type, and fix a bug that found.
- Respond to easy review feedback (adding comments/docstrings mostly).

Author: Guido van Rossum

mypy/checkexpr.py

@@ -303,11 +303,14 @@ def analyze_type_type_callee(self, item: Type, context: Context) -> Type:
             # but better than AnyType...), but replace the return type
             # with typevar.
             callee = self.analyze_type_type_callee(item.upper_bound, context)
+            # XXX What to do for a generic class?  Maybe just reject.
             if isinstance(callee, CallableType):
                 callee = callee.copy_modified(ret_type=item)
+            # XXX What to do for Overloaded?
             return callee
 
         # XXX Do we need to handle other forms?
+        # XXX Or maybe those should be rejected during semantic analysis.
         # XXX Make a nicely formatted error message.
         self.msg.fail("XXX Bad arg to Type[]", context)
         return AnyType()

mypy/constraints.py

@@ -357,8 +357,10 @@ def visit_overloaded(self, template: Overloaded) -> List[Constraint]:
     def visit_type_type(self, template: TypeType) -> List[Constraint]:
         if isinstance(self.actual, CallableType) and self.actual.is_type_obj():
             return infer_constraints(template.item, self.actual.ret_type, self.direction)
-        print("XXX Don't know what to do with type %s for template %s" % (self.actual, template))
-        return []  # XXX ???
+        elif isinstance(self.actual, TypeType):
+            return infer_constraints(template.item, self.actual.item, self.direction)
+        else:
+            return []
 
 
 def neg_op(op: int) -> int:

mypy/erasetype.py

@@ -3,7 +3,7 @@
 from mypy.types import (
     Type, TypeVisitor, UnboundType, ErrorType, AnyType, Void, NoneTyp,
     Instance, TypeVarType, CallableType, TupleType, UnionType, Overloaded, ErasedType,
-    PartialType, DeletedType, TypeTranslator, TypeList
+    PartialType, DeletedType, TypeTranslator, TypeList, TypeType
 )
 
 
@@ -72,6 +72,10 @@ def visit_tuple_type(self, t: TupleType) -> Type:
     def visit_union_type(self, t: UnionType) -> Type:
         return AnyType()        # XXX: return underlying type if only one?
 
+    def visit_type_type(self, t: TypeType) -> Type:
+        # XXX No idea if this makes much sense.
+        return TypeType(AnyType(), line=t.line)
+
 
 def erase_generic_types(t: Type) -> Type:
     """Remove generic type arguments and type variables from a type.

mypy/expandtype.py

@@ -95,6 +95,9 @@ def visit_partial_type(self, t: PartialType) -> Type:
         return t
 
     def visit_type_type(self, t: TypeType) -> Type:
+        # TODO: Verify that the new item type is valid (instance or
+        # union of instances or Any).  Sadly we can't report errors
+        # here yet.
         item = t.item.accept(self)
         return TypeType(item)
 

mypy/join.py

@@ -5,7 +5,8 @@
 from mypy.types import (
     Type, AnyType, NoneTyp, Void, TypeVisitor, Instance, UnboundType,
     ErrorType, TypeVarType, CallableType, TupleType, ErasedType, TypeList,
-    UnionType, FunctionLike, Overloaded, PartialType, DeletedType
+    UnionType, FunctionLike, Overloaded, PartialType, DeletedType,
+    TypeType
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy.subtypes import is_subtype, is_equivalent, is_subtype_ignoring_tvars
@@ -204,6 +205,13 @@ def visit_partial_type(self, t: PartialType) -> Type:
         # never get here.
         assert False, "Internal error"
 
+    def visit_type_type(self, t: TypeType) -> Type:
+        if isinstance(self.s, TypeType):
+            return TypeType(self.join(t.item, self.s.item), line=t.line)
+        else:
+            # XXX Should at least try to join Type[] with type
+            return AnyType()
+
     def join(self, s: Type, t: Type) -> Type:
         return join_types(s, t)
 

mypy/meet.py

@@ -3,7 +3,8 @@
 from mypy.join import is_similar_callables, combine_similar_callables
 from mypy.types import (
     Type, AnyType, TypeVisitor, UnboundType, Void, ErrorType, NoneTyp, TypeVarType,
-    Instance, CallableType, TupleType, ErasedType, TypeList, UnionType, PartialType, DeletedType
+    Instance, CallableType, TupleType, ErasedType, TypeList,
+    UnionType, PartialType, DeletedType, TypeType
 )
 from mypy.subtypes import is_subtype
 from mypy.nodes import TypeInfo
@@ -207,6 +208,13 @@ def visit_partial_type(self, t: PartialType) -> Type:
         # We can't determine the meet of partial types. We should never get here.
         assert False, 'Internal error'
 
+    def visit_type_type(self, t: TypeType) -> Type:
+        if isinstance(self.s, TypeType):
+            return TypeType(self.meet(t.item, self.s.item), line=t.line)
+        else:
+            # XXX Other cases, e.g. type <--> Type[]?
+            return NoneTyp()
+
     def meet(self, s, t):
         return meet_types(s, t)
 

mypy/sametypes.py

@@ -2,7 +2,8 @@
 
 from mypy.types import (
     Type, UnboundType, ErrorType, AnyType, NoneTyp, Void, TupleType, UnionType, CallableType,
-    TypeVarType, Instance, TypeVisitor, ErasedType, TypeList, Overloaded, PartialType, DeletedType
+    TypeVarType, Instance, TypeVisitor, ErasedType, TypeList,
+    Overloaded, PartialType, DeletedType, TypeType
 )
 
 
@@ -121,3 +122,9 @@ 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
+
+    def visit_type_type(self, left: TypeType) -> bool:
+        if isinstance(self.right, TypeType):
+            return is_same_type(left.item, self.right.item)
+        else:
+            return False

mypy/subtypes.py

@@ -146,6 +146,7 @@ def visit_callable_type(self, left: CallableType) -> bool:
         elif isinstance(right, Instance):
             return is_subtype(left.fallback, right)
         elif isinstance(right, TypeType):
+            # This is unsound, we don't check the __init__ signature.
             return left.is_type_obj() and is_subtype(left.ret_type, right.item)
         else:
             return False
@@ -203,6 +204,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.
+            # This is unsound, we don't check the __init__ signature.
             return left.is_type_obj() and is_subtype(left.items()[0].ret_type, right.item)
         else:
             return False
@@ -220,6 +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):
+            # This is unsound, we don't check the __init__ signature.
             return right.is_type_obj() and is_subtype(left.item, right.ret_type)
         # XXX Others? Union, Any, TypeVar
         return False

mypy/test/data/check-classes.test

@@ -1427,38 +1427,47 @@ C(arg=0)
 from typing import Type
 class User: pass
 class ProUser(User): pass
-class BasicUser(User): pass
 def new_user(user_class: Type[User]) -> User:
     return user_class()
-reveal_type(new_user(User))
-reveal_type(new_user(ProUser))
+reveal_type(new_user(User))  # E: Revealed type is '__main__.User'
+reveal_type(new_user(ProUser))  # E: Revealed type is '__main__.User'
 [out]
-main:7: error: Revealed type is '__main__.User'
-main:8: error: Revealed type is '__main__.User'
 
 [case testTypeUsingTypeCTypeVar]
 from typing import Type, TypeVar
 class User: pass
 class ProUser(User): pass
-class BasicUser(User): pass
 U = TypeVar('U', bound=User)
 def new_user(user_class: Type[U]) -> U:
     user = user_class()
     reveal_type(user)
     return user
 pro_user = new_user(ProUser)
-reveal_type(pro_user)  # XXX Why is this ProUser*?
+reveal_type(pro_user)
 [out]
 main: note: In function "new_user":
-main:8: error: Revealed type is 'U`-1'
+main:7: error: Revealed type is 'U`-1'
 main: note: At top level:
-main:11: error: Revealed type is '__main__.ProUser*'
+main:10: error: Revealed type is '__main__.ProUser*'
+
+[case testTypeUsingTypeCTwoTypeVars]
+from typing import Type, TypeVar
+class User: pass
+class ProUser(User): pass
+class WizUser(ProUser): pass
+U = TypeVar('U', bound=User)
+def new_user(u_c: Type[U]) -> U: pass
+P = TypeVar('P', bound=ProUser)
+def new_pro(pro_c: Type[P]) -> P:
+    return new_user(pro_c)
+wiz = new_pro(WizUser)
+reveal_type(wiz)  # E: Revealed type is '__main__.WizUser*'
+[out]
 
 [case testTypeUsingTypeCCovariance]
 from typing import Type, TypeVar
 class User: pass
 class ProUser(User): pass
-class BasicUser(User): pass
 def new_user(user_class: Type[User]) -> User:
     return user_class()
 def new_pro_user(user_class: Type[ProUser]):
@@ -1471,10 +1480,9 @@ class User: pass
 def new_user(user_class: Type[User]):
     return user_class()
 def foo(arg: Type[int]):
-    new_user(arg)
+    new_user(arg)  # E: Argument 1 to "new_user" has incompatible type Type[int]; expected Type[User]
 [out]
 main: note: In function "foo":
-main:6: error: Argument 1 to "new_user" has incompatible type Type[int]; expected Type[User]
 
 [case testTypeUsingTypeCUnionOverload]
 from typing import Type, Union, overload
@@ -1489,3 +1497,23 @@ def bar(o: Type[Union[X, Y]]): pass
 bar(X)
 bar(Y)
 [out]
+
+[case testTypeUsingTypeCTypeAny]
+from typing import Type, Any
+def foo(arg: Type[Any]):
+    x = arg()
+    reveal_type(x)  # E: Revealed type is 'Any'
+class X: pass
+foo(X)
+[out]
+main: note: In function "foo":
+
+[case testTypeUsingTypeCTypeNoArg]
+from typing import Type
+def foo(arg: Type):
+    x = arg()
+    reveal_type(x)  # E: Revealed type is 'Any'
+class X: pass
+foo(X)
+[out]
+main: note: In function "foo":

mypy/typeanal.py

@@ -115,11 +115,13 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
             elif fullname == 'typing.Callable':
                 return self.analyze_callable_type(t)
             elif fullname == 'typing.Type':
+                if len(t.args) == 0:
+                    return TypeType(AnyType(), line=t.line)
                 if len(t.args) != 1:
                     self.fail('Type[...] must have exactly one type argument', t)
                 items = self.anal_array(t.args)
                 item = items[0]
-                return TypeType(item, t.line)
+                return TypeType(item, line=t.line)
             elif sym.kind == TYPE_ALIAS:
                 # TODO: Generic type aliases.
                 return sym.type_override
@@ -214,7 +216,7 @@ def visit_ellipsis_type(self, t: EllipsisType) -> Type:
         return AnyType()
 
     def visit_type_type(self, t: TypeType) -> Type:
-        return TypeType(t.accept(self), t.line)
+        return TypeType(t.accept(self), line=t.line)
 
     def analyze_callable_type(self, t: UnboundType) -> Type:
         fallback = self.builtin_type('builtins.function')

mypy/types.py

@@ -789,11 +789,34 @@ class TypeType(Type):
 
     This annotates variables that are class objects, constrained by
     the type argument.  See PEP 484 for more details.
+
+    We may encounter expressions whose values are specific classes;
+    those are represented as callables (possibly overloaded)
+    corresponding to the class's constructor's signature and returning
+    an instance of that class.  The difference with Type[C] is that
+    those callables always represent the exact class given as the
+    return type; Type[C] represents any class that's a subclass of C,
+    and C may also be a type variable or a union (or Any).
+
+    Many questions around subtype relationships between Type[C1] and
+    def(...) -> C2 are answered by looking at the subtype
+    relationships between C1 and C2, since Type[] is considered
+    covariant.
+
+    There's an unsolved problem with constructor signatures (also
+    unsolved in PEP 484): calling a variable whose type is Type[C]
+    assumes the constructor signature for C, even though a subclass of
+    C might completely change the constructor signature.  For now we
+    just assume that users of Type[C] are careful not to do that (in
+    the future we might detect when they are violating that
+    assumption).
     """
 
+    # This can't be everything, but it can be a class reference,
+    # a generic class instance, a union, Any, a type variable...
     item = None  # type: Type
 
-    def __init__(self, item: Type, line: int = -1) -> None:
+    def __init__(self, item: Type, *, line: int = -1) -> None:
         super().__init__(line)
         self.item = item
 
@@ -887,8 +910,9 @@ def visit_partial_type(self, t: PartialType) -> T:
     def visit_ellipsis_type(self, t: EllipsisType) -> T:
         raise self._notimplemented_helper('ellipsis_type')
 
+    @abstractmethod
     def visit_type_type(self, t: TypeType) -> T:
-        raise self._notimplemented_helper('type_type')
+        pass
 
 
 class TypeTranslator(TypeVisitor[Type]):
@@ -968,7 +992,7 @@ def visit_overloaded(self, t: Overloaded) -> Type:
         return Overloaded(items=items)
 
     def visit_type_type(self, t: TypeType) -> Type:
-        return t
+        return TypeType(t.item.accept(self), line=t.line)
 
 
 class TypeStrVisitor(TypeVisitor[str]):