Drop support for --python-version 3.9 (#21243)

Resolves #20154

It's getting close to time. Typeshed will drop support in a few days.

Co-authored-by Codex

Author: hauntsaninja

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Next Release
 
+### Drop Support for Targeting Python 3.9
+
+Mypy no longer supports type checking code with `--python-version 3.9`.
+Use `--python-version 3.10` or newer.
+
 ## Mypy 1.20
 
 We’ve just uploaded mypy 1.20.0 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).

docs/source/builtin_types.rst

@@ -40,8 +40,7 @@ See :ref:`dynamic-typing` for more details.
 Generic types
 .............
 
-In Python 3.9 and later, built-in collection type objects support
-indexing:
+Built-in collection type objects support indexing:
 
 ====================== ===============================
 Type                   Description
@@ -65,13 +64,11 @@ strings and ``dict[Any, Any]`` is a dictionary of dynamically typed
 Python protocols. For example, a ``str`` object or a ``list[str]`` object is
 valid when ``Iterable[str]`` or ``Sequence[str]`` is expected.
 You can import them from :py:mod:`collections.abc` instead of importing from
-:py:mod:`typing` in Python 3.9.
+:py:mod:`typing`.
 
-See :ref:`generic-builtins` for more details, including how you can
-use these in annotations also in Python 3.7 and 3.8.
+See :ref:`generic-builtins` for more details.
 
-These legacy types defined in :py:mod:`typing` are needed if you need to support
-Python 3.8 and earlier:
+These legacy types defined in :py:mod:`typing` are also supported:
 
 ====================== ===============================
 Type                   Description
@@ -80,17 +77,5 @@ Type                   Description
 ``Tuple[int, int]``    tuple of two ``int`` objects (``Tuple[()]`` is the empty tuple)
 ``Tuple[int, ...]``    tuple of an arbitrary number of ``int`` objects
 ``Dict[str, int]``     dictionary from ``str`` keys to ``int`` values
-``Iterable[int]``      iterable object containing ints
-``Sequence[bool]``     sequence of booleans (read-only)
-``Mapping[str, int]``  mapping from ``str`` keys to ``int`` values (read-only)
 ``Type[C]``            type object of ``C`` (``C`` is a class/type variable/union of types)
 ====================== ===============================
-
-``List`` is an alias for the built-in type ``list`` that supports
-indexing (and similarly for ``dict``/``Dict`` and
-``tuple``/``Tuple``).
-
-Note that even though ``Iterable``, ``Sequence`` and ``Mapping`` look
-similar to abstract base classes defined in :py:mod:`collections.abc`
-(formerly ``collections``), they are not identical, since the latter
-don't support indexing prior to Python 3.9.

docs/source/cheat_sheet_py3.rst

@@ -43,18 +43,18 @@ Useful built-in types
    x: str = "test"
    x: bytes = b"test"
 
-   # For collections on Python 3.9+, the type of the collection item is in brackets
+   # For collections, the type of the collection item is in brackets
    x: list[int] = [1]
    x: set[int] = {6, 7}
 
    # For mappings, we need the types of both keys and values
-   x: dict[str, float] = {"field": 2.0}  # Python 3.9+
+   x: dict[str, float] = {"field": 2.0}
 
    # For tuples of fixed size, we specify the types of all the elements
-   x: tuple[int, str, float] = (3, "yes", 7.5)  # Python 3.9+
+   x: tuple[int, str, float] = (3, "yes", 7.5)
 
    # For tuples of variable size, we use one type and ellipsis
-   x: tuple[int, ...] = (1, 2, 3)  # Python 3.9+
+   x: tuple[int, ...] = (1, 2, 3)
 
    # On Python 3.8 and earlier, the name of the collection type is
    # capitalized, and the type is imported from the 'typing' module
@@ -67,13 +67,12 @@ Useful built-in types
 
    from typing import Union, Optional
 
-   # On Python 3.10+, use the | operator when something could be one of a few types
-   x: list[int | str] = [3, 5, "test", "fun"]  # Python 3.10+
-   # On earlier versions, use Union
+   # Use the | operator when something could be one of a few types
+   x: list[int | str] = [3, 5, "test", "fun"]
+   # Union is equivalent
    x: list[Union[int, str]] = [3, 5, "test", "fun"]
 
-   # Use X | None for a value that could be None on Python 3.10+
-   # Use Optional[X] on 3.9 and earlier; Optional[X] is the same as 'X | None'
+   # Use X | None for a value that could be None; Optional[X] is the same as X | None
    x: str | None = "something" if some_condition() else None
    if x is not None:
        # Mypy understands x won't be None here because of the if-statement

docs/source/common_issues.rst

@@ -671,7 +671,7 @@ subtly different, and it's important to understand how they differ to avoid pitf
 
    .. code-block:: python
 
-     from typing import TypeAlias  # "from typing_extensions" in Python 3.9 and earlier
+     from typing import TypeAlias
 
      class A: ...
      Alias: TypeAlias = A

docs/source/config_file.rst

@@ -432,7 +432,7 @@ Platform configuration
 
     Specifies the Python version used to parse and check the target
     program.  The string should be in the format ``MAJOR.MINOR`` --
-    for example ``3.9``.  The default is the version of the Python
+    for example ``3.10``.  The default is the version of the Python
     interpreter used to run mypy.
 
     This option may only be set in the global section (``[mypy]``).
@@ -1255,7 +1255,7 @@ of your repo (or append it to the end of an existing ``pyproject.toml`` file) an
     # mypy global options:
 
     [tool.mypy]
-    python_version = "3.9"
+    python_version = "3.10"
     warn_return_any = true
     warn_unused_configs = true
     exclude = [

docs/source/generics.rst

@@ -1419,8 +1419,7 @@ class in more recent versions of Python:
 
 .. code-block:: python
 
-   >>> # Only relevant for Python 3.8 and below
-   >>> # If using Python 3.9 or newer, prefer the 'list[int]' syntax
+   >>> # Prefer the 'list[int]' syntax
    >>> from typing import List
    >>> List[int]
    typing.List[int]

docs/source/getting_started.rst

@@ -197,12 +197,6 @@ union type. For example, ``int`` is a subtype of ``int | str``:
        else:
            return user_id
 
-.. note::
-
-    If using Python 3.9 or earlier, use ``typing.Union[int, str]`` instead of
-    ``int | str``, or use ``from __future__ import annotations`` at the top of
-    the file (see :ref:`runtime_troubles`).
-
 The :py:mod:`typing` module contains many other useful types.
 
 For a quick overview, look through the :ref:`mypy cheatsheet <cheat-sheet-py3>`.

docs/source/kinds_of_types.rst

@@ -315,9 +315,8 @@ such as ``int | None``. This is called an *optional type*:
            return None  # Error: None not compatible with int
        return len(s)
 
-To support Python 3.9 and earlier, you can use the :py:data:`~typing.Optional`
-type modifier instead, such as ``Optional[int]`` (``Optional[X]`` is
-the preferred shorthand for ``Union[X, None]``):
+You can also use the :py:data:`~typing.Optional` type modifier, such as
+``Optional[int]`` (``Optional[X]`` is the shorthand for ``Union[X, None]``):
 
 .. code-block:: python
 
@@ -515,12 +514,11 @@ distinguish them from implicit type aliases:
   it can't be used in contexts which require a class object. For example, it's
   not valid as a base class and it can't be used to construct instances.
 
-There is also use an older syntax for defining explicit type aliases, which was
-introduced in Python 3.10 (:pep:`613`):
+There is also use an older syntax for defining explicit type aliases (:pep:`613`):
 
 .. code-block:: python
 
-   from typing import TypeAlias  # "from typing_extensions" in Python 3.9 and earlier
+   from typing import TypeAlias
 
    AliasType: TypeAlias = list[dict[tuple[int, str], set[int]]] | tuple[str, list[str]]
 

docs/source/protocols.rst

@@ -66,11 +66,6 @@ you need to define to implement each protocol.
 .. note::
     ``typing`` also contains deprecated aliases to protocols and ABCs defined in
     :py:mod:`collections.abc`, such as :py:class:`Iterable[T] <typing.Iterable>`.
-    These are only necessary in Python 3.8 and earlier, since the protocols in
-    ``collections.abc`` didn't yet support subscripting (``[]``) in Python 3.8,
-    but the aliases in ``typing`` have always supported
-    subscripting. In Python 3.9 and later, the aliases in ``typing`` don't provide
-    any extra functionality.
 
 Simple user-defined protocols
 *****************************

docs/source/type_inference_and_annotations.rst

@@ -94,14 +94,6 @@ In these cases you can give the type explicitly using a type annotation:
    l: list[int] = []       # Create empty list of int
    d: dict[str, int] = {}  # Create empty dictionary (str -> int)
 
-.. note::
-
-   Using type arguments (e.g. ``list[int]``) on builtin collections like
-   :py:class:`list`,  :py:class:`dict`, :py:class:`tuple`, and  :py:class:`set`
-   only works in Python 3.9 and later. For Python 3.8 and earlier, you must use
-   :py:class:`~typing.List` (e.g. ``List[int]``), :py:class:`~typing.Dict`, and
-   so on.
-
 
 Compatibility of container types
 ********************************