Use PEP 604 annotations everywhere (#20320)

See #20154. Most of this was done with ruff, rest was done by hand

Author: hauntsaninja

mypy/binder.py

@@ -3,7 +3,7 @@
 from collections import defaultdict
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import NamedTuple, Optional, Union
+from typing import NamedTuple
 from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.erasetype import remove_instance_last_known_values
@@ -39,7 +39,7 @@
 )
 from mypy.typevars import fill_typevars_with_any
 
-BindableExpression: _TypeAlias = Union[IndexExpr, MemberExpr, NameExpr]
+BindableExpression: _TypeAlias = IndexExpr | MemberExpr | NameExpr
 
 
 class CurrentType(NamedTuple):
@@ -81,7 +81,7 @@ def __repr__(self) -> str:
         return f"Frame({self.id}, {self.types}, {self.unreachable}, {self.conditional_frame})"
 
 
-Assigns = defaultdict[Expression, list[tuple[Type, Optional[Type]]]]
+Assigns = defaultdict[Expression, list[tuple[Type, Type | None]]]
 
 
 class ConditionalTypeBinder:

mypy/cache.py

@@ -48,7 +48,7 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import Any, Final, Union
+from typing import Any, Final
 from typing_extensions import TypeAlias as _TypeAlias
 
 from librt.internal import (
@@ -391,7 +391,7 @@ def write_str_opt_list(data: WriteBuffer, value: list[str | None]) -> None:
         write_str_opt(data, item)
 
 
-JsonValue: _TypeAlias = Union[None, int, str, bool, list["JsonValue"], dict[str, "JsonValue"]]
+JsonValue: _TypeAlias = None | int | str | bool | list["JsonValue"] | dict[str, "JsonValue"]
 
 
 def read_json_value(data: ReadBuffer) -> JsonValue:

mypy/checker.py

@@ -6,18 +6,7 @@
 from collections import defaultdict
 from collections.abc import Iterable, Iterator, Mapping, Sequence, Set as AbstractSet
 from contextlib import ExitStack, contextmanager
-from typing import (
-    Callable,
-    Final,
-    Generic,
-    Literal,
-    NamedTuple,
-    Optional,
-    TypeVar,
-    Union,
-    cast,
-    overload,
-)
+from typing import Callable, Final, Generic, Literal, NamedTuple, TypeVar, cast, overload
 from typing_extensions import TypeAlias as _TypeAlias, TypeGuard
 
 import mypy.checkexpr
@@ -249,8 +238,8 @@
 # Maximum length of fixed tuple types inferred when narrowing from variadic tuples.
 MAX_PRECISE_TUPLE_SIZE: Final = 8
 
-DeferredNodeType: _TypeAlias = Union[FuncDef, OverloadedFuncDef, Decorator]
-FineGrainedDeferredNodeType: _TypeAlias = Union[FuncDef, MypyFile, OverloadedFuncDef]
+DeferredNodeType: _TypeAlias = FuncDef | OverloadedFuncDef | Decorator
+FineGrainedDeferredNodeType: _TypeAlias = FuncDef | MypyFile | OverloadedFuncDef
 
 
 # A node which is postponed to be processed during the next pass.
@@ -283,7 +272,7 @@ class FineGrainedDeferredNode(NamedTuple):
 # (such as two references to the same variable). TODO: it would
 # probably be better to have the dict keyed by the nodes' literal_hash
 # field instead.
-TypeMap: _TypeAlias = Optional[dict[Expression, Type]]
+TypeMap: _TypeAlias = dict[Expression, Type] | None
 
 
 # Keeps track of partial types in a single scope. In fine-grained incremental

mypy/checkexpr.py

@@ -8,7 +8,7 @@
 from collections import defaultdict
 from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager, nullcontext
-from typing import Callable, ClassVar, Final, Optional, cast, overload
+from typing import Callable, ClassVar, Final, cast, overload
 from typing_extensions import TypeAlias as _TypeAlias, assert_never
 
 import mypy.checker
@@ -217,7 +217,7 @@
 # Type of callback user for checking individual function arguments. See
 # check_args() below for details.
 ArgChecker: _TypeAlias = Callable[
-    [Type, Type, ArgKind, Type, int, int, CallableType, Optional[Type], Context, Context], None
+    [Type, Type, ArgKind, Type, int, int, CallableType, Type | None, Context, Context], None
 ]
 
 # Maximum nesting level for math union in overloads, setting this to large values

mypy/checkstrformat.py

@@ -14,7 +14,7 @@
 
 import re
 from re import Match, Pattern
-from typing import Callable, Final, Union, cast
+from typing import Callable, Final, cast
 from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.errorcodes as codes
@@ -64,7 +64,7 @@
     get_proper_types,
 )
 
-FormatStringExpr: _TypeAlias = Union[StrExpr, BytesExpr]
+FormatStringExpr: _TypeAlias = StrExpr | BytesExpr
 Checkers: _TypeAlias = tuple[Callable[[Expression], None], Callable[[Type], bool]]
 MatchMap: _TypeAlias = dict[tuple[int, int], Match[str]]  # span -> match
 

mypy/config_parser.py

@@ -14,15 +14,15 @@
     import tomli as tomllib
 
 from collections.abc import Mapping, MutableMapping, Sequence
-from typing import Any, Callable, Final, TextIO, Union
+from typing import Any, Callable, Final, TextIO
 from typing_extensions import Never, TypeAlias
 
 from mypy import defaults
 from mypy.options import PER_MODULE_OPTIONS, Options
 
-_CONFIG_VALUE_TYPES: TypeAlias = Union[
-    str, bool, int, float, dict[str, str], list[str], tuple[int, int]
-]
+_CONFIG_VALUE_TYPES: TypeAlias = (
+    str | bool | int | float | dict[str, str] | list[str] | tuple[int, int]
+)
 _INI_PARSER_CALLABLE: TypeAlias = Callable[[Any], _CONFIG_VALUE_TYPES]
 
 

mypy/constant_fold.py

@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-from typing import Final, Union
+from typing import Final
 
 from mypy.nodes import (
     ComplexExpr,
@@ -20,7 +20,7 @@
 )
 
 # All possible result types of constant folding
-ConstantValue = Union[int, bool, float, complex, str]
+ConstantValue = int | bool | float | complex | str
 CONST_TYPES: Final = (int, bool, float, complex, str)
 
 

mypy/errors.py

@@ -6,7 +6,7 @@
 from collections import defaultdict
 from collections.abc import Iterable, Iterator
 from itertools import chain
-from typing import Callable, Final, NoReturn, Optional, TextIO, TypeVar
+from typing import Callable, Final, NoReturn, TextIO, TypeVar
 from typing_extensions import Literal, Self, TypeAlias as _TypeAlias
 
 from mypy import errorcodes as codes
@@ -155,7 +155,7 @@ def __init__(
 
 # Type used internally to represent errors:
 #   (path, line, column, end_line, end_column, severity, message, code)
-ErrorTuple: _TypeAlias = tuple[Optional[str], int, int, int, int, str, str, Optional[ErrorCode]]
+ErrorTuple: _TypeAlias = tuple[str | None, int, int, int, int, str, str, ErrorCode | None]
 
 
 class ErrorWatcher:

mypy/exportjson.py

@@ -16,7 +16,7 @@
 import argparse
 import json
 import sys
-from typing import Any, Union
+from typing import Any
 from typing_extensions import TypeAlias as _TypeAlias
 
 from librt.internal import ReadBuffer
@@ -69,7 +69,7 @@
     get_proper_type,
 )
 
-Json: _TypeAlias = Union[dict[str, Any], str]
+Json: _TypeAlias = dict[str, Any] | str
 
 
 class Config:

mypy/fastparse.py

@@ -4,7 +4,7 @@
 import sys
 import warnings
 from collections.abc import Sequence
-from typing import Any, Callable, Final, Literal, Optional, TypeVar, Union, cast, overload
+from typing import Any, Callable, Final, Literal, TypeVar, Union, cast, overload
 
 from mypy import defaults, errorcodes as codes, message_registry
 from mypy.errors import Errors
@@ -714,7 +714,7 @@ def fix_function_overloads(self, stmts: list[Statement]) -> list[Statement]:
                     current_overload.extend(if_block_with_overload.body[-1].items)
                 else:
                     current_overload.append(
-                        cast(Union[Decorator, FuncDef], if_block_with_overload.body[0])
+                        cast(Decorator | FuncDef, if_block_with_overload.body[0])
                     )
             else:
                 if last_if_stmt is not None:
@@ -760,7 +760,7 @@ def fix_function_overloads(self, stmts: list[Statement]) -> list[Statement]:
                             cast(list[IfStmt], if_block_with_overload.body[:-1])
                         )
                         last_if_overload = cast(
-                            Union[Decorator, FuncDef, OverloadedFuncDef],
+                            Decorator | FuncDef | OverloadedFuncDef,
                             if_block_with_overload.body[-1],
                         )
                     last_if_unknown_truth_value = if_unknown_truth_value
@@ -806,9 +806,7 @@ def _check_ifstmt_for_overloads(
         ):
             return None
 
-        overload_name = cast(
-            Union[Decorator, FuncDef, OverloadedFuncDef], stmt.body[0].body[-1]
-        ).name
+        overload_name = cast(Decorator | FuncDef | OverloadedFuncDef, stmt.body[0].body[-1]).name
         if stmt.else_body is None:
             return overload_name
 
@@ -991,7 +989,7 @@ def do_func_def(
                         self.errors, line=lineno, override_column=n.col_offset
                     ).translate_expr_list(func_type_ast.argtypes)
                     # Use a cast to work around `list` invariance
-                    arg_types = cast(list[Optional[Type]], translated_args)
+                    arg_types = cast(list[Type | None], translated_args)
                 return_type = TypeConverter(self.errors, line=lineno).visit(func_type_ast.returns)
 
                 # add implicit self type
@@ -1646,7 +1644,7 @@ def visit_Call(self, n: Call) -> CallExpr:
             self.visit(n.func),
             arg_types,
             arg_kinds,
-            cast("list[Optional[str]]", [None] * len(args)) + keyword_names,
+            cast("list[str | None]", [None] * len(args)) + keyword_names,
         )
         return self.set_line(e, n)