Interpret type annotations as type[Any] annotations

mypy/fastparse.py

@@ -373,7 +373,7 @@ def __init__(
         self.type_ignores: dict[int, list[str]] = {}
 
         # Cache of visit_X methods keyed by type of visited object
-        self.visitor_cache: dict[type, Callable[[AST | None], Any]] = {}
+        self.visitor_cache: dict[type[object], Callable[[AST | None], Any]] = {}
 
     def note(self, msg: str, line: int, column: int) -> None:
         self.errors.report(line, column, msg, severity="note", code=codes.SYNTAX)

mypy/message_registry.py

@@ -178,6 +178,10 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 IMPLICIT_GENERIC_ANY_BUILTIN: Final = (
     'Implicit generic "Any". Use "{}" and specify generic parameters'
 )
+BUILTIN_TYPE_USED_AS_GENERIC = (
+    '"builtins.type" is indexable as a type hint but neither a generic class nor a generic '
+    "function"
+)
 INVALID_UNPACK: Final = "{} cannot be unpacked (must be tuple or TypeVarTuple)"
 INVALID_UNPACK_POSITION: Final = "Unpack is only valid in a variadic position"
 

mypy/messages.py

@@ -417,6 +417,13 @@ def has_no_attr(
             # Indexed get.
             # TODO: Fix this consistently in format_type
             if isinstance(original_type, FunctionLike) and original_type.is_type_obj():
+                if (
+                    isinstance(original_type, CallableType)
+                    and isinstance(ret_type := get_proper_type(original_type.ret_type), Instance)
+                    and (ret_type.type.fullname == "builtins.type")
+                ):
+                    self.fail(message_registry.BUILTIN_TYPE_USED_AS_GENERIC, context)
+                    return None
                 self.fail(
                     "The type {} is not generic and not indexable".format(
                         format_type(original_type, self.options)
@@ -2075,7 +2082,7 @@ def report_protocol_problems(
         # note:     method, attr
         MAX_ITEMS = 2  # Maximum number of conflicts, missing members, and overloads shown
         # List of special situations where we don't want to report additional problems
-        exclusions: dict[type, list[str]] = {
+        exclusions: dict[type[object], list[str]] = {
             TypedDictType: ["typing.Mapping"],
             TupleType: ["typing.Iterable", "typing.Sequence"],
         }

mypy/nodes.py

@@ -3400,7 +3400,7 @@ class FakeInfo(TypeInfo):
     def __init__(self, msg: str) -> None:
         self.msg = msg
 
-    def __getattribute__(self, attr: str) -> type:
+    def __getattribute__(self, attr: str) -> type[object]:
         # Handle __class__ so that isinstance still works...
         if attr == "__class__":
             return object.__getattribute__(self, attr)  # type: ignore[no-any-return]

mypy/semanal.py

@@ -2170,7 +2170,10 @@ def analyze_base_classes(
 
             try:
                 base = self.expr_to_analyzed_type(
-                    base_expr, allow_placeholder=True, allow_type_any=True
+                    base_expr,
+                    allow_placeholder=True,
+                    allow_type_any=True,
+                    builtin_type_is_type_type=not refers_to_fullname(base_expr, "builtins.type"),
                 )
             except TypeTranslationError:
                 name = self.get_name_repr_of_expr(base_expr)
@@ -2220,10 +2223,14 @@ def configure_base_classes(
             elif isinstance(base, TypedDictType):
                 base_types.append(base.fallback)
             else:
-                msg = "Invalid base class"
-                name = self.get_name_repr_of_expr(base_expr)
-                if name:
-                    msg += f' "{name}"'
+                if isinstance(base_expr, IndexExpr) and refers_to_fullname(
+                    base_expr.base, "builtins.type"
+                ):
+                    msg = message_registry.BUILTIN_TYPE_USED_AS_GENERIC
+                else:
+                    msg = "Invalid base class"
+                    if name := self.get_name_repr_of_expr(base_expr):
+                        msg += f' "{name}"'
                 self.fail(msg, base_expr)
                 info.fallback_to_any = True
             if self.options.disallow_any_unimported and has_any_from_unimported_type(base):
@@ -3467,7 +3474,11 @@ def analyze_simple_literal_type(self, rvalue: Expression, is_final: bool) -> Typ
         return typ
 
     def analyze_alias(
-        self, name: str, rvalue: Expression, allow_placeholder: bool = False
+        self,
+        name: str,
+        rvalue: Expression,
+        allow_placeholder: bool = False,
+        builtin_type_is_type_type: bool = False,
     ) -> tuple[Type | None, list[TypeVarLikeType], set[str], list[str], bool]:
         """Check if 'rvalue' is a valid type allowed for aliasing (e.g. not a type variable).
 
@@ -3508,6 +3519,7 @@ def analyze_alias(
                 in_dynamic_func=dynamic,
                 global_scope=global_scope,
                 allowed_alias_tvars=tvar_defs,
+                builtin_type_is_type_type=builtin_type_is_type_type,
             )
 
         # There can be only one variadic variable at most, the error is reported elsewhere.
@@ -3609,7 +3621,12 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
         else:
             tag = self.track_incomplete_refs()
             res, alias_tvars, depends_on, qualified_tvars, empty_tuple_index = self.analyze_alias(
-                lvalue.name, rvalue, allow_placeholder=True
+                lvalue.name,
+                rvalue,
+                allow_placeholder=True,
+                builtin_type_is_type_type=(
+                    (s.type is not None) or not refers_to_fullname(s.rvalue, "builtins.type")
+                ),
             )
             if not res:
                 return False
@@ -6548,6 +6565,7 @@ def expr_to_analyzed_type(
         allow_unbound_tvars: bool = False,
         allow_param_spec_literals: bool = False,
         allow_unpack: bool = False,
+        builtin_type_is_type_type: bool = True,
     ) -> Type | None:
         if isinstance(expr, CallExpr):
             # This is a legacy syntax intended mostly for Python 2, we keep it for
@@ -6579,6 +6597,9 @@ def expr_to_analyzed_type(
             allow_unbound_tvars=allow_unbound_tvars,
             allow_param_spec_literals=allow_param_spec_literals,
             allow_unpack=allow_unpack,
+            builtin_type_is_type_type=(
+                builtin_type_is_type_type or not refers_to_fullname(expr, "builtins.type")
+            ),
         )
 
     def analyze_type_expr(self, expr: Expression) -> None:
@@ -6604,6 +6625,7 @@ def type_analyzer(
         report_invalid_types: bool = True,
         prohibit_self_type: str | None = None,
         allow_type_any: bool = False,
+        builtin_type_is_type_type: bool = True,
     ) -> TypeAnalyser:
         if tvar_scope is None:
             tvar_scope = self.tvar_scope
@@ -6622,6 +6644,7 @@ def type_analyzer(
             allow_unpack=allow_unpack,
             prohibit_self_type=prohibit_self_type,
             allow_type_any=allow_type_any,
+            builtin_type_is_type_type=builtin_type_is_type_type,
         )
         tpan.in_dynamic_func = bool(self.function_stack and self.function_stack[-1].is_dynamic())
         tpan.global_scope = not self.type and not self.function_stack
@@ -6646,6 +6669,7 @@ def anal_type(
         report_invalid_types: bool = True,
         prohibit_self_type: str | None = None,
         allow_type_any: bool = False,
+        builtin_type_is_type_type: bool = True,
         third_pass: bool = False,
     ) -> Type | None:
         """Semantically analyze a type.
@@ -6684,6 +6708,7 @@ def anal_type(
             report_invalid_types=report_invalid_types,
             prohibit_self_type=prohibit_self_type,
             allow_type_any=allow_type_any,
+            builtin_type_is_type_type=builtin_type_is_type_type,
         )
         tag = self.track_incomplete_refs()
         typ = typ.accept(a)

mypy/stubgenc.py

@@ -684,7 +684,7 @@ def generate_property_stub(
 
                 rw_properties.append(f"{self._indent}{name}: {inferred_type}")
 
-    def get_type_fullname(self, typ: type) -> str:
+    def get_type_fullname(self, typ: type[object]) -> str:
         """Given a type, return a string representation"""
         if typ is Any:
             return "Any"
@@ -695,7 +695,7 @@ def get_type_fullname(self, typ: type) -> str:
             typename = f"{module_name}.{typename}"
         return typename
 
-    def get_base_types(self, obj: type) -> list[str]:
+    def get_base_types(self, obj: type[object]) -> list[str]:
         all_bases = type.mro(obj)
         if all_bases[-1] is object:
             # TODO: Is this always object?
@@ -707,13 +707,13 @@ def get_base_types(self, obj: type) -> list[str]:
         # remove the class itself
         all_bases = all_bases[1:]
         # Remove base classes of other bases as redundant.
-        bases: list[type] = []
+        bases: list[type[object]] = []
         for base in all_bases:
             if not any(issubclass(b, base) for b in bases):
                 bases.append(base)
         return [self.strip_or_import(self.get_type_fullname(base)) for base in bases]
 
-    def generate_class_stub(self, class_name: str, cls: type, output: list[str]) -> None:
+    def generate_class_stub(self, class_name: str, cls: type[object], output: list[str]) -> None:
         """Generate stub for a single class using runtime introspection.
 
         The result lines will be appended to 'output'. If necessary, any

mypy/stubutil.py

@@ -277,7 +277,11 @@ def args_str(self, args: Iterable[Type]) -> str:
 
 class ClassInfo:
     def __init__(
-        self, name: str, self_var: str, docstring: str | None = None, cls: type | None = None
+        self,
+        name: str,
+        self_var: str,
+        docstring: str | None = None,
+        cls: type[object] | None = None,
     ) -> None:
         self.name = name
         self.self_var = self_var

mypy/subtypes.py

@@ -1055,6 +1055,20 @@ def visit_type_type(self, left: TypeType) -> bool:
                 #       of x is Type[int]. It's unclear what's the right way to address this.
                 return True
             item = left.item
+            if (
+                right.type.is_protocol
+                and (len(right.type.protocol_members) == 1)
+                and (right.type.protocol_members[0] == "__hash__")
+            ):
+                if isinstance(item, AnyType):
+                    return True
+                if isinstance(item, Instance):
+                    if (
+                        (metaclass_type := item.type.metaclass_type) is None
+                        or (symtab := metaclass_type.type.get("__hash__")) is None
+                        or isinstance(symtab.node, FunctionLike)
+                    ):
+                        return True
             if isinstance(item, TypeVarType):
                 item = get_proper_type(item.upper_bound)
             if isinstance(item, Instance):

mypy/test/helpers.py

@@ -318,14 +318,14 @@ def assert_equal(a: object, b: object, fmt: str = "{} != {}") -> None:
         raise AssertionError(fmt.format(good_repr(a), good_repr(b)))
 
 
-def typename(t: type) -> str:
+def typename(t: type[object]) -> str:
     if "." in str(t):
         return str(t).split(".")[-1].rstrip("'>")
     else:
         return str(t)[8:-2]
 
 
-def assert_type(typ: type, value: object) -> None:
+def assert_type(typ: type[object], value: object) -> None:
     __tracebackhide__ = True
     if type(value) != typ:
         raise AssertionError(f"Invalid type {typename(type(value))}, expected {typename(typ)}")

mypy/typeanal.py

@@ -133,6 +133,7 @@ def analyze_type_alias(
     in_dynamic_func: bool = False,
     global_scope: bool = True,
     allowed_alias_tvars: list[TypeVarLikeType] | None = None,
+    builtin_type_is_type_type: bool = True,
 ) -> tuple[Type, set[str]]:
     """Analyze r.h.s. of a (potential) type alias definition.
 
@@ -150,6 +151,7 @@ def analyze_type_alias(
         allow_placeholder=allow_placeholder,
         prohibit_self_type="type alias target",
         allowed_alias_tvars=allowed_alias_tvars,
+        builtin_type_is_type_type=builtin_type_is_type_type,
     )
     analyzer.in_dynamic_func = in_dynamic_func
     analyzer.global_scope = global_scope
@@ -202,6 +204,7 @@ def __init__(
         prohibit_self_type: str | None = None,
         allowed_alias_tvars: list[TypeVarLikeType] | None = None,
         allow_type_any: bool = False,
+        builtin_type_is_type_type: bool = True,
     ) -> None:
         self.api = api
         self.fail_func = api.fail
@@ -246,6 +249,7 @@ def __init__(
         self.allow_type_any = allow_type_any
         self.allow_type_var_tuple = False
         self.allow_unpack = allow_unpack
+        self.builtin_type_is_type_type = builtin_type_is_type_type
 
     def lookup_qualified(
         self, name: str, ctx: Context, suppress_errors: bool = False
@@ -588,7 +592,9 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
             and (self.always_allow_new_syntax or self.options.python_version >= (3, 9))
         ):
             if len(t.args) == 0:
-                if fullname == "typing.Type":
+                if fullname == "typing.Type" or (
+                    self.builtin_type_is_type_type and (fullname == "builtins.type")
+                ):
                     any_type = self.get_omitted_any(t)
                     return TypeType(any_type, line=t.line, column=t.column)
                 else:

test-data/unit/check-callable.test

@@ -524,17 +524,6 @@ else:
 
 [builtins fixtures/callable.pyi]
 
-[case testBuiltinsTypeAsCallable]
-# flags: --python-version 3.7
-from __future__ import annotations
-
-reveal_type(type)  # N: Revealed type is "def (x: Any) -> builtins.type"
-_TYPE = type
-reveal_type(_TYPE)  # N: Revealed type is "def (x: Any) -> builtins.type"
-_TYPE('bar')
-
-[builtins fixtures/callable.pyi]
-
 [case testErrorMessageAboutSelf]
 # https://github.com/python/mypy/issues/11309
 class Some:

test-data/unit/check-classes.test

@@ -2136,7 +2136,7 @@ tmp/foo.pyi:8: note:          def __add__(self, int, /) -> A
 tmp/foo.pyi:8: note:          @overload
 tmp/foo.pyi:8: note:          def __add__(self, str, /) -> A
 tmp/foo.pyi:8: note:          @overload
-tmp/foo.pyi:8: note:          def __add__(self, type, /) -> A
+tmp/foo.pyi:8: note:          def __add__(self, Type[Any], /) -> A
 tmp/foo.pyi:8: note: Overloaded operator methods can't have wider argument types in overrides
 
 [case testOverloadedOperatorMethodOverrideWithSwitchedItemOrder]
@@ -3431,7 +3431,7 @@ def foo(arg: Type[Any]):
 from typing import Type, Any
 def foo(arg: Type[Any]):
     reveal_type(arg.__str__)  # N: Revealed type is "def () -> builtins.str"
-    reveal_type(arg.mro())  # N: Revealed type is "builtins.list[builtins.type[Any]]"
+    reveal_type(arg.mro())  # N: Revealed type is "builtins.list[Type[Any]]"
 [builtins fixtures/type.pyi]
 [out]
 
@@ -3771,7 +3771,7 @@ def f(a: type) -> None: pass
 f(3)  # E: No overload variant of "f" matches argument type "int" \
       # N: Possible overload variants: \
       # N:     def f(a: Type[User]) -> None \
-      # N:     def f(a: type) -> None
+      # N:     def f(a: Type[Any]) -> None
 [builtins fixtures/classmethod.pyi]
 [out]
 
@@ -5493,8 +5493,7 @@ def f() -> type: return M
 class C1(six.with_metaclass(M), object): pass  # E: Unsupported dynamic base class "six.with_metaclass"
 class C2(C1, six.with_metaclass(M)): pass  # E: Unsupported dynamic base class "six.with_metaclass"
 class C3(six.with_metaclass(A)): pass  # E: Metaclasses not inheriting from "type" are not supported
-@six.add_metaclass(A)  # E: Metaclasses not inheriting from "type" are not supported  \
-    # E: Argument 1 to "add_metaclass" has incompatible type "Type[A]"; expected "Type[type]"
+@six.add_metaclass(A)  # E: Metaclasses not inheriting from "type" are not supported
 
 class D3(A): pass
 class C4(six.with_metaclass(M), metaclass=M): pass  # E: Multiple metaclass definitions

test-data/unit/check-generic-alias.test

@@ -109,7 +109,7 @@ reveal_type(t6)  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
 reveal_type(t7)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 reveal_type(t8)  # N: Revealed type is "builtins.dict[Any, Any]"
 reveal_type(t9)  # N: Revealed type is "builtins.dict[builtins.int, builtins.str]"
-reveal_type(t10)  # N: Revealed type is "builtins.type"
+reveal_type(t10)  # N: Revealed type is "Type[Any]"
 reveal_type(t11)  # N: Revealed type is "Type[builtins.int]"
 [builtins fixtures/dict.pyi]
 

test-data/unit/check-generics.test

@@ -513,7 +513,7 @@ Alias[int]("a")  # E: Argument 1 to "Node" has incompatible type "str"; expected
 [out]
 
 [case testTypeApplicationCrash]
-type[int] # this was crashing, see #2302 (comment)  # E: The type "Type[type]" is not generic and not indexable
+type[int] # this was crashing, see #2302 (comment)  # E: "builtins.type" is indexable as a type hint but neither a generic class nor a generic function
 [out]
 
 

test-data/unit/check-isinstance.test

@@ -1883,7 +1883,7 @@ if issubclass(y): # E: Missing positional argument "t" in call to "issubclass"
 
 [case testIsInstanceTooManyArgs]
 isinstance(1, 1, 1) # E: Too many arguments for "isinstance" \
-         # E: Argument 2 to "isinstance" has incompatible type "int"; expected "Union[type, Tuple[Any, ...]]"
+         # E: Argument 2 to "isinstance" has incompatible type "int"; expected "Union[Type[Any], Tuple[Any, ...]]"
 x: object
 if isinstance(x, str, 1): # E: Too many arguments for "isinstance"
     reveal_type(x) # N: Revealed type is "builtins.object"

test-data/unit/check-literal.test

@@ -1480,13 +1480,13 @@ Alias = Literal[3]
 
 isinstance(3, Literal[3])           # E: Cannot use isinstance() with Literal type
 isinstance(3, Alias)                # E: Cannot use isinstance() with Literal type \
-                                    # E: Argument 2 to "isinstance" has incompatible type "<typing special form>"; expected "Union[type, Tuple[Any, ...]]"
+                                    # E: Argument 2 to "isinstance" has incompatible type "<typing special form>"; expected "Union[Type[Any], Tuple[Any, ...]]"
 isinstance(3, Renamed[3])           # E: Cannot use isinstance() with Literal type
 isinstance(3, indirect.Literal[3])  # E: Cannot use isinstance() with Literal type
 
 issubclass(int, Literal[3])           # E: Cannot use issubclass() with Literal type
 issubclass(int, Alias)                # E: Cannot use issubclass() with Literal type \
-                                      # E: Argument 2 to "issubclass" has incompatible type "<typing special form>"; expected "Union[type, Tuple[Any, ...]]"
+                                      # E: Argument 2 to "issubclass" has incompatible type "<typing special form>"; expected "Union[Type[Any], Tuple[Any, ...]]"
 issubclass(int, Renamed[3])           # E: Cannot use issubclass() with Literal type
 issubclass(int, indirect.Literal[3])  # E: Cannot use issubclass() with Literal type
 [builtins fixtures/isinstancelist.pyi]