Merge branch 'master' into literals_as_anyof_types

Author: randolf-scholz

.github/workflows/test.yml

@@ -205,7 +205,7 @@ 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 }}
@@ -268,7 +268,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

.pre-commit-config.yaml

@@ -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

CHANGELOG.md

@@ -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]

MANIFEST.in

@@ -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,7 +598,7 @@ of the above sections.
 .. option:: --allow-redefinition-new
 
     By default, mypy won't allow a variable to be redefined with an
-    unrelated type. This flag enables the redefinition of unannotated
+    unrelated type. This 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:
@@ -631,9 +631,20 @@ 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.
 
 .. option:: --allow-redefinition
 
@@ -1007,9 +1018,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
 

docs/source/command_line.rst

@@ -228,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
 --------------------------
@@ -302,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

docs/source/common_issues.rst

@@ -748,6 +748,18 @@ section of the command line docs.
                 # 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 :confval:`local_partial_types`.
 
@@ -967,7 +979,7 @@ These options may only be set in the global section (``[mypy]``).
 .. confval:: sqlite_cache
 
     :type: boolean
-    :default: False
+    :default: True
 
     Use an `SQLite`_ database to store the cache.
 

docs/source/config_file.rst

@@ -693,10 +693,11 @@ contravariant, use type variables defined with special keyword arguments
    my_box = Box(Square())
    look_into(my_box)  # OK, but mypy would complain here for an invariant type
 
+.. _value-constrained-type-variables:
 .. _type-variable-value-restriction:
 
-Type variables with value restriction
-*************************************
+Value-constrained type variables
+*********************************
 
 By default, a type variable can be replaced with any type -- or any type that
 is a subtype of the upper bound, which defaults to ``object``. However, sometimes
@@ -727,8 +728,9 @@ The same thing is also possibly using the legacy syntax (Python 3.11 or earlier)
    def concat(x: AnyStr, y: AnyStr) -> AnyStr:
        return x + y
 
-No matter which syntax you use, such a type variable is called a type variable
-with a value restriction. Importantly, this is different from a union type,
+No matter which syntax you use, such a type variable is called a
+value-constrained type variable (the allowed types are accessible at runtime
+via ``TypeVar.__constraints__``). Importantly, this is different from a union type,
 since combinations of ``str`` and ``bytes`` are not accepted:
 
 .. code-block:: python
@@ -760,7 +762,7 @@ for the type variable, which in this case is ``str``.
 
 This is thus subtly different from using ``str | bytes`` as an upper bound,
 where the return type would be ``S`` (see :ref:`type-variable-upper-bound`).
-Using a value restriction is correct for ``concat``, since ``concat``
+Using a value constraint is correct for ``concat``, since ``concat``
 actually returns a ``str`` instance in the above example:
 
 .. code-block:: python
@@ -775,7 +777,7 @@ value of :py:func:`re.compile`, where ``S`` can be either ``str``
 or ``bytes``. Regular expressions can be based on a string or a
 bytes pattern.
 
-A type variable may not have both a value restriction and an upper bound.
+A type variable may not have both value constraints and an upper bound.
 
 Note that you may come across :py:data:`~typing.AnyStr` imported from
 :py:mod:`typing`. This feature is now deprecated, but it means the same
@@ -1330,7 +1332,7 @@ Here are examples using the legacy syntax (Python 3.11 and earlier):
     for i, j in NewVec[int]():
         ...
 
-Using type variable bounds or value restriction in generic aliases has
+Using type variable bounds or value constraints in generic aliases has
 the same effect as in generic classes and functions.
 
 

docs/source/generics.rst

@@ -303,8 +303,8 @@ Here is the same example using the legacy syntax (Python 3.11 and earlier):
 .. note::
 
    If you just need to constrain a type variable to certain types or
-   subtypes, you can use a :ref:`value restriction
-   <type-variable-value-restriction>`.
+   subtypes, you can use a :ref:`value-constrained type variable
+   <value-constrained-type-variables>`.
 
 The default values of a function's arguments don't affect its signature -- only
 the absence or presence of a default value does. So in order to reduce

docs/source/more_types.rst

@@ -126,7 +126,7 @@ For example:
             """Some docstring"""
             pass
 
-        # Error: Incompatible default for argument "foo" (default has
-        # type "ellipsis", argument has type "list[str]")
+        # Error: Incompatible default for parameter "foo" (default has
+        # type "ellipsis", parameter has type "list[str]")
         def not_ok(self, foo: list[str] = ...) -> None:
             print(foo)