Merge remote-tracking branch 'upstream/master' into intf-impl-parallel

Author: ilevkivskyi

.github/workflows/test.yml

@@ -139,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
@@ -209,8 +210,10 @@ jobs:
 
     - 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

misc/typeshed_patches/0001-Revert-dict.__or__-typeshed-change.patch

@@ -0,0 +1,30 @@
+From d88a4b774fc59ecd0f2d0fdda8e0e61092adafd3 Mon Sep 17 00:00:00 2001
+From: Ivan Levkivskyi <levkivskyi@gmail.com>
+Date: Wed, 8 Apr 2026 00:01:44 +0100
+Subject: [PATCH] Revert dict.__or__ typeshed change
+
+---
+ mypy/typeshed/stdlib/builtins.pyi | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
+index 674142d70..25b21ba97 100644
+--- a/mypy/typeshed/stdlib/builtins.pyi
++++ b/mypy/typeshed/stdlib/builtins.pyi
+@@ -1142,7 +1142,13 @@ class dict(MutableMapping[_KT, _VT]):
+     def __reversed__(self) -> Iterator[_KT]: ...
+     __hash__: ClassVar[None]  # type: ignore[assignment]
+     def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
++    @overload
++    def __or__(self, value: dict[_KT, _VT], /) -> dict[_KT, _VT]: ...
++    @overload
+     def __or__(self, value: dict[_T1, _T2], /) -> dict[_KT | _T1, _VT | _T2]: ...
++    @overload
++    def __ror__(self, value: dict[_KT, _VT], /) -> dict[_KT, _VT]: ...
++    @overload
+     def __ror__(self, value: dict[_T1, _T2], /) -> dict[_KT | _T1, _VT | _T2]: ...
+     # dict.__ior__ should be kept roughly in line with MutableMapping.update()
+     @overload  # type: ignore[misc]
+-- 
+2.25.1
+

mypy-requirements.txt

@@ -4,4 +4,4 @@ typing_extensions>=4.6.0
 mypy_extensions>=1.0.0
 pathspec>=1.0.0
 tomli>=1.1.0; python_version<'3.11'
-librt>=0.8.0; platform_python_implementation != 'PyPy'
+librt>=0.9.0; platform_python_implementation != 'PyPy'

mypy/build.py

@@ -145,7 +145,8 @@
 
 from mypy import errorcodes as codes
 from mypy.config_parser import get_config_module_names, parse_mypy_comments
-from mypy.fixup import fixup_module
+from mypy.fixer_state import fixer_state
+from mypy.fixup import NodeFixer
 from mypy.freetree import free_tree
 from mypy.fscache import FileSystemCache
 from mypy.known_modules import get_known_modules, reset_known_modules_cache
@@ -814,6 +815,10 @@ def __init__(
         self.options = options
         self.version_id = version_id
         self.modules: dict[str, MypyFile] = {}
+        # Share same modules dictionary with the global fixer state.
+        # We need to set allow_missing when doing a fine-grained cache
+        # load because we need to gracefully handle missing modules.
+        fixer_state.node_fixer = NodeFixer(self.modules, self.options.use_fine_grained_cache)
         self.import_map: dict[str, set[str]] = {}
         self.missing_modules: dict[str, int] = {}
         self.fg_deps_meta: dict[str, FgDepMeta] = {}
@@ -879,7 +884,7 @@ def __init__(
                 ]
             )
 
-        self.metastore = create_metastore(options, parallel_worker)
+        self.metastore = create_metastore(options)
 
         # a mapping from source files to their corresponding shadow files
         # for efficient lookup
@@ -1217,7 +1222,9 @@ def wait_for_done_workers(
         done_sccs = []
         results = {}
         for idx in ready_to_read([w.conn for w in self.workers], WORKER_DONE_TIMEOUT):
-            data = SccResponseMessage.read(receive(self.workers[idx].conn))
+            buf = receive(self.workers[idx].conn)
+            assert read_tag(buf) == SCC_RESPONSE_MESSAGE
+            data = SccResponseMessage.read(buf)
             if not data.is_interface:
                 # Mark worker as free after it finished checking implementation.
                 self.free_workers.add(idx)
@@ -1622,13 +1629,10 @@ def exclude_from_backups(target_dir: str) -> None:
         pass
 
 
-def create_metastore(options: Options, parallel_worker: bool = False) -> MetadataStore:
+def create_metastore(options: Options) -> MetadataStore:
     """Create the appropriate metadata store."""
     if options.sqlite_cache:
-        # We use this flag in both coordinator and workers to speed up commits,
-        # see mypy.metastore.connect_db() for details.
-        sync_off = options.num_workers > 0 or parallel_worker
-        mds: MetadataStore = SqliteMetadataStore(_cache_dir_prefix(options), sync_off=sync_off)
+        mds: MetadataStore = SqliteMetadataStore(_cache_dir_prefix(options))
     else:
         mds = FilesystemMetadataStore(_cache_dir_prefix(options))
     return mds
@@ -2836,9 +2840,21 @@ def load_tree(self, temporary: bool = False) -> None:
 
     def fix_cross_refs(self) -> None:
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
-        # We need to set allow_missing when doing a fine-grained cache
-        # load because we need to gracefully handle missing modules.
-        fixup_module(self.tree, self.manager.modules, self.options.use_fine_grained_cache)
+        # Do initial lightweight pass fixing TypeInfos and module cross-references.
+        assert fixer_state.node_fixer is not None
+        fixer_state.node_fixer.visit_symbol_table(self.tree.names)
+        type_fixer = fixer_state.node_fixer.type_fixer
+        # Eagerly fix shared instances, before they are used by named_type() calls.
+        if instance_cache.str_type is not None:
+            instance_cache.str_type.accept(type_fixer)
+        if instance_cache.function_type is not None:
+            instance_cache.function_type.accept(type_fixer)
+        if instance_cache.int_type is not None:
+            instance_cache.int_type.accept(type_fixer)
+        if instance_cache.bool_type is not None:
+            instance_cache.bool_type.accept(type_fixer)
+        if instance_cache.object_type is not None:
+            instance_cache.object_type.accept(type_fixer)
 
     # Methods for processing modules from source code.
 
@@ -4183,7 +4199,8 @@ def process_graph(graph: Graph, manager: BuildManager) -> None:
     graph_message.write(buf)
     graph_data = buf.getvalue()
     for worker in manager.workers:
-        AckMessage.read(receive(worker.conn))
+        buf = receive(worker.conn)
+        assert read_tag(buf) == ACK_MESSAGE
         worker.conn.write_bytes(graph_data)
 
     sccs = sorted_components(graph)
@@ -4203,10 +4220,12 @@ def process_graph(graph: Graph, manager: BuildManager) -> None:
     sccs_message.write(buf)
     sccs_data = buf.getvalue()
     for worker in manager.workers:
-        AckMessage.read(receive(worker.conn))
+        buf = receive(worker.conn)
+        assert read_tag(buf) == ACK_MESSAGE
         worker.conn.write_bytes(sccs_data)
     for worker in manager.workers:
-        AckMessage.read(receive(worker.conn))
+        buf = receive(worker.conn)
+        assert read_tag(buf) == ACK_MESSAGE
 
     manager.free_workers = set(range(manager.options.num_workers))
 
@@ -4785,7 +4804,6 @@ class AckMessage(IPCMessage):
 
     @classmethod
     def read(cls, buf: ReadBuffer) -> AckMessage:
-        assert read_tag(buf) == ACK_MESSAGE
         return AckMessage()
 
     def write(self, buf: WriteBuffer) -> None:
@@ -4812,7 +4830,6 @@ def __init__(
 
     @classmethod
     def read(cls, buf: ReadBuffer) -> SccRequestMessage:
-        assert read_tag(buf) == SCC_REQUEST_MESSAGE
         return SccRequestMessage(
             scc_id=read_int_opt(buf),
             import_errors={
@@ -4897,7 +4914,6 @@ def __init__(
 
     @classmethod
     def read(cls, buf: ReadBuffer) -> SccResponseMessage:
-        assert read_tag(buf) == SCC_RESPONSE_MESSAGE
         scc_id = read_int(buf)
         is_interface = read_bool(buf)
         tag = read_tag(buf)
@@ -4943,7 +4959,6 @@ def __init__(self, *, sources: list[BuildSource]) -> None:
 
     @classmethod
     def read(cls, buf: ReadBuffer) -> SourcesDataMessage:
-        assert read_tag(buf) == SOURCES_DATA_MESSAGE
         sources = [
             BuildSource(
                 read_str_opt(buf),
@@ -4975,7 +4990,6 @@ def __init__(self, *, sccs: list[SCC]) -> None:
 
     @classmethod
     def read(cls, buf: ReadBuffer) -> SccsDataMessage:
-        assert read_tag(buf) == SCCS_DATA_MESSAGE
         sccs = [
             SCC(set(read_str_list(buf)), read_int(buf), read_int_list(buf))
             for _ in range(read_int_bare(buf))
@@ -5003,7 +5017,6 @@ def __init__(self, *, graph: Graph, missing_modules: dict[str, int]) -> None:
     @classmethod
     def read(cls, buf: ReadBuffer, manager: BuildManager | None = None) -> GraphMessage:
         assert manager is not None
-        assert read_tag(buf) == GRAPH_MESSAGE
         graph = {read_str_bare(buf): State.read(buf, manager) for _ in range(read_int_bare(buf))}
         missing_modules = {read_str_bare(buf): read_int(buf) for _ in range(read_int_bare(buf))}
         message = GraphMessage(graph=graph, missing_modules=missing_modules)

mypy/build_worker/worker.py

@@ -26,10 +26,15 @@
 from typing import NamedTuple
 
 from librt.base64 import b64decode
+from librt.internal import ReadBuffer, read_tag
 
 from mypy import util
 from mypy.build import (
+    GRAPH_MESSAGE,
     SCC,
+    SCC_REQUEST_MESSAGE,
+    SCCS_DATA_MESSAGE,
+    SOURCES_DATA_MESSAGE,
     AckMessage,
     BuildManager,
     Graph,
@@ -42,6 +47,7 @@
     process_stale_scc_implementation,
     process_stale_scc_interface,
 )
+from mypy.cache import Tag, read_int_opt
 from mypy.defaults import RECURSION_LIMIT, WORKER_CONNECTION_TIMEOUT
 from mypy.errors import CompileError, ErrorInfo, Errors, report_internal_error
 from mypy.fscache import FileSystemCache
@@ -116,21 +122,37 @@ def main(argv: list[str]) -> None:
         util.hard_exit(0)
 
 
+def should_shutdown(buf: ReadBuffer, expected_tag: Tag) -> bool:
+    """Check if the message is a shutdown request."""
+    tag = read_tag(buf)
+    if tag == SCC_REQUEST_MESSAGE:
+        assert read_int_opt(buf) is None
+        return True
+    assert tag == expected_tag, f"Unexpected tag: {tag}"
+    return False
+
+
 def serve(server: IPCServer, ctx: ServerContext) -> None:
     """Main server loop of the worker.
 
     Receive initial state from the coordinator, then process each
     SCC checking request and reply to client (coordinator). See module
     docstring for more details on the protocol.
     """
-    sources = SourcesDataMessage.read(receive(server)).sources
+    buf = receive(server)
+    if should_shutdown(buf, SOURCES_DATA_MESSAGE):
+        return
+    sources = SourcesDataMessage.read(buf).sources
     manager = setup_worker_manager(sources, ctx)
     if manager is None:
         return
 
     # Notify coordinator we are done with setup.
     send(server, AckMessage())
-    graph_data = GraphMessage.read(receive(server), manager)
+    buf = receive(server)
+    if should_shutdown(buf, GRAPH_MESSAGE):
+        return
+    graph_data = GraphMessage.read(buf, manager)
     # Update some manager data in-place as it has been passed to semantic analyzer.
     manager.missing_modules |= graph_data.missing_modules
     graph = graph_data.graph
@@ -141,14 +163,19 @@ def serve(server: IPCServer, ctx: ServerContext) -> None:
 
     # Notify coordinator we are ready to receive computed graph SCC structure.
     send(server, AckMessage())
-    sccs = SccsDataMessage.read(receive(server)).sccs
+    buf = receive(server)
+    if should_shutdown(buf, SCCS_DATA_MESSAGE):
+        return
+    sccs = SccsDataMessage.read(buf).sccs
     manager.scc_by_id = {scc.id: scc for scc in sccs}
     manager.top_order = [scc.id for scc in sccs]
 
     # Notify coordinator we are ready to start processing SCCs.
     send(server, AckMessage())
     while True:
-        scc_message = SccRequestMessage.read(receive(server))
+        buf = receive(server)
+        assert read_tag(buf) == SCC_REQUEST_MESSAGE
+        scc_message = SccRequestMessage.read(buf)
         scc_id = scc_message.scc_id
         if scc_id is None:
             manager.dump_stats()

mypy/cache.py

@@ -298,6 +298,7 @@ def read(cls, data: ReadBuffer) -> CacheMetaEx | None:
 # Always use this type alias to refer to type tags.
 Tag = u8
 
+# Note: all tags should be kept in sync with lib-rt/internal/librt_internal.c.
 # Primitives.
 LITERAL_FALSE: Final[Tag] = 0
 LITERAL_TRUE: Final[Tag] = 1
@@ -323,6 +324,7 @@ def read(cls, data: ReadBuffer) -> CacheMetaEx | None:
 # Four integers representing source file (line, column) range.
 LOCATION: Final[Tag] = 152
 
+RESERVED: Final[Tag] = 254
 END_TAG: Final[Tag] = 255
 
 

mypy/checker.py

@@ -6903,6 +6903,14 @@ def narrow_type_by_identity_equality(
                 expr_in_type_expr = type_expr.expr
             else:
                 continue
+
+            p_expr_type = get_proper_type(operand_types[i])
+            if isinstance(p_expr_type, TypeType) and isinstance(p_expr_type.item, TypeVarType):
+                # This mirrors logic in comparison_type_narrowing_helper
+                # In theory, this is like `i not in narrowable_indices`, except that
+                # narrowable_indices filters all type(x) narrowing as it's a call
+                continue
+
             for j in expr_indices:
                 if i == j:
                     continue
@@ -8627,15 +8635,19 @@ def and_conditional_maps(m1: TypeMap, m2: TypeMap, *, use_meet: bool = False) ->
     the truth of e2.
     """
     # Both conditions can be true; combine the information. Anything
-    # we learn from either conditions' truth is valid. If the same
-    # expression's type is refined by both conditions, we somewhat
-    # arbitrarily give precedence to m2 unless m1 value is Any.
-    # In the future, we could use an intersection type or meet_types().
+    # we learn from either conditions' truth is valid.
+    # If the same expression's type is refined by both conditions and use_meet=False, we somewhat
+    # arbitrarily give precedence to m2 unless m2's value is Any or m1's value is Never.
     result = m2.copy()
-    m2_keys = {literal_hash(n2) for n2 in m2}
+    m2_exprs = {literal_hash(n2): n2 for n2 in m2}
     for n1 in m1:
-        if literal_hash(n1) not in m2_keys or isinstance(
-            get_proper_type(m1[n1]), (AnyType, UninhabitedType)
+        n1_hash = literal_hash(n1)
+        if n1_hash not in m2_exprs or (
+            not use_meet
+            and (
+                isinstance(get_proper_type(m1[n1]), UninhabitedType)
+                or isinstance(get_proper_type(m2[m2_exprs[n1_hash]]), AnyType)
+            )
         ):
             result[n1] = m1[n1]
     if use_meet:

mypy/checkpattern.py

@@ -378,9 +378,15 @@ def visit_sequence_pattern(self, o: SequencePattern) -> PatternType:
             # tuples, so we instead try to narrow the entire type.
             # TODO: use more precise narrowing when possible (e.g. for identical shapes).
             new_tuple_type = TupleType(new_inner_types, current_type.partial_fallback)
-            new_type, rest_type = self.chk.conditional_types_with_intersection(
+            new_type, _ = self.chk.conditional_types_with_intersection(
                 new_tuple_type, [get_type_range(current_type)], o, default=new_tuple_type
             )
+            if (
+                star_position is not None
+                and required_patterns <= len(inner_types) - 1
+                and all(is_uninhabited(rest) for rest in rest_inner_types)
+            ):
+                rest_type = UninhabitedType()
         else:
             new_inner_type = UninhabitedType()
             for typ in new_inner_types:
@@ -460,7 +466,7 @@ def expand_starred_pattern_types(
             # so we only restore the type of the star item.
             res = []
             for i, t in enumerate(types):
-                if i != star_pos:
+                if i != star_pos or is_uninhabited(t):
                     res.append(t)
                 else:
                     res.append(UnpackType(self.chk.named_generic_type("builtins.tuple", [t])))

mypy/fixer_state.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Final
+
+if TYPE_CHECKING:
+    from mypy.fixup import NodeFixer
+
+# This is global mutable state. Don't add anything here unless there's a very
+# good reason. This exists as a separate file to avoid method-level import in
+# hot code in SymbolTableNode.node().
+
+
+class FixerState:
+    def __init__(self) -> None:
+        self.node_fixer: NodeFixer | None = None
+
+
+fixer_state: Final = FixerState()