CR: Rename .make -> .make_normalized

Author: pkch

mypy/checker.py

@@ -667,7 +667,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.make(ref_type)
+                            ref_type = mypy.types.TypeType.make_normalized(ref_type)
                         erased = erase_to_bound(arg_type)
                         if not is_subtype_ignoring_tvars(ref_type, erased):
                             note = None
@@ -2719,7 +2719,7 @@ def convert_to_typetype(type_map: TypeMap) -> TypeMap:
         if not isinstance(typ, (UnionType, Instance)):
             # unknown type; error was likely reported earlier
             return {}
-        converted_type_map[expr] = TypeType.make(typ)
+        converted_type_map[expr] = TypeType.make_normalized(typ)
     return converted_type_map
 
 

mypy/checkexpr.py

@@ -432,7 +432,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.make(arg_types[0]))
+                callee = callee.copy_modified(ret_type=TypeType.make_normalized(arg_types[0]))
 
             if callable_node:
                 # Store the inferred callable type.
@@ -1108,7 +1108,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.make(owner_type))],
+            dunder_get_type, [TempNode(instance_type), TempNode(TypeType.make_normalized(owner_type))],
             [nodes.ARG_POS, nodes.ARG_POS], context)
 
         if isinstance(inferred_dunder_get_type, AnyType):

mypy/checkmember.py

@@ -650,7 +650,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.make(original_type.ret_type)
+        original_type = TypeType.make_normalized(original_type.ret_type)
     res = func.copy_modified(arg_types=arg_types,
                              arg_kinds=func.arg_kinds[1:],
                              arg_names=func.arg_names[1:],
@@ -665,5 +665,5 @@ def erase_to_bound(t: Type) -> Type:
         return t.upper_bound
     if isinstance(t, TypeType):
         if isinstance(t.item, TypeVarType):
-            return TypeType.make(t.item.upper_bound)
+            return TypeType.make_normalized(t.item.upper_bound)
     return t

mypy/erasetype.py

@@ -75,7 +75,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.make(t.item.accept(self), line=t.line)
+        return TypeType.make_normalized(t.item.accept(self), line=t.line)
 
 
 def erase_typevars(t: Type, ids_to_erase: Optional[Container[TypeVarId]] = None) -> Type:

mypy/expandtype.py

@@ -124,7 +124,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.make(item)
+        return TypeType.make_normalized(item)
 
     def expand_types(self, types: Iterable[Type]) -> List[Type]:
         a = []  # type: List[Type]

mypy/join.py

@@ -245,7 +245,7 @@ def visit_partial_type(self, t: PartialType) -> Type:
 
     def visit_type_type(self, t: TypeType) -> Type:
         if isinstance(self.s, TypeType):
-            return TypeType.make(self.join(t.item, self.s.item), line=t.line)
+            return TypeType.make_normalized(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

@@ -278,7 +278,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.make(typ, line=t.line)
+                typ = TypeType.make_normalized(typ, line=t.line)
             return typ
         elif isinstance(self.s, Instance) and self.s.type.fullname() == 'builtins.type':
             return t

mypy/messages.py

@@ -192,7 +192,7 @@ def format(self, typ: Type, verbosity: int = 0) -> str:
             if func.is_type_obj():
                 # The type of a type object type can be derived from the
                 # return type (this always works).
-                return self.format(TypeType.make(erase_type(func.items()[0].ret_type)), verbosity)
+                return self.format(TypeType.make_normalized(erase_type(func.items()[0].ret_type)), verbosity)
             elif isinstance(func, CallableType):
                 return_type = strip_quotes(self.format(func.ret_type))
                 if func.is_ellipsis_args:

mypy/semanal.py

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

mypy/subtypes.py

@@ -154,7 +154,7 @@ def visit_instance(self, left: Instance) -> bool:
             if isinstance(item, TupleType):
                 item = item.fallback
             if is_named_instance(left, 'builtins.type'):
-                return is_subtype(TypeType.make(AnyType()), right)
+                return is_subtype(TypeType(AnyType()), right)
             if left.type.is_metaclass():
                 if isinstance(item, AnyType):
                     return True

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.make(self.fx.o))
+        self.assert_join(self.fx.type_c, self.fx.type_d, TypeType.make_normalized(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

@@ -185,11 +185,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.make(AnyType(), line=t.line)
+                    return TypeType(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.make(item, line=t.line)
+                return TypeType.make_normalized(item, line=t.line)
             elif fullname == 'typing.ClassVar':
                 if self.nesting_level > 0:
                     self.fail('Invalid type: ClassVar nested inside other type', t)
@@ -384,7 +384,7 @@ def visit_ellipsis_type(self, t: EllipsisType) -> Type:
         return AnyType()
 
     def visit_type_type(self, t: TypeType) -> Type:
-        return TypeType.make(self.anal_type(t.item), line=t.line)
+        return TypeType.make_normalized(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.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)
+        self.type_a = TypeType.make_normalized(self.a)
+        self.type_b = TypeType.make_normalized(self.b)
+        self.type_c = TypeType.make_normalized(self.c)
+        self.type_d = TypeType.make_normalized(self.d)
+        self.type_t = TypeType.make_normalized(self.t)
+        self.type_any = TypeType.make_normalized(self.anyt)
 
     # Helper methods
 

mypy/types.py

@@ -1183,20 +1183,22 @@ class TypeType(Type):
     # a generic class instance, a union, Any, a type variable...
     item = None  # type: Type
 
-    # This class must be created using 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: Union[Instance, AnyType, TypeVarType, TupleType, NoneTyp,
                                    CallableType], *, line: int = -1, column: int = -1) -> None:
+        """To ensure Type[Union[A, B]] is always represented as Union[Type[A], Type[B]], item of
+        type UnionType must be handled through make_normalized static method.
+        """
+
         super().__init__(line, column)
         if isinstance(item, CallableType) and item.is_type_obj():
             self.item = item.fallback
         else:
             self.item = item
 
     @staticmethod
-    def make(item: Type, *, line: int = -1, column: int = -1) -> Type:
+    def make_normalized(item: Type, *, line: int = -1, column: int = -1) -> Type:
         if isinstance(item, UnionType):
-            return UnionType.make_union([TypeType.make(union_item) for union_item in item.items],
+            return UnionType.make_union([TypeType.make_normalized(union_item) for union_item in item.items],
                              line=line, column=column)
         elif isinstance(item, (Instance, AnyType, TypeVarType, TupleType, NoneTyp, CallableType)):
             return TypeType(item, line=line, column=column)
@@ -1212,7 +1214,7 @@ def serialize(self) -> JsonDict:
     @classmethod
     def deserialize(cls, data: JsonDict) -> Type:
         assert data['.class'] == 'TypeType'
-        return TypeType.make(deserialize_type(data['item']))
+        return TypeType.make_normalized(deserialize_type(data['item']))
 
 
 #
@@ -1389,7 +1391,7 @@ def visit_overloaded(self, t: Overloaded) -> Type:
         return Overloaded(items=items)
 
     def visit_type_type(self, t: TypeType) -> Type:
-        return TypeType.make(t.item.accept(self), line=t.line, column=t.column)
+        return TypeType.make_normalized(t.item.accept(self), line=t.line, column=t.column)
 
 
 class TypeStrVisitor(SyntheticTypeVisitor[str]):