Merge remote-tracking branch 'upstream/master' into try-native-parser

Author: ilevkivskyi

mypy-requirements.txt

@@ -6,4 +6,4 @@ mypy_extensions>=1.0.0
 pathspec>=1.0.0
 tomli>=1.1.0; python_version<'3.11'
 librt>=0.9.0; platform_python_implementation != 'PyPy'
-ast-serialize>=0.2.0,<1.0.0
+ast-serialize>=0.2.2,<1.0.0

mypy/binder.py

@@ -3,7 +3,7 @@
 from collections import defaultdict
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Literal, NamedTuple, TypeAlias as _TypeAlias
+from typing import Final, Literal, TypeAlias as _TypeAlias
 
 from mypy.erasetype import remove_instance_last_known_values
 from mypy.literals import Key, extract_var_from_literal_hash, literal, literal_hash, subkeys
@@ -42,9 +42,10 @@
 BindableExpression: _TypeAlias = IndexExpr | MemberExpr | NameExpr
 
 
-class CurrentType(NamedTuple):
-    type: Type
-    from_assignment: bool
+class CurrentType:
+    def __init__(self, type: Type, from_assignment: bool) -> None:
+        self.type: Final = type
+        self.from_assignment: Final = from_assignment
 
 
 class Frame:

mypy/build.py

@@ -913,20 +913,20 @@ def __init__(
                 continue
             path = self.find_module_cache.find_module(module, fast_path=True)
             if not isinstance(path, str):
-                raise CompileError(
-                    [f"Failed to find builtin module {module}, perhaps typeshed is broken?"]
+                build_error(
+                    f'Failed to find builtin module "{module}", perhaps typeshed is broken?'
                 )
             if is_typeshed_file(options.abs_custom_typeshed_dir, path) or is_stub_package_file(
                 path
             ):
                 continue
 
-            raise CompileError(
-                [
-                    f'mypy: "{os.path.relpath(path)}" shadows library module "{module}"',
-                    f'note: A user-defined top-level module with name "{module}" is not supported',
-                ]
+            self.errors.set_file(path, module, options)
+            self.error(None, f'This file shadows library module "{module}"', blocker=True)
+            self.note(
+                None, f'A user-defined top-level module with name "{module}" is not supported'
             )
+            self.errors.raise_error()
 
         if metastore is None:
             metastore = create_metastore(options, parallel_worker=parallel_worker)
@@ -1255,7 +1255,19 @@ def all_imported_modules_in_file(self, file: MypyFile) -> list[tuple[int, str, i
         return res
 
     def is_module(self, id: str) -> bool:
-        """Is there a file in the file system corresponding to module id?"""
+        """Does the given fullname refer to a module?
+
+        Note: this does not always verify that the module exists and relies on
+        previously executed logic in find_module_and_diagnose().
+        """
+        if id in self.modules:
+            # Micro-optimization, if we already found it, it is definitely a module.
+            return True
+        if id in self.source_set.source_modules:
+            # Special case: if a module is passed on command line, we accept it even
+            # if we would not resolve it using regular mechanisms. This makes behavior
+            # consistent in cases like `mypy foo-stubs`, where stubs are not installed.
+            return True
         return find_module_simple(id, self) is not None
 
     def parse_file(
@@ -3149,7 +3161,7 @@ def get_source(self) -> str:
                     assert ioerr.errno is not None
                     raise CompileError(
                         [
-                            "mypy: error: cannot read file '{}': {}".format(
+                            "mypy: error: Cannot read file '{}': {}".format(
                                 self.path.replace(os.getcwd() + os.sep, ""),
                                 os.strerror(ioerr.errno),
                             )
@@ -3158,9 +3170,9 @@ def get_source(self) -> str:
                     ) from ioerr
                 except (UnicodeDecodeError, DecodeError) as decodeerr:
                     if self.path.endswith(".pyd"):
-                        err = f"{self.path}: error: stubgen does not support .pyd files"
+                        err = f"{self.path}: error: Stubgen does not support .pyd files"
                     else:
-                        err = f"{self.path}: error: cannot decode file: {str(decodeerr)}"
+                        err = f"{self.path}: error: Cannot decode file: {str(decodeerr)}"
                     raise CompileError([err], module_with_blocker=self.id) from decodeerr
             elif self.path and self.manager.fscache.isdir(self.path):
                 source = ""
@@ -3782,7 +3794,7 @@ def find_module_and_diagnose(
             # If we can't find a root source it's always fatal.
             # TODO: This might hide non-fatal errors from
             # root sources processed earlier.
-            raise CompileError([f"mypy: can't find module '{id}'"])
+            raise CompileError([f'mypy: error: Cannot find module "{id}"'])
         else:
             raise ModuleNotFound
 
@@ -3911,7 +3923,7 @@ def module_not_found(
     )
     if target == "builtins":
         manager.error(
-            line, "Cannot find 'builtins' module. Typeshed appears broken!", blocker=True
+            line, 'Cannot find "builtins" module. Typeshed appears broken!', blocker=True
         )
         errors.raise_error()
     else:

mypy/build_worker/worker.py

@@ -23,7 +23,7 @@
 import platform
 import sys
 import time
-from typing import NamedTuple
+from typing import Final
 
 from librt.internal import ReadBuffer, read_tag
 
@@ -65,12 +65,20 @@
 CONNECTION_NAME = "build_worker"
 
 
-class ServerContext(NamedTuple):
-    options: Options
-    disable_error_code: list[str]
-    enable_error_code: list[str]
-    errors: Errors
-    fscache: FileSystemCache
+class ServerContext:
+    def __init__(
+        self,
+        options: Options,
+        disable_error_code: list[str],
+        enable_error_code: list[str],
+        errors: Errors,
+        fscache: FileSystemCache,
+    ) -> None:
+        self.options: Final = options
+        self.disable_error_code: Final = disable_error_code
+        self.enable_error_code: Final = enable_error_code
+        self.errors: Final = errors
+        self.fscache: Final = fscache
 
 
 def main(argv: list[str]) -> None:

mypy/checker.py

@@ -353,10 +353,11 @@ class FineGrainedDeferredNode(NamedTuple):
 # Keeps track of partial types in a single scope. In fine-grained incremental
 # mode partial types initially defined at the top level cannot be completed in
 # a function, and we use the 'is_function' attribute to enforce this.
-class PartialTypeScope(NamedTuple):
-    map: dict[Var, Context]
-    is_function: bool
-    is_local: bool
+class PartialTypeScope:
+    def __init__(self, map: dict[Var, Context], is_function: bool, is_local: bool) -> None:
+        self.map: Final = map
+        self.is_function: Final = is_function
+        self.is_local: Final = is_local
 
 
 class LocalTypeMap:
@@ -1617,14 +1618,14 @@ def check_func_def(
                             else:
                                 msg = message_registry.MISSING_RETURN_STATEMENT
                             if body_is_trivial:
-                                msg = msg._replace(code=codes.EMPTY_BODY)
+                                msg = ErrorMessage(msg.value, code=codes.EMPTY_BODY)
                             self.fail(msg, defn)
                             if may_be_abstract:
                                 self.note(message_registry.EMPTY_BODY_ABSTRACT, defn)
                     else:
                         msg = message_registry.INCOMPATIBLE_RETURN_VALUE_TYPE
                         if body_is_trivial:
-                            msg = msg._replace(code=codes.EMPTY_BODY)
+                            msg = ErrorMessage(msg.value, code=codes.EMPTY_BODY)
                         # similar to code in check_return_stmt
                         if (
                             not self.check_subtype(
@@ -7208,14 +7209,23 @@ def replay_lookup(new_parent_type: ProperType) -> Type | None:
                     if int_literals is not None:
 
                         def replay_lookup(new_parent_type: ProperType) -> Type | None:
-                            if not isinstance(new_parent_type, TupleType):
-                                return None
-                            try:
-                                assert int_literals is not None
-                                member_types = [new_parent_type.items[key] for key in int_literals]
-                            except IndexError:
-                                return None
-                            return make_simplified_union(member_types)
+                            if isinstance(new_parent_type, TupleType):
+                                try:
+                                    assert int_literals is not None
+                                    member_types = [
+                                        new_parent_type.items[key] for key in int_literals
+                                    ]
+                                except IndexError:
+                                    return None
+                                return make_simplified_union(member_types)
+                            if (
+                                isinstance(new_parent_type, Instance)
+                                and new_parent_type.type.fullname
+                                in ("builtins.list", "builtins.tuple")
+                                and new_parent_type.args
+                            ):
+                                return new_parent_type.args[0]
+                            return None
 
                     else:
                         return output
@@ -7874,7 +7884,7 @@ def enter_partial_types(
             self.options.check_untyped_defs and self.dynamic_funcs and self.dynamic_funcs[-1]
         )
 
-        partial_types, _, _ = self.partial_types.pop()
+        partial_types = self.partial_types.pop().map
         if not self.current_node_deferred:
             for var, context in partial_types.items():
                 if isinstance(var.type, PartialType) and var.type.type is None and not permissive:
@@ -8914,24 +8924,9 @@ def reduce_and_conditional_type_maps(ms: list[TypeMap], *, use_meet: bool) -> Ty
     return result
 
 
-BUILTINS_CUSTOM_EQ_CHECKS: Final = {
-    "builtins.frozenset",
-    "_collections_abc.dict_keys",
-    "_collections_abc.dict_items",
-}
-
-
 def has_custom_eq_checks(t: Type) -> bool:
-    return (
-        custom_special_method(t, "__eq__", check_all=False)
-        or custom_special_method(t, "__ne__", check_all=False)
-        # custom_special_method has special casing for builtins.* and typing.* that make the
-        # above always return False. Some builtin collections still have equality behavior that
-        # crosses nominal type boundaries and isn't captured by VALUE_EQUALITY_TYPE_DOMAINS.
-        or (
-            isinstance(pt := get_proper_type(t), Instance)
-            and pt.type.fullname in BUILTINS_CUSTOM_EQ_CHECKS
-        )
+    return custom_special_method(t, "__eq__", check_all=False) or custom_special_method(
+        t, "__ne__", check_all=False
     )
 
 
@@ -9721,6 +9716,8 @@ def visit_starred_pattern(self, p: StarredPattern) -> None:
     "builtins.bytes": "builtins.bytes",
     "builtins.bytearray": "builtins.bytes",
     "builtins.memoryview": "builtins.bytes",
+    "typing.Mapping": "typing.Mapping",
+    "typing.AbstractSet": "typing.AbstractSet",
 }
 
 VALUE_EQUALITY_DOMAINS: Final = {**OPEN_VALUE_EQUALITY_DOMAINS, **CLOSED_VALUE_EQUALITY_DOMAINS}

mypy/checker_shared.py

@@ -5,7 +5,7 @@
 from abc import abstractmethod
 from collections.abc import Iterator, Sequence, Set as AbstractSet
 from contextlib import contextmanager
-from typing import NamedTuple, overload
+from typing import Final, overload
 
 from mypy_extensions import trait
 
@@ -42,9 +42,10 @@
 
 # An object that represents either a precise type or a type with an upper bound;
 # it is important for correct type inference with isinstance.
-class TypeRange(NamedTuple):
-    item: Type
-    is_upper_bound: bool  # False => precise type
+class TypeRange:
+    def __init__(self, item: Type, is_upper_bound: bool) -> None:
+        self.item: Final = item
+        self.is_upper_bound: Final = is_upper_bound  # False => precise type
 
 
 @trait

mypy/infer.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import NamedTuple
+from typing import Final
 
 from mypy.constraints import (
     SUBTYPE_OF,
@@ -16,7 +16,7 @@
 from mypy.types import CallableType, Instance, Type, TypeVarLikeType
 
 
-class ArgumentInferContext(NamedTuple):
+class ArgumentInferContext:
     """Type argument inference context.
 
     We need this because we pass around ``Mapping`` and ``Iterable`` types.
@@ -26,8 +26,9 @@ class ArgumentInferContext(NamedTuple):
     https://github.com/python/mypy/issues/11144
     """
 
-    mapping_type: Instance
-    iterable_type: Instance
+    def __init__(self, mapping_type: Instance, iterable_type: Instance) -> None:
+        self.mapping_type: Final = mapping_type
+        self.iterable_type: Final = iterable_type
 
 
 def infer_function_type_arguments(

mypy/main.py

@@ -101,7 +101,14 @@ def main(
         # Supporting both parsers would be really tricky, so just support the new one.
         options.native_parser = True
         if options.cache_dir == os.devnull:
-            fail("error: cache must be enabled in parallel mode", stderr, options)
+            fail("error: Cache must be enabled in parallel mode", stderr, options)
+        if options.report_dirs:
+            fail(
+                "error: Reports are not supported in parallel mode yet\n"
+                "note: Use -n0 to disable parallel checking",
+                stderr,
+                options,
+            )
 
     if options.allow_redefinition and not options.local_partial_types:
         fail(
@@ -1577,7 +1584,8 @@ def set_strict_flags() -> None:
                 reason = cache.find_module(p)
                 if reason is ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS:
                     fail(
-                        f"Package '{p}' cannot be type checked due to missing py.typed marker. See https://mypy.readthedocs.io/en/stable/installed_packages.html for more details",
+                        f"Package '{p}' cannot be type checked due to missing py.typed marker.\n"
+                        "See https://mypy.readthedocs.io/en/stable/installed_packages.html for more details",
                         stderr,
                         options,
                     )
@@ -1698,7 +1706,7 @@ def read_types_packages_to_install(cache_dir: str, after_run: bool) -> list[str]
         if not after_run:
             sys.stderr.write(
                 "error: Can't determine which types to install with no files to check "
-                + "(and no cache from previous mypy run)\n"
+                "(and no cache from previous mypy run)\n"
             )
         else:
             sys.stderr.write(

mypy/meet.py

@@ -173,6 +173,15 @@ def narrow_declared_type(declared: Type, narrowed: Type) -> Type:
         return declared.copy_modified(
             upper_bound=narrow_declared_type(declared.upper_bound, original_narrowed)
         )
+    elif (
+        isinstance(narrowed, TypeVarType)
+        and not has_type_vars(original_declared)
+        and is_subtype(original_declared, narrowed.upper_bound)
+    ):
+        # This branch is a mirror image of the above one.
+        return narrowed.copy_modified(
+            upper_bound=narrow_declared_type(original_declared, narrowed.upper_bound)
+        )
     elif not is_overlapping_types(declared, narrowed):
         if state.strict_optional:
             return UninhabitedType()

mypy/message_registry.py

@@ -8,15 +8,16 @@
 
 from __future__ import annotations
 
-from typing import Final, NamedTuple
+from typing import Final
 
 from mypy import errorcodes as codes
 from mypy.errorcodes import ErrorCode
 
 
-class ErrorMessage(NamedTuple):
-    value: str
-    code: ErrorCode | None = None
+class ErrorMessage:
+    def __init__(self, value: str, code: ErrorCode | None = None) -> None:
+        self.value: Final = value
+        self.code: Final = code
 
     def format(self, *args: object, **kwargs: object) -> ErrorMessage:
         return ErrorMessage(self.value.format(*args, **kwargs), code=self.code)