python
diff --git a/‎.github/workflows/test.yml‎
Lines changed: 10 additions & 2 deletions b/‎.github/workflows/test.yml‎
Lines changed: 10 additions & 2 deletions
diff --git a/‎.pre-commit-config.yaml‎
Lines changed: 1 addition & 1 deletion b/‎.pre-commit-config.yaml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎CHANGELOG.md‎
Lines changed: 600 additions & 2 deletions b/‎CHANGELOG.md‎
Lines changed: 600 additions & 2 deletions
diff --git a/‎MANIFEST.in‎
Lines changed: 5 additions & 2 deletions b/‎MANIFEST.in‎
Lines changed: 5 additions & 2 deletions
diff --git a/‎docs/source/builtin_types.rst‎
Lines changed: 4 additions & 19 deletions b/‎docs/source/builtin_types.rst‎
Lines changed: 4 additions & 19 deletions
diff --git a/‎docs/source/cheat_sheet_py3.rst‎
Lines changed: 8 additions & 9 deletions b/‎docs/source/cheat_sheet_py3.rst‎
Lines changed: 8 additions & 9 deletions
diff --git a/‎docs/source/command_line.rst‎
Lines changed: 50 additions & 33 deletions b/‎docs/source/command_line.rst‎
Lines changed: 50 additions & 33 deletions
diff --git a/‎docs/source/common_issues.rst‎
Lines changed: 19 additions & 6 deletions b/‎docs/source/common_issues.rst‎
Lines changed: 19 additions & 6 deletions
@@ -112,6 +112,11 @@ jobs:
           toxenv: py
           tox_extra_args: "-n 4 --mypy-num-workers=4 mypy/test/testcheck.py"
           test_mypyc: true
+        - name: Parallel tests with py314-windows-64, interpreted
+          python: '3.14'
+          os: windows-latest
+          toxenv: py
+          tox_extra_args: "-n 2 --mypy-num-workers=2 mypy/test/testcheck.py -k 'incremental or modules or classes'"
 
         - name: Type check our own code (py310-ubuntu)
           python: '3.10'
@@ -134,6 +139,7 @@ jobs:
     timeout-minutes: 60
     env:
       TOX_SKIP_MISSING_INTERPRETERS: False
+      VIRTUALENV_SYSTEM_SITE_PACKAGES: ${{ matrix.test_mypyc && 1 || 0 }}
       # Rich (pip) -- Disable color for windows + pytest
       FORCE_COLOR: ${{ !(startsWith(matrix.os, 'windows-') && startsWith(matrix.toxenv, 'py')) && 1 || 0 }}
       # Tox
@@ -200,12 +206,14 @@ jobs:
         echo debug build; python -c 'import sysconfig; print(bool(sysconfig.get_config_var("Py_DEBUG")))'
         echo os.cpu_count; python -c 'import os; print(os.cpu_count())'
         echo os.sched_getaffinity; python -c 'import os; print(len(getattr(os, "sched_getaffinity", lambda *args: [])(0)))'
-        pip install setuptools==75.1.0 tox==4.26.0
+        pip install tox==4.26.0
 
     - name: Compiled with mypyc
       if: ${{ matrix.test_mypyc }}
+      # Use local version of librt during self-compilation in tests.
       run: |
         pip install -r test-requirements.txt
+        pip install -U mypyc/lib-rt
         CC=clang MYPYC_OPT_LEVEL=0 MYPY_USE_MYPYC=1 pip install -e .
 
     - name: Setup tox environment
@@ -263,7 +271,7 @@ jobs:
           default: 3.11.1
           command: python -c "import platform; print(f'{platform.architecture()=} {platform.machine()=}');"
       - name: Install tox
-        run: pip install setuptools==75.1.0 tox==4.26.0
+        run: pip install tox==4.26.0
       - name: Setup tox environment
         run: tox run -e py --notest
       - name: Test
 
@@ -26,7 +26,7 @@ repos:
     hooks:
       - id: codespell
         args:
-          - --ignore-words-list=HAX,ccompiler,ot,statics,whet,zar
+          - --ignore-words-list=HAX,Nam,ccompiler,ot,statics,whet,zar
         exclude: ^(mypy/test/|mypy/typeshed/|mypyc/test-data/|test-data/).+$
   - repo: https://github.com/rhysd/actionlint
     rev: v1.7.7
 
@@ -5,6 +5,7 @@
 prune mypy/typeshed
 include mypy/typeshed/LICENSE
 include mypy/typeshed/stdlib/VERSIONS
+include mypy/typeshed/stdlib/_typeshed/README.md
 recursive-include mypy/typeshed *.pyi
 
 # mypy and mypyc
@@ -38,14 +39,16 @@ include test-requirements.in
 include test-requirements.txt
 include mypy_self_check.ini
 prune misc
+include misc/diff-cache.py
+include misc/apply-cache-diff.py
 graft test-data
 graft mypy/test
 include conftest.py
 include runtests.py
 include tox.ini
 
-include LICENSE mypyc/README.md CHANGELOG.md
-exclude .gitmodules CONTRIBUTING.md CREDITS ROADMAP.md action.yml .editorconfig
+include LICENSE mypyc/README.md CHANGELOG.md CREDITS
+exclude .gitmodules CONTRIBUTING.md ROADMAP.md action.yml .editorconfig
 exclude .git-blame-ignore-revs .pre-commit-config.yaml
 
 global-exclude *.py[cod]
 
@@ -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.
@@ -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
 
@@ -551,7 +551,7 @@ potentially problematic or redundant in some way.
     .. note::
 
         Mypy currently cannot detect and report unreachable or redundant code
-        inside any functions using :ref:`type-variable-value-restriction`.
+        inside any functions using :ref:`value-constrained type variables <value-constrained-type-variables>`.
 
         This limitation will be removed in future releases of mypy.
 
@@ -598,10 +598,10 @@ of the above sections.
 .. option:: --allow-redefinition-new
 
     By default, mypy won't allow a variable to be redefined with an
-    unrelated type. This *experimental* flag enables the redefinition of
-    unannotated variables with an arbitrary type. You will also need to enable
-    :option:`--local-partial-types <mypy --local-partial-types>`.
-    Example:
+    unrelated type. This flag enables the redefinition of *unannotated*
+    variables with an arbitrary type. This also requires
+    :option:`--local-partial-types <mypy --no-local-partial-types>`, which is
+    enabled by default starting from mypy 2.0. Example:
 
     .. code-block:: python
 
@@ -631,12 +631,30 @@ of the above sections.
                 # Type of "x" is "str" here.
                 ...
 
+    Function arguments are special, changing their type within function body
+    is allowed even if they are annotated, but that annotation is used to infer
+    types of r.h.s. of all subsequent assignments. Such middle-ground semantics
+    provides good balance for majority of common use cases. For example:
+
+    .. code-block:: python
+
+        def process(values: list[float]) -> None:
+            if not values:
+                values = [0, 0, 0]
+            reveal_type(values)  # Revealed type is list[float]
+
     Note: We are planning to turn this flag on by default in a future mypy
-    release, along with :option:`--local-partial-types <mypy --local-partial-types>`.
-    The feature is still experimental, and the semantics may still change.
+    release.
 
 .. option:: --allow-redefinition
 
+    This is an alias to :option:`--allow-redefinition-old <mypy --allow-redefinition-old>`.
+    In mypy v2.0 this will point to
+    :option:`--allow-redefinition-new <mypy --allow-redefinition-new>`, and will
+    eventually became the default.
+
+.. option:: --allow-redefinition-old
+
     This is an older variant of
     :option:`--allow-redefinition-new <mypy --allow-redefinition-new>`.
     This flag enables redefinition of a variable with an
@@ -666,30 +684,26 @@ of the above sections.
            items = "100"  # valid, items now has type str
            items = int(items)  # valid, items now has type int
 
-.. option:: --local-partial-types
+.. option:: --no-local-partial-types
 
-    In mypy, the most common cases for partial types are variables initialized using ``None``,
-    but without explicit ``X | None`` annotations. By default, mypy won't check partial types
-    spanning module top level or class top level. This flag changes the behavior to only allow
-    partial types at local level, therefore it disallows inferring variable type for ``None``
-    from two assignments in different scopes. For example:
+    Disable local partial types to enable legacy type inference mode for
+    containers.
 
-    .. code-block:: python
+    Local partial types prevent inferring a container type for a variable, when
+    the initial assignment happens at module top level or in a class body, and
+    the container item type is only set in a function. Example:
 
-        a = None  # Need type annotation here if using --local-partial-types
-        b: int | None = None
+    .. code-block:: python
 
-        class Foo:
-            bar = None  # Need type annotation here if using --local-partial-types
-            baz: int | None = None
+        a = []  # Need type annotation unless using --no-local-partial-types
 
-            def __init__(self) -> None:
-                self.bar = 1
+        def func() -> None:
+            a.append(1)
 
-        reveal_type(Foo().bar)  # 'int | None' without --local-partial-types
+        reveal_type(a)  # "list[int]" if using --no-local-partial-types
 
-    Note: this option is always implicitly enabled in mypy daemon and will become
-    enabled by default for mypy in a future release.
+    Local partial types are enabled by default starting from mypy 2.0. The
+    mypy daemon requires local partial types.
 
 .. option:: --no-implicit-reexport
 
@@ -746,11 +760,11 @@ of the above sections.
     Note that :option:`--strict-equality-for-none <mypy --strict-equality-for-none>`
     only works in combination with :option:`--strict-equality <mypy --strict-equality>`.
 
-.. option:: --strict-bytes
+.. option:: --no-strict-bytes
 
-    By default, mypy treats ``bytearray`` and ``memoryview`` as subtypes of ``bytes`` which
-    is not true at runtime. Use this flag to disable this behavior. ``--strict-bytes`` will
-    be enabled by default in *mypy 2.0*.
+    Treat ``bytearray`` and ``memoryview`` as subtypes of ``bytes``. This is not true
+    at runtime and can lead to unexpected behavior. This was the default behavior prior
+    to mypy 2.0.
 
     .. code-block:: python
 
@@ -759,10 +773,12 @@ of the above sections.
            with open("binary_file", "wb") as fp:
                fp.write(buf)
 
-       f(bytearray(b""))  # error: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
-       f(memoryview(b""))  # error: Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
+       # Using --no-strict-bytes disables the following errors
+       f(bytearray(b""))  # Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+       f(memoryview(b""))  # Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
 
-       # If `f` accepts any object that implements the buffer protocol, consider using:
+       # If `f` accepts any object that implements the buffer protocol,
+       # consider using Buffer instead:
        from collections.abc import Buffer  # "from typing_extensions" in Python 3.11 and earlier
 
        def f(buf: Buffer) -> None:
@@ -1000,9 +1016,10 @@ beyond what incremental mode can offer, try running mypy in
     writing to the cache, use ``--cache-dir=/dev/null`` (UNIX)
     or ``--cache-dir=nul`` (Windows).
 
-.. option:: --sqlite-cache
+.. option:: --no-sqlite-cache
 
-    Use an `SQLite`_ database to store the cache.
+    Avoid using `SQLite`_ database to store the cache, instead write cache data
+    out to individual files.
 
 .. option:: --cache-fine-grained
 
 
@@ -148,6 +148,14 @@ error:
 The second line is now fine, since the ignore comment causes the name
 ``frobnicate`` to get an implicit ``Any`` type.
 
+The type ignore comment must be at the start of the comments on a line.
+This type ignore will not take effect:
+
+.. code-block:: python
+
+    import frobnicate  #example other comment # type: ignore
+    frobnicate.start()
+
 .. note::
 
     You can use the form ``# type: ignore[<code>]`` to only ignore
@@ -220,11 +228,12 @@ make cold mypy runs several times faster.
 
 Furthermore: as of `mypy 1.13 <https://mypy-lang.blogspot.com/2024/10/mypy-113-released.html>`_,
 mypy allows use of the orjson library for handling the cache instead of the stdlib json, for
-improved performance. You can ensure the presence of orjson using the faster-cache extra:
+improved performance. You can ensure the presence of orjson using the ``faster-cache`` extra:
 
     python3 -m pip install -U mypy[faster-cache]
 
-Mypy may depend on orjson by default in the future.
+Mypy may depend on orjson by default in the future. To use faster, native parser, use the
+``native-parse`` extra. Native parser will be default in near future.
 
 Types of empty collections
 --------------------------
@@ -294,9 +303,13 @@ See :ref:`type-narrowing` for more information.
 Invariance vs covariance
 ------------------------
 
-Most mutable generic collections are invariant, and mypy considers all
-user-defined generic classes invariant by default
-(see :ref:`variance-of-generics` for motivation). This could lead to some
+Most mutable generic collections are invariant. When using the legacy
+``TypeVar`` syntax, mypy considers all user-defined generic classes invariant
+by default (see :ref:`variance-of-generics` for motivation). When using the
+:pep:`695` syntax (``class MyClass[T]: ...``), variance is inferred from
+usage rather than defaulting to invariant.
+
+The fact that mutable sequences are usually invariant can lead to some
 unexpected errors when combined with type inference. For example:
 
 .. code-block:: python
@@ -658,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