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

mypyc/test/test_refcount.py

@@ -0,0 +1,59 @@
+"""Test runner for reference count opcode insertion transform test cases.
+
+The transform inserts needed reference count increment/decrement
+operations to IR.
+"""
+
+from __future__ import annotations
+
+import os.path
+
+from mypy.errors import CompileError
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase
+from mypyc.common import TOP_LEVEL_NAME
+from mypyc.ir.pprint import format_func
+from mypyc.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    MypycDataSuite,
+    assert_test_output,
+    build_ir_for_single_file,
+    infer_ir_build_options_from_test_name,
+    remove_comment_lines,
+    replace_word_size,
+    use_custom_builtins,
+)
+from mypyc.transform.refcount import insert_ref_count_opcodes
+from mypyc.transform.uninit import insert_uninit_checks
+
+files = ["refcount.test"]
+
+
+class TestRefCountTransform(MypycDataSuite):
+    files = files
+    base_path = test_temp_dir
+    optional_out = True
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        """Perform a runtime checking transformation test case."""
+        options = infer_ir_build_options_from_test_name(testcase.name)
+        if options is None:
+            # Skipped test case
+            return
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
+            expected_output = remove_comment_lines(testcase.output)
+            expected_output = replace_word_size(expected_output)
+            try:
+                ir = build_ir_for_single_file(testcase.input, options)
+            except CompileError as e:
+                actual = e.messages
+            else:
+                actual = []
+                for fn in ir:
+                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith("_toplevel"):
+                        continue
+                    insert_uninit_checks(fn)
+                    insert_ref_count_opcodes(fn)
+                    actual.extend(format_func(fn))
+
+            assert_test_output(testcase, actual, "Invalid source code output", expected_output)

mypyc/test/test_run.py

@@ -0,0 +1,426 @@
+"""Test cases for building an C extension and running it."""
+
+from __future__ import annotations
+
+import ast
+import contextlib
+import glob
+import os.path
+import re
+import shutil
+import subprocess
+import sys
+import time
+from typing import Any, Iterator
+
+from mypy import build
+from mypy.errors import CompileError
+from mypy.options import Options
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase
+from mypy.test.helpers import assert_module_equivalence, perform_file_operations
+from mypyc.build import construct_groups
+from mypyc.codegen import emitmodule
+from mypyc.errors import Errors
+from mypyc.options import CompilerOptions
+from mypyc.test.test_serialization import check_serialization_roundtrip
+from mypyc.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    TESTUTIL_PATH,
+    MypycDataSuite,
+    assert_test_output,
+    fudge_dir_mtimes,
+    show_c,
+    use_custom_builtins,
+)
+
+files = [
+    "run-async.test",
+    "run-misc.test",
+    "run-functions.test",
+    "run-integers.test",
+    "run-i64.test",
+    "run-i32.test",
+    "run-i16.test",
+    "run-u8.test",
+    "run-floats.test",
+    "run-math.test",
+    "run-bools.test",
+    "run-strings.test",
+    "run-bytes.test",
+    "run-tuples.test",
+    "run-lists.test",
+    "run-dicts.test",
+    "run-sets.test",
+    "run-primitives.test",
+    "run-loops.test",
+    "run-exceptions.test",
+    "run-imports.test",
+    "run-classes.test",
+    "run-traits.test",
+    "run-generators.test",
+    "run-multimodule.test",
+    "run-bench.test",
+    "run-mypy-sim.test",
+    "run-dunders.test",
+    "run-singledispatch.test",
+    "run-attrs.test",
+    "run-python37.test",
+    "run-python38.test",
+]
+
+if sys.version_info >= (3, 10):
+    files.append("run-match.test")
+
+setup_format = """\
+from setuptools import setup
+from mypyc.build import mypycify
+
+setup(name='test_run_output',
+      ext_modules=mypycify({}, separate={}, skip_cgen_input={!r}, strip_asserts=False,
+                           multi_file={}, opt_level='{}'),
+)
+"""
+
+WORKDIR = "build"
+
+
+def run_setup(script_name: str, script_args: list[str]) -> bool:
+    """Run a setup script in a somewhat controlled environment.
+
+    This is adapted from code in distutils and our goal here is that is
+    faster to not need to spin up a python interpreter to run it.
+
+    We had to fork it because the real run_setup swallows errors
+    and KeyboardInterrupt with no way to recover them (!).
+    The real version has some extra features that we removed since
+    we weren't using them.
+
+    Returns whether the setup succeeded.
+    """
+    save_argv = sys.argv.copy()
+    g = {"__file__": script_name}
+    try:
+        try:
+            sys.argv[0] = script_name
+            sys.argv[1:] = script_args
+            with open(script_name, "rb") as f:
+                exec(f.read(), g)
+        finally:
+            sys.argv = save_argv
+    except SystemExit as e:
+        # distutils converts KeyboardInterrupt into a SystemExit with
+        # "interrupted" as the argument. Convert it back so that
+        # pytest will exit instead of just failing the test.
+        if e.code == "interrupted":
+            raise KeyboardInterrupt from e
+
+        return e.code == 0 or e.code is None
+
+    return True
+
+
+@contextlib.contextmanager
+def chdir_manager(target: str) -> Iterator[None]:
+    dir = os.getcwd()
+    os.chdir(target)
+    try:
+        yield
+    finally:
+        os.chdir(dir)
+
+
+class TestRun(MypycDataSuite):
+    """Test cases that build a C extension and run code."""
+
+    files = files
+    base_path = test_temp_dir
+    optional_out = True
+    multi_file = False
+    separate = False  # If True, using separate (incremental) compilation
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        # setup.py wants to be run from the root directory of the package, which we accommodate
+        # by chdiring into tmp/
+        with use_custom_builtins(
+            os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase
+        ), chdir_manager("tmp"):
+            self.run_case_inner(testcase)
+
+    def run_case_inner(self, testcase: DataDrivenTestCase) -> None:
+        if not os.path.isdir(WORKDIR):  # (one test puts something in build...)
+            os.mkdir(WORKDIR)
+
+        text = "\n".join(testcase.input)
+
+        with open("native.py", "w", encoding="utf-8") as f:
+            f.write(text)
+        with open("interpreted.py", "w", encoding="utf-8") as f:
+            f.write(text)
+
+        shutil.copyfile(TESTUTIL_PATH, "testutil.py")
+
+        step = 1
+        self.run_case_step(testcase, step)
+
+        steps = testcase.find_steps()
+        if steps == [[]]:
+            steps = []
+
+        for operations in steps:
+            # To make sure that any new changes get picked up as being
+            # new by distutils, shift the mtime of all of the
+            # generated artifacts back by a second.
+            fudge_dir_mtimes(WORKDIR, -1)
+            # On some OS, changing the mtime doesn't work reliably. As
+            # a workaround, sleep.
+            # TODO: Figure out a better approach, since this slows down tests.
+            time.sleep(1.0)
+
+            step += 1
+            with chdir_manager(".."):
+                perform_file_operations(operations)
+            self.run_case_step(testcase, step)
+
+    def run_case_step(self, testcase: DataDrivenTestCase, incremental_step: int) -> None:
+        bench = testcase.config.getoption("--bench", False) and "Benchmark" in testcase.name
+
+        options = Options()
+        options.use_builtins_fixtures = True
+        options.show_traceback = True
+        options.strict_optional = True
+        options.python_version = sys.version_info[:2]
+        options.export_types = True
+        options.preserve_asts = True
+        options.allow_empty_bodies = True
+        options.incremental = self.separate
+
+        # Avoid checking modules/packages named 'unchecked', to provide a way
+        # to test interacting with code we don't have types for.
+        options.per_module_options["unchecked.*"] = {"follow_imports": "error"}
+
+        source = build.BuildSource("native.py", "native", None)
+        sources = [source]
+        module_names = ["native"]
+        module_paths = ["native.py"]
+
+        # Hard code another module name to compile in the same compilation unit.
+        to_delete = []
+        for fn, text in testcase.files:
+            fn = os.path.relpath(fn, test_temp_dir)
+
+            if os.path.basename(fn).startswith("other") and fn.endswith(".py"):
+                name = fn.split(".")[0].replace(os.sep, ".")
+                module_names.append(name)
+                sources.append(build.BuildSource(fn, name, None))
+                to_delete.append(fn)
+                module_paths.append(fn)
+
+                shutil.copyfile(fn, os.path.join(os.path.dirname(fn), name + "_interpreted.py"))
+
+        for source in sources:
+            options.per_module_options.setdefault(source.module, {})["mypyc"] = True
+
+        separate = (
+            self.get_separate("\n".join(testcase.input), incremental_step)
+            if self.separate
+            else False
+        )
+
+        groups = construct_groups(sources, separate, len(module_names) > 1)
+
+        try:
+            compiler_options = CompilerOptions(multi_file=self.multi_file, separate=self.separate)
+            result = emitmodule.parse_and_typecheck(
+                sources=sources,
+                options=options,
+                compiler_options=compiler_options,
+                groups=groups,
+                alt_lib_path=".",
+            )
+            errors = Errors(options)
+            ir, cfiles = emitmodule.compile_modules_to_c(
+                result, compiler_options=compiler_options, errors=errors, groups=groups
+            )
+            if errors.num_errors:
+                errors.flush_errors()
+                assert False, "Compile error"
+        except CompileError as e:
+            for line in e.messages:
+                print(fix_native_line_number(line, testcase.file, testcase.line))
+            assert False, "Compile error"
+
+        # Check that serialization works on this IR. (Only on the first
+        # step because the returned ir only includes updated code.)
+        if incremental_step == 1:
+            check_serialization_roundtrip(ir)
+
+        opt_level = int(os.environ.get("MYPYC_OPT_LEVEL", 0))
+        debug_level = int(os.environ.get("MYPYC_DEBUG_LEVEL", 0))
+
+        setup_file = os.path.abspath(os.path.join(WORKDIR, "setup.py"))
+        # We pass the C file information to the build script via setup.py unfortunately
+        with open(setup_file, "w", encoding="utf-8") as f:
+            f.write(
+                setup_format.format(
+                    module_paths, separate, cfiles, self.multi_file, opt_level, debug_level
+                )
+            )
+
+        if not run_setup(setup_file, ["build_ext", "--inplace"]):
+            if testcase.config.getoption("--mypyc-showc"):
+                show_c(cfiles)
+            assert False, "Compilation failed"
+
+        # Assert that an output file got created
+        suffix = "pyd" if sys.platform == "win32" else "so"
+        assert glob.glob(f"native.*.{suffix}") or glob.glob(f"native.{suffix}")
+
+        driver_path = "driver.py"
+        if not os.path.isfile(driver_path):
+            # No driver.py provided by test case. Use the default one
+            # (mypyc/test-data/driver/driver.py) that calls each
+            # function named test_*.
+            default_driver = os.path.join(
+                os.path.dirname(__file__), "..", "test-data", "driver", "driver.py"
+            )
+            shutil.copy(default_driver, driver_path)
+        env = os.environ.copy()
+        env["MYPYC_RUN_BENCH"] = "1" if bench else "0"
+
+        debugger = testcase.config.getoption("debugger")
+        if debugger:
+            if debugger == "lldb":
+                subprocess.check_call(["lldb", "--", sys.executable, driver_path], env=env)
+            elif debugger == "gdb":
+                subprocess.check_call(["gdb", "--args", sys.executable, driver_path], env=env)
+            else:
+                assert False, "Unsupported debugger"
+            # TODO: find a way to automatically disable capturing
+            # stdin/stdout when in debugging mode
+            assert False, (
+                "Test can't pass in debugging mode. "
+                "(Make sure to pass -s to pytest to interact with the debugger)"
+            )
+        proc = subprocess.Popen(
+            [sys.executable, driver_path],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            env=env,
+        )
+        if sys.version_info >= (3, 12):
+            # TODO: testDecorators1 hangs on 3.12, remove this once fixed
+            proc.wait(timeout=30)
+        output = proc.communicate()[0].decode("utf8")
+        outlines = output.splitlines()
+
+        if testcase.config.getoption("--mypyc-showc"):
+            show_c(cfiles)
+        if proc.returncode != 0:
+            print()
+            print("*** Exit status: %d" % proc.returncode)
+
+        # Verify output.
+        if bench:
+            print("Test output:")
+            print(output)
+        else:
+            if incremental_step == 1:
+                msg = "Invalid output"
+                expected = testcase.output
+            else:
+                msg = f"Invalid output (step {incremental_step})"
+                expected = testcase.output2.get(incremental_step, [])
+
+            if not expected:
+                # Tweak some line numbers, but only if the expected output is empty,
+                # as tweaked output might not match expected output.
+                outlines = [
+                    fix_native_line_number(line, testcase.file, testcase.line) for line in outlines
+                ]
+            assert_test_output(testcase, outlines, msg, expected)
+
+        if incremental_step > 1 and options.incremental:
+            suffix = "" if incremental_step == 2 else str(incremental_step - 1)
+            expected_rechecked = testcase.expected_rechecked_modules.get(incremental_step - 1)
+            if expected_rechecked is not None:
+                assert_module_equivalence(
+                    "rechecked" + suffix, expected_rechecked, result.manager.rechecked_modules
+                )
+            expected_stale = testcase.expected_stale_modules.get(incremental_step - 1)
+            if expected_stale is not None:
+                assert_module_equivalence(
+                    "stale" + suffix, expected_stale, result.manager.stale_modules
+                )
+
+        assert proc.returncode == 0
+
+    def get_separate(self, program_text: str, incremental_step: int) -> Any:
+        template = r"# separate{}: (\[.*\])$"
+        m = re.search(template.format(incremental_step), program_text, flags=re.MULTILINE)
+        if not m:
+            m = re.search(template.format(""), program_text, flags=re.MULTILINE)
+        if m:
+            return ast.literal_eval(m.group(1))
+        else:
+            return True
+
+
+class TestRunMultiFile(TestRun):
+    """Run the main multi-module tests in multi-file compilation mode.
+
+    In multi-file mode each module gets compiled into a separate C file,
+    but all modules (C files) are compiled together.
+    """
+
+    multi_file = True
+    test_name_suffix = "_multi"
+    files = ["run-multimodule.test", "run-mypy-sim.test"]
+
+
+class TestRunSeparate(TestRun):
+    """Run the main multi-module tests in separate compilation mode.
+
+    In this mode there are multiple compilation groups, which are compiled
+    incrementally. Each group is compiled to a separate C file, and these C
+    files are compiled separately.
+
+    Each compiled module is placed into a separate compilation group, unless
+    overridden by a special comment. Consider this example:
+
+      # separate: [(["other.py", "other_b.py"], "stuff")]
+
+    This puts other.py and other_b.py into a compilation group named "stuff".
+    Any files not mentioned in the comment will get single-file groups.
+    """
+
+    separate = True
+    test_name_suffix = "_separate"
+    files = ["run-multimodule.test", "run-mypy-sim.test"]
+
+
+def fix_native_line_number(message: str, fnam: str, delta: int) -> str:
+    """Update code locations in test case output to point to the .test file.
+
+    The description of the test case is written to native.py, and line numbers
+    in test case output often are relative to native.py. This translates the
+    line numbers to be relative to the .test file that contains the test case
+    description, and also updates the file name to the .test file name.
+
+    Args:
+        message: message to update
+        fnam: path of the .test file
+        delta: line number of the beginning of the test case in the .test file
+
+    Returns updated message (or original message if we couldn't find anything).
+    """
+    fnam = os.path.basename(fnam)
+    message = re.sub(
+        r"native\.py:([0-9]+):", lambda m: "%s:%d:" % (fnam, int(m.group(1)) + delta), message
+    )
+    message = re.sub(
+        r'"native.py", line ([0-9]+),',
+        lambda m: '"%s", line %d,' % (fnam, int(m.group(1)) + delta),
+        message,
+    )
+    return message

mypyc/test/test_serialization.py

@@ -0,0 +1,108 @@
+"""Functions to check that serialization round-tripped properly."""
+
+# This file is named test_serialization.py even though it doesn't
+# contain its own tests so that pytest will rewrite the asserts...
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature
+from mypyc.ir.module_ir import ModuleIR, deserialize_modules
+from mypyc.ir.ops import DeserMaps
+from mypyc.ir.rtypes import RType
+from mypyc.sametype import is_same_signature, is_same_type
+
+
+def get_dict(x: Any) -> dict[str, Any]:
+    if hasattr(x, "__mypyc_attrs__"):
+        return {k: getattr(x, k) for k in x.__mypyc_attrs__ if hasattr(x, k)}
+    else:
+        return dict(x.__dict__)
+
+
+def get_function_dict(x: FuncIR) -> dict[str, Any]:
+    """Get a dict of function attributes safe to compare across serialization"""
+    d = get_dict(x)
+    d.pop("blocks", None)
+    d.pop("env", None)
+    return d
+
+
+def assert_blobs_same(x: Any, y: Any, trail: tuple[Any, ...]) -> None:
+    """Compare two blobs of IR as best we can.
+
+    FuncDecls, FuncIRs, and ClassIRs are compared by fullname to avoid
+    infinite recursion.
+    (More detailed comparisons should be done manually.)
+
+    Types and signatures are compared using mypyc.sametype.
+
+    Containers are compared recursively.
+
+    Anything else is compared with ==.
+
+    The `trail` argument is used in error messages.
+    """
+
+    assert type(x) is type(y), (f"Type mismatch at {trail}", type(x), type(y))
+    if isinstance(x, (FuncDecl, FuncIR, ClassIR)):
+        assert x.fullname == y.fullname, f"Name mismatch at {trail}"
+    elif isinstance(x, dict):
+        assert len(x.keys()) == len(y.keys()), f"Keys mismatch at {trail}"
+        for (xk, xv), (yk, yv) in zip(x.items(), y.items()):
+            assert_blobs_same(xk, yk, trail + ("keys",))
+            assert_blobs_same(xv, yv, trail + (xk,))
+    elif isinstance(x, dict):
+        assert x.keys() == y.keys(), f"Keys mismatch at {trail}"
+        for k in x.keys():
+            assert_blobs_same(x[k], y[k], trail + (k,))
+    elif isinstance(x, Iterable) and not isinstance(x, (str, set)):
+        # Special case iterables to generate better assert error messages.
+        # We can't use this for sets since the ordering is unpredictable,
+        # and strings should be treated as atomic values.
+        for i, (xv, yv) in enumerate(zip(x, y)):
+            assert_blobs_same(xv, yv, trail + (i,))
+    elif isinstance(x, RType):
+        assert is_same_type(x, y), f"RType mismatch at {trail}"
+    elif isinstance(x, FuncSignature):
+        assert is_same_signature(x, y), f"Signature mismatch at {trail}"
+    else:
+        assert x == y, f"Value mismatch at {trail}"
+
+
+def assert_modules_same(ir1: ModuleIR, ir2: ModuleIR) -> None:
+    """Assert that two module IRs are the same (*).
+
+    * Or rather, as much as we care about preserving across
+    serialization.  We drop the actual IR bodies of functions but try
+    to preserve everything else.
+    """
+    assert ir1.fullname == ir2.fullname
+
+    assert ir1.imports == ir2.imports
+
+    for cls1, cls2 in zip(ir1.classes, ir2.classes):
+        assert_blobs_same(get_dict(cls1), get_dict(cls2), (ir1.fullname, cls1.fullname))
+
+    for fn1, fn2 in zip(ir1.functions, ir2.functions):
+        assert_blobs_same(
+            get_function_dict(fn1), get_function_dict(fn2), (ir1.fullname, fn1.fullname)
+        )
+        assert_blobs_same(get_dict(fn1.decl), get_dict(fn2.decl), (ir1.fullname, fn1.fullname))
+
+    assert_blobs_same(ir1.final_names, ir2.final_names, (ir1.fullname, "final_names"))
+
+
+def check_serialization_roundtrip(irs: dict[str, ModuleIR]) -> None:
+    """Check that we can serialize modules out and deserialize them to the same thing."""
+    serialized = {k: ir.serialize() for k, ir in irs.items()}
+
+    ctx = DeserMaps({}, {})
+    irs2 = deserialize_modules(serialized, ctx)
+    assert irs.keys() == irs2.keys()
+
+    for k in irs:
+        assert_modules_same(irs[k], irs2[k])