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/messages.py

@@ -2068,7 +2068,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/semanal.py

@@ -3384,7 +3384,9 @@ def process_type_annotation(self, s: AssignmentStmt) -> None:
         if s.type:
             lvalue = s.lvalues[-1]
             allow_tuple_literal = isinstance(lvalue, TupleExpr)
-            analyzed = self.anal_type(s.type, allow_tuple_literal=allow_tuple_literal)
+            analyzed = self.anal_type(
+                s.type, allow_tuple_literal=allow_tuple_literal, analyze_annotation=True
+            )
             # Don't store not ready types (including placeholders).
             if analyzed is None or has_placeholder(analyzed):
                 self.defer(s)
@@ -6602,6 +6604,7 @@ def type_analyzer(
         report_invalid_types: bool = True,
         prohibit_self_type: str | None = None,
         allow_type_any: bool = False,
+        analyze_annotation: bool = False,
     ) -> TypeAnalyser:
         if tvar_scope is None:
             tvar_scope = self.tvar_scope
@@ -6620,6 +6623,7 @@ def type_analyzer(
             allow_unpack=allow_unpack,
             prohibit_self_type=prohibit_self_type,
             allow_type_any=allow_type_any,
+            analyze_annotation=analyze_annotation,
         )
         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
@@ -6644,6 +6648,7 @@ def anal_type(
         report_invalid_types: bool = True,
         prohibit_self_type: str | None = None,
         allow_type_any: bool = False,
+        analyze_annotation: bool = False,
         third_pass: bool = False,
     ) -> Type | None:
         """Semantically analyze a type.
@@ -6682,6 +6687,7 @@ def anal_type(
             report_invalid_types=report_invalid_types,
             prohibit_self_type=prohibit_self_type,
             allow_type_any=allow_type_any,
+            analyze_annotation=analyze_annotation,
         )
         tag = self.track_incomplete_refs()
         typ = typ.accept(a)

mypy/stubgenc.py

@@ -707,7 +707,7 @@ 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)

mypy/typeanal.py

@@ -202,6 +202,7 @@ def __init__(
         prohibit_self_type: str | None = None,
         allowed_alias_tvars: list[TypeVarLikeType] | None = None,
         allow_type_any: bool = False,
+        analyze_annotation: bool = False,
     ) -> None:
         self.api = api
         self.fail_func = api.fail
@@ -246,6 +247,7 @@ def __init__(
         self.allow_type_any = allow_type_any
         self.allow_type_var_tuple = False
         self.allow_unpack = allow_unpack
+        self.analyze_annotation = analyze_annotation
 
     def lookup_qualified(
         self, name: str, ctx: Context, suppress_errors: bool = False
@@ -588,7 +590,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.analyze_annotation 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-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-lowercase.test

@@ -45,7 +45,7 @@ x = 3  # E: Incompatible types in assignment (expression has type "int", variabl
 
 [case testTypeLowercaseSettingOff]
 # flags: --python-version 3.9 --no-force-uppercase-builtins
-x: type[type]
+x: type[type]  # E: Type[...] can't contain another Type[...]
 y: int
 
-y = x  # E: Incompatible types in assignment (expression has type "type[type]", variable has type "int")
+y = x  # E: Incompatible types in assignment (expression has type "type[Any]", variable has type "int")

test-data/unit/check-narrowing.test

@@ -659,6 +659,37 @@ else:
     reveal_type(y["model"])     # N: Revealed type is "Union[TypedDict('__main__.Model1', {'key': Literal['A']}), TypedDict('__main__.Model2', {'key': Literal['B']})]"
 [builtins fixtures/primitives.pyi]
 
+[case testNarrowingTypingTypeTypeAndBuiltinTypeTypeExplicitAny]
+# flags: --python-version 3.9 --warn-unreachable --disallow-any-generics
+
+from typing import Any, Type
+
+t1: Type[Any]
+t2: type[Any]
+
+class C: ...
+
+if isinstance(t1, C):
+    reveal_type(t1)  # E: Statement is unreachable
+if isinstance(t2, C):
+    reveal_type(t2)  # E: Statement is unreachable
+[builtins fixtures/isinstance.pyi]
+
+[case testNarrowingTypingTypeTypeAndBuiltinTypeTypeImplicitAny]
+# flags: --python-version 3.9 --warn-unreachable --disallow-any-generics
+
+from typing import Type
+
+t1: Type  # E: Missing type parameters for generic type "Type"
+t2: type  # E: Missing type parameters for generic type "type"
+class C: ...
+
+if isinstance(t1, C):
+    reveal_type(t1)  # E: Statement is unreachable
+if isinstance(t2, C):
+    reveal_type(t2)  # E: Statement is unreachable
+[builtins fixtures/isinstance.pyi]
+
 [case testNarrowingExprPropagation]
 from typing import Union
 from typing_extensions import Literal
@@ -1330,7 +1361,7 @@ else:
 
 raw: tuple[type, ...]
 if isinstance(some, raw):
-    reveal_type(some)  # N: Revealed type is "Union[builtins.int, __main__.Base]"
+    reveal_type(some)  # N: Revealed type is "Any"
 else:
     reveal_type(some)  # N: Revealed type is "Union[builtins.int, __main__.Base]"
 [builtins fixtures/dict.pyi]