Merge branch 'master' into bug/generic-namedtuple-match-pattern

Author: paulorochaoliveira

.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:
@@ -645,7 +645,6 @@ of the above sections.
 
     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
 

docs/source/command_line.rst

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

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

@@ -183,6 +183,11 @@ The rest of this section documents the command line interface of stubtest.
 
     Ignore errors for whether an argument should or shouldn't be positional-only
 
+.. option:: --strict-type-check-only
+
+    Require :py:func:`@type_check_only <typing.type_check_only>` on private types
+    that are not present at runtime.
+
 .. option:: --allowlist FILE
 
     Use file as an allowlist. Can be passed multiple times to combine multiple

docs/source/stubtest.rst

@@ -146,6 +146,8 @@
 from mypy.fixup import fixup_module
 from mypy.freetree import free_tree
 from mypy.fscache import FileSystemCache
+from mypy.known_modules import get_known_modules, reset_known_modules_cache
+from mypy.messages import best_matches, pretty_seq
 from mypy.metastore import FilesystemMetadataStore, MetadataStore, SqliteMetadataStore
 from mypy.modulefinder import (
     BuildSource as BuildSource,
@@ -355,6 +357,7 @@ def build(
 
     # This is mostly for the benefit of tests that use builtins fixtures.
     instance_cache.reset()
+    reset_known_modules_cache()
 
     def default_flush_errors(
         filename: str | None, new_messages: list[str], is_serious: bool
@@ -3562,6 +3565,27 @@ def module_not_found(
             code = codes.IMPORT
         manager.error(line, msg.format(module=target), code=code)
 
+        if (
+            reason == ModuleNotFoundReason.NOT_FOUND
+            and not errors.prefer_simple_messages()
+            and line not in errors.ignored_lines.get(caller_state.xpath, {})
+        ):
+            top_level_target = target.split(".")[0]
+            if not top_level_target.startswith("_"):
+                known_modules = get_known_modules(
+                    manager.find_module_cache.stdlib_py_versions, manager.options.python_version
+                )
+                matches = best_matches(top_level_target, known_modules, n=3)
+                matches = [m for m in matches if m.lower() != top_level_target.lower()]
+                if matches:
+                    errors.report(
+                        line,
+                        0,
+                        f'Did you mean {pretty_seq(matches, "or")}?',
+                        severity="note",
+                        code=code,
+                    )
+
         dist = stub_distribution_name(target)
         for note in notes:
             if "{stub_dist}" in note:

mypy/build.py

@@ -6803,11 +6803,14 @@ def narrow_type_by_identity_equality(
                     # It is correct to always narrow here. It improves behaviour on tests and
                     # detects many inaccurate type annotations on primer.
                     # However, because mypy does not currently check unreachable code, it feels
-                    # risky to narrow to unreachable without --warn-unreachable.
+                    # risky to narrow to unreachable without --warn-unreachable or not
+                    # at module level
                     # See also this specific primer comment, where I force primer to run with
                     # --warn-unreachable to see what code we would stop checking:
                     # https://github.com/python/mypy/pull/20660#issuecomment-3865794148
-                    if self.options.warn_unreachable or not is_unreachable_map(if_map):
+                    if (
+                        self.options.warn_unreachable and len(self.scope.stack) != 1
+                    ) or not is_unreachable_map(if_map):
                         all_if_maps.append(if_map)
 
         # Handle narrowing for operands with custom __eq__ methods specially