Standardize Type[Union...]] -> Union[Type[...]]

* Add more tests for Type[Union[...]]
* Force TypeType.make() to be used everywhere instead of TypeType()
* Accidentally fixed testTypeUsingTypeCClassMethodUnion

Author: pkch

mypy/checker.py

@@ -663,7 +663,7 @@ def is_implicit_any(t: Type) -> bool:
                             and typ.arg_kinds[0] not in [nodes.ARG_STAR, nodes.ARG_STAR2]):
                         isclass = defn.is_class or defn.name() in ('__new__', '__init_subclass__')
                         if isclass:
-                            ref_type = mypy.types.TypeType(ref_type)
+                            ref_type = mypy.types.TypeType.make(ref_type)
                         erased = erase_to_bound(arg_type)
                         if not is_subtype_ignoring_tvars(ref_type, erased):
                             note = None
@@ -2680,13 +2680,10 @@ def convert_to_typetype(type_map: TypeMap) -> TypeMap:
     if type_map is None:
         return None
     for expr, typ in type_map.items():
-        if isinstance(typ, UnionType):
-            converted_type_map[expr] = UnionType([TypeType(t) for t in typ.items])
-        elif isinstance(typ, Instance):
-            converted_type_map[expr] = TypeType(typ)
-        else:
+        if not isinstance(typ, (UnionType, Instance)):
             # unknown type; error was likely reported earlier
             return {}
+        converted_type_map[expr] = TypeType.make(typ)
     return converted_type_map
 
 

mypy/checkexpr.py

@@ -401,7 +401,7 @@ def check_call(self, callee: Type, args: List[Expression],
 
             if (callee.is_type_obj() and (len(arg_types) == 1)
                     and is_equivalent(callee.ret_type, self.named_type('builtins.type'))):
-                callee = callee.copy_modified(ret_type=TypeType(arg_types[0]))
+                callee = callee.copy_modified(ret_type=TypeType.make(arg_types[0]))
 
             if callable_node:
                 # Store the inferred callable type.
@@ -1071,7 +1071,7 @@ def analyze_descriptor_access(self, instance_type: Type, descriptor_type: Type,
             owner_type = instance_type
 
         _, inferred_dunder_get_type = self.check_call(
-            dunder_get_type, [TempNode(instance_type), TempNode(TypeType(owner_type))],
+            dunder_get_type, [TempNode(instance_type), TempNode(TypeType.make(owner_type))],
             [nodes.ARG_POS, nodes.ARG_POS], context)
 
         if isinstance(inferred_dunder_get_type, AnyType):

mypy/checkmember.py

@@ -633,7 +633,7 @@ def expand(target: Type) -> Type:
         ret_type = func.ret_type
         variables = func.variables
     if isinstance(original_type, CallableType) and original_type.is_type_obj():
-        original_type = TypeType(original_type.ret_type)
+        original_type = TypeType.make(original_type.ret_type)
     res = func.copy_modified(arg_types=arg_types,
                              arg_kinds=func.arg_kinds[1:],
                              arg_names=func.arg_names[1:],
@@ -648,5 +648,5 @@ def erase_to_bound(t: Type) -> Type:
         return t.upper_bound
     if isinstance(t, TypeType):
         if isinstance(t.item, TypeVarType):
-            return TypeType(t.item.upper_bound)
+            return TypeType.make(t.item.upper_bound)
     return t

mypy/erasetype.py

@@ -77,7 +77,7 @@ def visit_union_type(self, t: UnionType) -> Type:
         return UnionType.make_simplified_union(erased_items)
 
     def visit_type_type(self, t: TypeType) -> Type:
-        return TypeType(t.item.accept(self), line=t.line)
+        return TypeType.make(t.item.accept(self), line=t.line)
 
 
 def erase_typevars(t: Type, ids_to_erase: Optional[Container[TypeVarId]] = None) -> Type:

mypy/expandtype.py

@@ -127,7 +127,7 @@ def visit_type_type(self, t: TypeType) -> Type:
         # union of instances or Any).  Sadly we can't report errors
         # here yet.
         item = t.item.accept(self)
-        return TypeType(item)
+        return TypeType.make(item)
 
     def expand_types(self, types: Iterable[Type]) -> List[Type]:
         a = []  # type: List[Type]

mypy/join.py

@@ -248,7 +248,7 @@ def visit_partial_type(self, t: PartialType) -> Type:
 
     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)
+            return TypeType.make(self.join(t.item, self.s.item), line=t.line)
         elif isinstance(self.s, Instance) and self.s.type.fullname() == 'builtins.type':
             return self.s
         else:

mypy/meet.py

@@ -276,7 +276,7 @@ def visit_type_type(self, t: TypeType) -> Type:
         if isinstance(self.s, TypeType):
             typ = self.meet(t.item, self.s.item)
             if not isinstance(typ, NoneTyp):
-                typ = TypeType(typ, line=t.line)
+                typ = TypeType.make(typ, line=t.line)
             return typ
         elif isinstance(self.s, Instance) and self.s.type.fullname() == 'builtins.type':
             return t

mypy/semanal.py

@@ -2212,7 +2212,7 @@ def add_method(funcname: str,
                        is_classmethod: bool = False,
                        ) -> None:
             if is_classmethod:
-                first = [Argument(Var('cls'), TypeType(selftype), None, ARG_POS)]
+                first = [Argument(Var('cls'), TypeType.make(selftype), None, ARG_POS)]
             else:
                 first = [Argument(Var('self'), selftype, None, ARG_POS)]
             args = first + args

mypy/subtypes.py

@@ -70,9 +70,9 @@ def is_subtype(left: Type, right: Type,
         # otherwise, fall through
     # Treat builtins.type the same as Type[Any]
     elif is_named_instance(left, 'builtins.type'):
-            return is_subtype(TypeType(AnyType()), right)
+            return is_subtype(TypeType.make(AnyType()), right)
     elif is_named_instance(right, 'builtins.type'):
-            return is_subtype(left, TypeType(AnyType()))
+            return is_subtype(left, TypeType.make(AnyType()))
     return left.accept(SubtypeVisitor(right, type_parameter_checker,
                                       ignore_pos_arg_names=ignore_pos_arg_names))
 

mypy/test/testtypes.py

@@ -580,7 +580,7 @@ def test_type_type(self) -> None:
         self.assert_join(self.fx.type_b, self.fx.type_any, self.fx.type_any)
         self.assert_join(self.fx.type_b, self.fx.type_type, self.fx.type_type)
         self.assert_join(self.fx.type_b, self.fx.type_c, self.fx.type_a)
-        self.assert_join(self.fx.type_c, self.fx.type_d, TypeType(self.fx.o))
+        self.assert_join(self.fx.type_c, self.fx.type_d, TypeType.make(self.fx.o))
         self.assert_join(self.fx.type_type, self.fx.type_any, self.fx.type_type)
         self.assert_join(self.fx.type_b, self.fx.anyt, self.fx.anyt)
 

mypy/typeanal.py

@@ -163,11 +163,11 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                 return self.analyze_callable_type(t)
             elif fullname == 'typing.Type':
                 if len(t.args) == 0:
-                    return TypeType(AnyType(), line=t.line)
+                    return TypeType.make(AnyType(), line=t.line)
                 if len(t.args) != 1:
                     self.fail('Type[...] must have exactly one type argument', t)
                 item = self.anal_type(t.args[0])
-                return TypeType(item, line=t.line)
+                return TypeType.make(item, line=t.line)
             elif fullname == 'typing.ClassVar':
                 if self.nesting_level > 0:
                     self.fail('Invalid type: ClassVar nested inside other type', t)
@@ -364,7 +364,7 @@ def visit_ellipsis_type(self, t: EllipsisType) -> Type:
         return AnyType()
 
     def visit_type_type(self, t: TypeType) -> Type:
-        return TypeType(self.anal_type(t.item), line=t.line)
+        return TypeType.make(self.anal_type(t.item), line=t.line)
 
     def analyze_callable_type(self, t: UnboundType) -> Type:
         fallback = self.builtin_type('builtins.function')

mypy/typefixture.py

@@ -145,12 +145,12 @@ def make_type_var(name: str, id: int, values: List[Type], upper_bound: Type,
         self.lsta = Instance(self.std_listi, [self.a])  # List[A]
         self.lstb = Instance(self.std_listi, [self.b])  # List[B]
 
-        self.type_a = TypeType(self.a)
-        self.type_b = TypeType(self.b)
-        self.type_c = TypeType(self.c)
-        self.type_d = TypeType(self.d)
-        self.type_t = TypeType(self.t)
-        self.type_any = TypeType(self.anyt)
+        self.type_a = TypeType.make(self.a)
+        self.type_b = TypeType.make(self.b)
+        self.type_c = TypeType.make(self.c)
+        self.type_d = TypeType.make(self.d)
+        self.type_t = TypeType.make(self.t)
+        self.type_any = TypeType.make(self.anyt)
 
     # Helper methods
 

mypy/types.py

@@ -1159,23 +1159,45 @@ class TypeType(Type):
     # a generic class instance, a union, Any, a type variable...
     item = None  # type: Type
 
+    # this class should not be created directly
+    # use make method which may return either TypeType or UnionType
+    # this is to ensure Type[Union[A, B]] is always represented as Union[Type[A], Type[B]]
     def __init__(self, item: Type, *, line: int = -1, column: int = -1) -> None:
+        raise NotImplementedError
+
+    def _init(self, item: Type, *, line: int = -1, column: int = -1) -> None:
         super().__init__(line, column)
         if isinstance(item, CallableType) and item.is_type_obj():
             self.item = item.fallback
         else:
             self.item = item
 
+    def __new__(cls, *args, **kwargs):  # type: ignore
+        instance = object.__new__(cls)
+        instance._init(*args, **kwargs)
+        return instance
+
+    def __copy__(self) -> 'Type':
+        return TypeType.make(self.item)
+
+    @staticmethod
+    def make(item: Type, *, line: int = -1, column: int = -1) -> Type:
+        if isinstance(item, UnionType):
+            return UnionType([TypeType.make(union_item) for union_item in item.items],
+                             line=line, column=column)
+        else:
+            return TypeType.__new__(TypeType, item, line=line, column=column)
+
     def accept(self, visitor: 'TypeVisitor[T]') -> T:
         return visitor.visit_type_type(self)
 
     def serialize(self) -> JsonDict:
         return {'.class': 'TypeType', 'item': self.item.serialize()}
 
     @classmethod
-    def deserialize(cls, data: JsonDict) -> 'TypeType':
+    def deserialize(cls, data: JsonDict) -> Type:
         assert data['.class'] == 'TypeType'
-        return TypeType(deserialize_type(data['item']))
+        return TypeType.make(deserialize_type(data['item']))
 
 
 #
@@ -1348,7 +1370,7 @@ def visit_overloaded(self, t: Overloaded) -> Type:
         return Overloaded(items=items)
 
     def visit_type_type(self, t: TypeType) -> Type:
-        return TypeType(t.item.accept(self), line=t.line, column=t.column)
+        return TypeType.make(t.item.accept(self), line=t.line, column=t.column)
 
 
 class TypeStrVisitor(TypeVisitor[str]):

test-data/unit/check-classes.test

@@ -2086,7 +2086,6 @@ def process(cls: Type[User]):
 [out]
 
 [case testTypeUsingTypeCClassMethodUnion]
-# Ideally this would work, but not worth the effort; just don't crash
 from typing import Type, Union
 class User:
     @classmethod
@@ -2095,11 +2094,11 @@ class User:
 class ProUser(User): pass
 class BasicUser(User): pass
 def process(cls: Type[Union[BasicUser, ProUser]]):
-    cls.foo()  # E: Type[Union[BasicUser, ProUser]] has no attribute "foo"
+    cls.foo()
     obj = cls()
-    cls.bar(obj)  # E: Type[Union[BasicUser, ProUser]] has no attribute "bar"
+    cls.bar(obj)
     cls.mro()  # Defined in class type
-    cls.error  # E: Type[Union[BasicUser, ProUser]] has no attribute "error"
+    cls.error  # E: Some element of union has no attribute "error"
 [builtins fixtures/classmethod.pyi]
 [out]
 

test-data/unit/check-isinstance.test

@@ -1443,7 +1443,7 @@ else:
 [builtins fixtures/isinstancelist.pyi]
 
 
-[case testIssubclasDestructuringUnions]
+[case testIssubclasDestructuringUnions1]
 from typing import Union, List, Tuple, Dict, Type
 def f(x: Union[Type[int], Type[str], Type[List]]) -> None:
     if issubclass(x, (str, (int,))):
@@ -1465,6 +1465,51 @@ def f(x: Union[Type[int], Type[str], Type[List]]) -> None:
 [builtins fixtures/isinstancelist.pyi]
 
 
+[case testIssubclasDestructuringUnions2]
+from typing import Union, List, Tuple, Dict, Type
+def f(x: Type[Union[int, str, List]]) -> None:
+    if issubclass(x, (str, (int,))):
+        reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.int], Type[builtins.str]]'
+        reveal_type(x())  # E: Revealed type is 'Union[builtins.int, builtins.str]'
+        x()[1]  # E: Value of type "Union[int, str]" is not indexable
+    else:
+        reveal_type(x)  # E: Revealed type is 'Type[builtins.list]'
+        reveal_type(x())  # E: Revealed type is 'builtins.list[<uninhabited>]'
+        x()[1]
+    reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.int], Type[builtins.str], Type[builtins.list]]'
+    reveal_type(x())  # E: Revealed type is 'Union[builtins.int, builtins.str, builtins.list[<uninhabited>]]'
+    if issubclass(x, (str, (list,))):
+        reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.str], Type[builtins.list[Any]]]'
+        reveal_type(x())  # E: Revealed type is 'Union[builtins.str, builtins.list[<uninhabited>]]'
+        x()[1]
+    reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.int], Type[builtins.str], Type[builtins.list[Any]]]'
+    reveal_type(x())  # E: Revealed type is 'Union[builtins.int, builtins.str, builtins.list[<uninhabited>]]'
+[builtins fixtures/isinstancelist.pyi]
+
+[case testIssubclasDestructuringUnions3]
+from typing import Union, List, Tuple, Dict, Type
+def f(x: Type[Union[int, str, List]]) -> None:
+    reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.int], Type[builtins.str], Type[builtins.list]]'
+    reveal_type(x())  # E: Revealed type is 'Union[builtins.int, builtins.str, builtins.list[<uninhabited>]]'
+    if issubclass(x, (str, (int,))):
+        reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.int], Type[builtins.str]]'
+        reveal_type(x())  # E: Revealed type is 'Union[builtins.int, builtins.str]'
+        x()[1]  # E: Value of type "Union[int, str]" is not indexable
+    else:
+        reveal_type(x)  # E: Revealed type is 'Type[builtins.list]'
+        reveal_type(x())  # E: Revealed type is 'builtins.list[<uninhabited>]'
+        x()[1]
+    reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.int], Type[builtins.str], Type[builtins.list]]'
+    reveal_type(x())  # E: Revealed type is 'Union[builtins.int, builtins.str, builtins.list[<uninhabited>]]'
+    if issubclass(x, (str, (list,))):
+        reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.str], Type[builtins.list[Any]]]'
+        reveal_type(x())  # E: Revealed type is 'Union[builtins.str, builtins.list[<uninhabited>]]'
+        x()[1]
+    reveal_type(x)  # E: Revealed type is 'Union[Type[builtins.int], Type[builtins.str], Type[builtins.list[Any]]]'
+    reveal_type(x())  # E: Revealed type is 'Union[builtins.int, builtins.str, builtins.list[<uninhabited>]]'
+[builtins fixtures/isinstancelist.pyi]
+
+
 [case testIssubclass]
 from typing import Type, ClassVar