mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/test/testgraph.py

@@ -0,0 +1,83 @@
+"""Test cases for graph processing code in build.py."""
+
+from __future__ import annotations
+
+import sys
+from typing import AbstractSet
+
+from mypy.build import BuildManager, BuildSourceSet, State, order_ascc, sorted_components
+from mypy.errors import Errors
+from mypy.fscache import FileSystemCache
+from mypy.graph_utils import strongly_connected_components, topsort
+from mypy.modulefinder import SearchPaths
+from mypy.options import Options
+from mypy.plugin import Plugin
+from mypy.report import Reports
+from mypy.test.helpers import Suite, assert_equal
+from mypy.version import __version__
+
+
+class GraphSuite(Suite):
+    def test_topsort(self) -> None:
+        a = frozenset({"A"})
+        b = frozenset({"B"})
+        c = frozenset({"C"})
+        d = frozenset({"D"})
+        data: dict[AbstractSet[str], set[AbstractSet[str]]] = {a: {b, c}, b: {d}, c: {d}}
+        res = list(topsort(data))
+        assert_equal(res, [{d}, {b, c}, {a}])
+
+    def test_scc(self) -> None:
+        vertices = {"A", "B", "C", "D"}
+        edges: dict[str, list[str]] = {"A": ["B", "C"], "B": ["C"], "C": ["B", "D"], "D": []}
+        sccs = {frozenset(x) for x in strongly_connected_components(vertices, edges)}
+        assert_equal(sccs, {frozenset({"A"}), frozenset({"B", "C"}), frozenset({"D"})})
+
+    def _make_manager(self) -> BuildManager:
+        options = Options()
+        options.use_builtins_fixtures = True
+        errors = Errors(options)
+        fscache = FileSystemCache()
+        search_paths = SearchPaths((), (), (), ())
+        manager = BuildManager(
+            data_dir="",
+            search_paths=search_paths,
+            ignore_prefix="",
+            source_set=BuildSourceSet([]),
+            reports=Reports("", {}),
+            options=options,
+            version_id=__version__,
+            plugin=Plugin(options),
+            plugins_snapshot={},
+            errors=errors,
+            flush_errors=lambda filename, msgs, serious: None,
+            fscache=fscache,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        return manager
+
+    def test_sorted_components(self) -> None:
+        manager = self._make_manager()
+        graph = {
+            "a": State("a", None, "import b, c", manager),
+            "d": State("d", None, "pass", manager),
+            "b": State("b", None, "import c", manager),
+            "c": State("c", None, "import b, d", manager),
+        }
+        res = sorted_components(graph)
+        assert_equal(res, [frozenset({"d"}), frozenset({"c", "b"}), frozenset({"a"})])
+
+    def test_order_ascc(self) -> None:
+        manager = self._make_manager()
+        graph = {
+            "a": State("a", None, "import b, c", manager),
+            "d": State("d", None, "def f(): import a", manager),
+            "b": State("b", None, "import c", manager),
+            "c": State("c", None, "import b, d", manager),
+        }
+        res = sorted_components(graph)
+        assert_equal(res, [frozenset({"a", "d", "c", "b"})])
+        ascc = res[0]
+        scc = order_ascc(graph, ascc)
+        assert_equal(scc, ["d", "c", "b", "a"])

mypy/test/testinfer.py

@@ -0,0 +1,373 @@
+"""Test cases for type inference helper functions."""
+
+from __future__ import annotations
+
+from mypy.argmap import map_actuals_to_formals
+from mypy.checker import DisjointDict, group_comparison_operands
+from mypy.literals import Key
+from mypy.nodes import ARG_NAMED, ARG_OPT, ARG_POS, ARG_STAR, ARG_STAR2, ArgKind, NameExpr
+from mypy.test.helpers import Suite, assert_equal
+from mypy.test.typefixture import TypeFixture
+from mypy.types import AnyType, TupleType, Type, TypeOfAny
+
+
+class MapActualsToFormalsSuite(Suite):
+    """Test cases for argmap.map_actuals_to_formals."""
+
+    def test_basic(self) -> None:
+        self.assert_map([], [], [])
+
+    def test_positional_only(self) -> None:
+        self.assert_map([ARG_POS], [ARG_POS], [[0]])
+        self.assert_map([ARG_POS, ARG_POS], [ARG_POS, ARG_POS], [[0], [1]])
+
+    def test_optional(self) -> None:
+        self.assert_map([], [ARG_OPT], [[]])
+        self.assert_map([ARG_POS], [ARG_OPT], [[0]])
+        self.assert_map([ARG_POS], [ARG_OPT, ARG_OPT], [[0], []])
+
+    def test_callee_star(self) -> None:
+        self.assert_map([], [ARG_STAR], [[]])
+        self.assert_map([ARG_POS], [ARG_STAR], [[0]])
+        self.assert_map([ARG_POS, ARG_POS], [ARG_STAR], [[0, 1]])
+
+    def test_caller_star(self) -> None:
+        self.assert_map([ARG_STAR], [ARG_STAR], [[0]])
+        self.assert_map([ARG_POS, ARG_STAR], [ARG_STAR], [[0, 1]])
+        self.assert_map([ARG_STAR], [ARG_POS, ARG_STAR], [[0], [0]])
+        self.assert_map([ARG_STAR], [ARG_OPT, ARG_STAR], [[0], [0]])
+
+    def test_too_many_caller_args(self) -> None:
+        self.assert_map([ARG_POS], [], [])
+        self.assert_map([ARG_STAR], [], [])
+        self.assert_map([ARG_STAR], [ARG_POS], [[0]])
+
+    def test_tuple_star(self) -> None:
+        any_type = AnyType(TypeOfAny.special_form)
+        self.assert_vararg_map([ARG_STAR], [ARG_POS], [[0]], self.make_tuple(any_type))
+        self.assert_vararg_map(
+            [ARG_STAR], [ARG_POS, ARG_POS], [[0], [0]], self.make_tuple(any_type, any_type)
+        )
+        self.assert_vararg_map(
+            [ARG_STAR],
+            [ARG_POS, ARG_OPT, ARG_OPT],
+            [[0], [0], []],
+            self.make_tuple(any_type, any_type),
+        )
+
+    def make_tuple(self, *args: Type) -> TupleType:
+        return TupleType(list(args), TypeFixture().std_tuple)
+
+    def test_named_args(self) -> None:
+        self.assert_map(["x"], [(ARG_POS, "x")], [[0]])
+        self.assert_map(["y", "x"], [(ARG_POS, "x"), (ARG_POS, "y")], [[1], [0]])
+
+    def test_some_named_args(self) -> None:
+        self.assert_map(["y"], [(ARG_OPT, "x"), (ARG_OPT, "y"), (ARG_OPT, "z")], [[], [0], []])
+
+    def test_missing_named_arg(self) -> None:
+        self.assert_map(["y"], [(ARG_OPT, "x")], [[]])
+
+    def test_duplicate_named_arg(self) -> None:
+        self.assert_map(["x", "x"], [(ARG_OPT, "x")], [[0, 1]])
+
+    def test_varargs_and_bare_asterisk(self) -> None:
+        self.assert_map([ARG_STAR], [ARG_STAR, (ARG_NAMED, "x")], [[0], []])
+        self.assert_map([ARG_STAR, "x"], [ARG_STAR, (ARG_NAMED, "x")], [[0], [1]])
+
+    def test_keyword_varargs(self) -> None:
+        self.assert_map(["x"], [ARG_STAR2], [[0]])
+        self.assert_map(["x", ARG_STAR2], [ARG_STAR2], [[0, 1]])
+        self.assert_map(["x", ARG_STAR2], [(ARG_POS, "x"), ARG_STAR2], [[0], [1]])
+        self.assert_map([ARG_POS, ARG_STAR2], [(ARG_POS, "x"), ARG_STAR2], [[0], [1]])
+
+    def test_both_kinds_of_varargs(self) -> None:
+        self.assert_map([ARG_STAR, ARG_STAR2], [(ARG_POS, "x"), (ARG_POS, "y")], [[0, 1], [0, 1]])
+
+    def test_special_cases(self) -> None:
+        self.assert_map([ARG_STAR], [ARG_STAR, ARG_STAR2], [[0], []])
+        self.assert_map([ARG_STAR, ARG_STAR2], [ARG_STAR, ARG_STAR2], [[0], [1]])
+        self.assert_map([ARG_STAR2], [(ARG_POS, "x"), ARG_STAR2], [[0], [0]])
+        self.assert_map([ARG_STAR2], [ARG_STAR2], [[0]])
+
+    def assert_map(
+        self,
+        caller_kinds_: list[ArgKind | str],
+        callee_kinds_: list[ArgKind | tuple[ArgKind, str]],
+        expected: list[list[int]],
+    ) -> None:
+        caller_kinds, caller_names = expand_caller_kinds(caller_kinds_)
+        callee_kinds, callee_names = expand_callee_kinds(callee_kinds_)
+        result = map_actuals_to_formals(
+            caller_kinds,
+            caller_names,
+            callee_kinds,
+            callee_names,
+            lambda i: AnyType(TypeOfAny.special_form),
+        )
+        assert_equal(result, expected)
+
+    def assert_vararg_map(
+        self,
+        caller_kinds: list[ArgKind],
+        callee_kinds: list[ArgKind],
+        expected: list[list[int]],
+        vararg_type: Type,
+    ) -> None:
+        result = map_actuals_to_formals(caller_kinds, [], callee_kinds, [], lambda i: vararg_type)
+        assert_equal(result, expected)
+
+
+def expand_caller_kinds(
+    kinds_or_names: list[ArgKind | str],
+) -> tuple[list[ArgKind], list[str | None]]:
+    kinds = []
+    names: list[str | None] = []
+    for k in kinds_or_names:
+        if isinstance(k, str):
+            kinds.append(ARG_NAMED)
+            names.append(k)
+        else:
+            kinds.append(k)
+            names.append(None)
+    return kinds, names
+
+
+def expand_callee_kinds(
+    kinds_and_names: list[ArgKind | tuple[ArgKind, str]]
+) -> tuple[list[ArgKind], list[str | None]]:
+    kinds = []
+    names: list[str | None] = []
+    for v in kinds_and_names:
+        if isinstance(v, tuple):
+            kinds.append(v[0])
+            names.append(v[1])
+        else:
+            kinds.append(v)
+            names.append(None)
+    return kinds, names
+
+
+class OperandDisjointDictSuite(Suite):
+    """Test cases for checker.DisjointDict, which is used for type inference with operands."""
+
+    def new(self) -> DisjointDict[int, str]:
+        return DisjointDict()
+
+    def test_independent_maps(self) -> None:
+        d = self.new()
+        d.add_mapping({0, 1}, {"group1"})
+        d.add_mapping({2, 3, 4}, {"group2"})
+        d.add_mapping({5, 6, 7}, {"group3"})
+
+        self.assertEqual(
+            d.items(), [({0, 1}, {"group1"}), ({2, 3, 4}, {"group2"}), ({5, 6, 7}, {"group3"})]
+        )
+
+    def test_partial_merging(self) -> None:
+        d = self.new()
+        d.add_mapping({0, 1}, {"group1"})
+        d.add_mapping({1, 2}, {"group2"})
+        d.add_mapping({3, 4}, {"group3"})
+        d.add_mapping({5, 0}, {"group4"})
+        d.add_mapping({5, 6}, {"group5"})
+        d.add_mapping({4, 7}, {"group6"})
+
+        self.assertEqual(
+            d.items(),
+            [
+                ({0, 1, 2, 5, 6}, {"group1", "group2", "group4", "group5"}),
+                ({3, 4, 7}, {"group3", "group6"}),
+            ],
+        )
+
+    def test_full_merging(self) -> None:
+        d = self.new()
+        d.add_mapping({0, 1, 2}, {"a"})
+        d.add_mapping({3, 4, 2}, {"b"})
+        d.add_mapping({10, 11, 12}, {"c"})
+        d.add_mapping({13, 14, 15}, {"d"})
+        d.add_mapping({14, 10, 16}, {"e"})
+        d.add_mapping({0, 10}, {"f"})
+
+        self.assertEqual(
+            d.items(),
+            [({0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 15, 16}, {"a", "b", "c", "d", "e", "f"})],
+        )
+
+    def test_merge_with_multiple_overlaps(self) -> None:
+        d = self.new()
+        d.add_mapping({0, 1, 2}, {"a"})
+        d.add_mapping({3, 4, 5}, {"b"})
+        d.add_mapping({1, 2, 4, 5}, {"c"})
+        d.add_mapping({6, 1, 2, 4, 5}, {"d"})
+        d.add_mapping({6, 1, 2, 4, 5}, {"e"})
+
+        self.assertEqual(d.items(), [({0, 1, 2, 3, 4, 5, 6}, {"a", "b", "c", "d", "e"})])
+
+
+class OperandComparisonGroupingSuite(Suite):
+    """Test cases for checker.group_comparison_operands."""
+
+    def literal_keymap(self, assignable_operands: dict[int, NameExpr]) -> dict[int, Key]:
+        output: dict[int, Key] = {}
+        for index, expr in assignable_operands.items():
+            output[index] = ("FakeExpr", expr.name)
+        return output
+
+    def test_basic_cases(self) -> None:
+        # Note: the grouping function doesn't actually inspect the input exprs, so we
+        # just default to using NameExprs for simplicity.
+        x0 = NameExpr("x0")
+        x1 = NameExpr("x1")
+        x2 = NameExpr("x2")
+        x3 = NameExpr("x3")
+        x4 = NameExpr("x4")
+
+        basic_input = [("==", x0, x1), ("==", x1, x2), ("<", x2, x3), ("==", x3, x4)]
+
+        none_assignable = self.literal_keymap({})
+        all_assignable = self.literal_keymap({0: x0, 1: x1, 2: x2, 3: x3, 4: x4})
+
+        for assignable in [none_assignable, all_assignable]:
+            self.assertEqual(
+                group_comparison_operands(basic_input, assignable, set()),
+                [("==", [0, 1]), ("==", [1, 2]), ("<", [2, 3]), ("==", [3, 4])],
+            )
+            self.assertEqual(
+                group_comparison_operands(basic_input, assignable, {"=="}),
+                [("==", [0, 1, 2]), ("<", [2, 3]), ("==", [3, 4])],
+            )
+            self.assertEqual(
+                group_comparison_operands(basic_input, assignable, {"<"}),
+                [("==", [0, 1]), ("==", [1, 2]), ("<", [2, 3]), ("==", [3, 4])],
+            )
+            self.assertEqual(
+                group_comparison_operands(basic_input, assignable, {"==", "<"}),
+                [("==", [0, 1, 2]), ("<", [2, 3]), ("==", [3, 4])],
+            )
+
+    def test_multiple_groups(self) -> None:
+        x0 = NameExpr("x0")
+        x1 = NameExpr("x1")
+        x2 = NameExpr("x2")
+        x3 = NameExpr("x3")
+        x4 = NameExpr("x4")
+        x5 = NameExpr("x5")
+
+        self.assertEqual(
+            group_comparison_operands(
+                [("==", x0, x1), ("==", x1, x2), ("is", x2, x3), ("is", x3, x4)],
+                self.literal_keymap({}),
+                {"==", "is"},
+            ),
+            [("==", [0, 1, 2]), ("is", [2, 3, 4])],
+        )
+        self.assertEqual(
+            group_comparison_operands(
+                [("==", x0, x1), ("==", x1, x2), ("==", x2, x3), ("==", x3, x4)],
+                self.literal_keymap({}),
+                {"==", "is"},
+            ),
+            [("==", [0, 1, 2, 3, 4])],
+        )
+        self.assertEqual(
+            group_comparison_operands(
+                [("is", x0, x1), ("==", x1, x2), ("==", x2, x3), ("==", x3, x4)],
+                self.literal_keymap({}),
+                {"==", "is"},
+            ),
+            [("is", [0, 1]), ("==", [1, 2, 3, 4])],
+        )
+        self.assertEqual(
+            group_comparison_operands(
+                [("is", x0, x1), ("is", x1, x2), ("<", x2, x3), ("==", x3, x4), ("==", x4, x5)],
+                self.literal_keymap({}),
+                {"==", "is"},
+            ),
+            [("is", [0, 1, 2]), ("<", [2, 3]), ("==", [3, 4, 5])],
+        )
+
+    def test_multiple_groups_coalescing(self) -> None:
+        x0 = NameExpr("x0")
+        x1 = NameExpr("x1")
+        x2 = NameExpr("x2")
+        x3 = NameExpr("x3")
+        x4 = NameExpr("x4")
+
+        nothing_combined = [("==", [0, 1, 2]), ("<", [2, 3]), ("==", [3, 4, 5])]
+        everything_combined = [("==", [0, 1, 2, 3, 4, 5]), ("<", [2, 3])]
+
+        # Note: We do 'x4 == x0' at the very end!
+        two_groups = [
+            ("==", x0, x1),
+            ("==", x1, x2),
+            ("<", x2, x3),
+            ("==", x3, x4),
+            ("==", x4, x0),
+        ]
+        self.assertEqual(
+            group_comparison_operands(
+                two_groups, self.literal_keymap({0: x0, 1: x1, 2: x2, 3: x3, 4: x4, 5: x0}), {"=="}
+            ),
+            everything_combined,
+            "All vars are assignable, everything is combined",
+        )
+        self.assertEqual(
+            group_comparison_operands(
+                two_groups, self.literal_keymap({1: x1, 2: x2, 3: x3, 4: x4}), {"=="}
+            ),
+            nothing_combined,
+            "x0 is unassignable, so no combining",
+        )
+        self.assertEqual(
+            group_comparison_operands(
+                two_groups, self.literal_keymap({0: x0, 1: x1, 3: x3, 5: x0}), {"=="}
+            ),
+            everything_combined,
+            "Some vars are unassignable but x0 is, so we combine",
+        )
+        self.assertEqual(
+            group_comparison_operands(two_groups, self.literal_keymap({0: x0, 5: x0}), {"=="}),
+            everything_combined,
+            "All vars are unassignable but x0 is, so we combine",
+        )
+
+    def test_multiple_groups_different_operators(self) -> None:
+        x0 = NameExpr("x0")
+        x1 = NameExpr("x1")
+        x2 = NameExpr("x2")
+        x3 = NameExpr("x3")
+
+        groups = [("==", x0, x1), ("==", x1, x2), ("is", x2, x3), ("is", x3, x0)]
+        keymap = self.literal_keymap({0: x0, 1: x1, 2: x2, 3: x3, 4: x0})
+        self.assertEqual(
+            group_comparison_operands(groups, keymap, {"==", "is"}),
+            [("==", [0, 1, 2]), ("is", [2, 3, 4])],
+            "Different operators can never be combined",
+        )
+
+    def test_single_pair(self) -> None:
+        x0 = NameExpr("x0")
+        x1 = NameExpr("x1")
+
+        single_comparison = [("==", x0, x1)]
+        expected_output = [("==", [0, 1])]
+
+        assignable_combinations: list[dict[int, NameExpr]] = [{}, {0: x0}, {1: x1}, {0: x0, 1: x1}]
+        to_group_by: list[set[str]] = [set(), {"=="}, {"is"}]
+
+        for combo in assignable_combinations:
+            for operators in to_group_by:
+                keymap = self.literal_keymap(combo)
+                self.assertEqual(
+                    group_comparison_operands(single_comparison, keymap, operators),
+                    expected_output,
+                )
+
+    def test_empty_pair_list(self) -> None:
+        # This case should never occur in practice -- ComparisionExprs
+        # always contain at least one comparison. But in case it does...
+
+        self.assertEqual(group_comparison_operands([], {}, set()), [])
+        self.assertEqual(group_comparison_operands([], {}, {"=="}), [])

mypy/test/testipc.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import sys
+import time
+from multiprocessing import Queue, get_context
+from unittest import TestCase, main
+
+import pytest
+
+from mypy.ipc import IPCClient, IPCServer
+
+CONNECTION_NAME = "dmypy-test-ipc"
+
+
+def server(msg: str, q: Queue[str]) -> None:
+    server = IPCServer(CONNECTION_NAME)
+    q.put(server.connection_name)
+    data = ""
+    while not data:
+        with server:
+            server.write(msg)
+            data = server.read()
+    server.cleanup()
+
+
+def server_multi_message_echo(q: Queue[str]) -> None:
+    server = IPCServer(CONNECTION_NAME)
+    q.put(server.connection_name)
+    data = ""
+    with server:
+        while data != "quit":
+            data = server.read()
+            server.write(data)
+    server.cleanup()
+
+
+class IPCTests(TestCase):
+    def setUp(self) -> None:
+        if sys.platform == "linux":
+            # The default "fork" start method is potentially unsafe
+            self.ctx = get_context("forkserver")
+        else:
+            self.ctx = get_context("spawn")
+
+    def test_transaction_large(self) -> None:
+        queue: Queue[str] = self.ctx.Queue()
+        msg = "t" * 200000  # longer than the max read size of 100_000
+        p = self.ctx.Process(target=server, args=(msg, queue), daemon=True)
+        p.start()
+        connection_name = queue.get()
+        with IPCClient(connection_name, timeout=1) as client:
+            assert client.read() == msg
+            client.write("test")
+        queue.close()
+        queue.join_thread()
+        p.join()
+
+    def test_connect_twice(self) -> None:
+        queue: Queue[str] = self.ctx.Queue()
+        msg = "this is a test message"
+        p = self.ctx.Process(target=server, args=(msg, queue), daemon=True)
+        p.start()
+        connection_name = queue.get()
+        with IPCClient(connection_name, timeout=1) as client:
+            assert client.read() == msg
+            client.write("")  # don't let the server hang up yet, we want to connect again.
+
+        with IPCClient(connection_name, timeout=1) as client:
+            assert client.read() == msg
+            client.write("test")
+        queue.close()
+        queue.join_thread()
+        p.join()
+        assert p.exitcode == 0
+
+    def test_multiple_messages(self) -> None:
+        queue: Queue[str] = self.ctx.Queue()
+        p = self.ctx.Process(target=server_multi_message_echo, args=(queue,), daemon=True)
+        p.start()
+        connection_name = queue.get()
+        with IPCClient(connection_name, timeout=1) as client:
+            # "foo bar" with extra accents on letters.
+            # In UTF-8 encoding so we don't confuse editors opening this file.
+            fancy_text = b"f\xcc\xb6o\xcc\xb2\xf0\x9d\x91\x9c \xd0\xb2\xe2\xb7\xa1a\xcc\xb6r\xcc\x93\xcd\x98\xcd\x8c"
+            client.write(fancy_text.decode("utf-8"))
+            assert client.read() == fancy_text.decode("utf-8")
+
+            client.write("Test with spaces")
+            client.write("Test write before reading previous")
+            time.sleep(0)  # yield to the server to force reading of all messages by server.
+            assert client.read() == "Test with spaces"
+            assert client.read() == "Test write before reading previous"
+
+            client.write("quit")
+            assert client.read() == "quit"
+        queue.close()
+        queue.join_thread()
+        p.join()
+        assert p.exitcode == 0
+
+    # Run test_connect_twice a lot, in the hopes of finding issues.
+    # This is really slow, so it is skipped, but can be enabled if
+    # needed to debug IPC issues.
+    @pytest.mark.skip
+    def test_connect_alot(self) -> None:
+        t0 = time.time()
+        for i in range(1000):
+            try:
+                print(i, "start")
+                self.test_connect_twice()
+            finally:
+                t1 = time.time()
+                print(i, t1 - t0)
+                sys.stdout.flush()
+                t0 = t1
+
+
+if __name__ == "__main__":
+    main()