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

mypyc/test/test_struct.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import unittest
+
+from mypyc.ir.rtypes import (
+    RStruct,
+    bool_rprimitive,
+    int32_rprimitive,
+    int64_rprimitive,
+    int_rprimitive,
+    object_rprimitive,
+)
+from mypyc.rt_subtype import is_runtime_subtype
+
+
+class TestStruct(unittest.TestCase):
+    def test_struct_offsets(self) -> None:
+        # test per-member alignment
+        r = RStruct("", [], [bool_rprimitive, int32_rprimitive, int64_rprimitive])
+        assert r.size == 16
+        assert r.offsets == [0, 4, 8]
+
+        # test final alignment
+        r1 = RStruct("", [], [bool_rprimitive, bool_rprimitive])
+        assert r1.size == 2
+        assert r1.offsets == [0, 1]
+        r2 = RStruct("", [], [int32_rprimitive, bool_rprimitive])
+        r3 = RStruct("", [], [int64_rprimitive, bool_rprimitive])
+        assert r2.offsets == [0, 4]
+        assert r3.offsets == [0, 8]
+        assert r2.size == 8
+        assert r3.size == 16
+
+        r4 = RStruct("", [], [bool_rprimitive, bool_rprimitive, bool_rprimitive, int32_rprimitive])
+        assert r4.size == 8
+        assert r4.offsets == [0, 1, 2, 4]
+
+        # test nested struct
+        r5 = RStruct("", [], [bool_rprimitive, r])
+        assert r5.offsets == [0, 8]
+        assert r5.size == 24
+        r6 = RStruct("", [], [int32_rprimitive, r5])
+        assert r6.offsets == [0, 8]
+        assert r6.size == 32
+        # test nested struct with alignment less than 8
+        r7 = RStruct("", [], [bool_rprimitive, r4])
+        assert r7.offsets == [0, 4]
+        assert r7.size == 12
+
+    def test_struct_str(self) -> None:
+        r = RStruct("Foo", ["a", "b"], [bool_rprimitive, object_rprimitive])
+        assert str(r) == "Foo{a:bool, b:object}"
+        assert (
+            repr(r) == "<RStruct Foo{a:<RPrimitive builtins.bool>, "
+            "b:<RPrimitive builtins.object>}>"
+        )
+        r1 = RStruct("Bar", ["c"], [int32_rprimitive])
+        assert str(r1) == "Bar{c:i32}"
+        assert repr(r1) == "<RStruct Bar{c:<RPrimitive i32>}>"
+        r2 = RStruct("Baz", [], [])
+        assert str(r2) == "Baz{}"
+        assert repr(r2) == "<RStruct Baz{}>"
+
+    def test_runtime_subtype(self) -> None:
+        # right type to check with
+        r = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive])
+
+        # using the exact same fields
+        r1 = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive])
+
+        # names different
+        r2 = RStruct("Bar", ["c", "b"], [bool_rprimitive, int_rprimitive])
+
+        # name different
+        r3 = RStruct("Baz", ["a", "b"], [bool_rprimitive, int_rprimitive])
+
+        # type different
+        r4 = RStruct("FooBar", ["a", "b"], [bool_rprimitive, int32_rprimitive])
+
+        # number of types different
+        r5 = RStruct(
+            "FooBarBaz", ["a", "b", "c"], [bool_rprimitive, int_rprimitive, bool_rprimitive]
+        )
+
+        assert is_runtime_subtype(r1, r) is True
+        assert is_runtime_subtype(r2, r) is False
+        assert is_runtime_subtype(r3, r) is False
+        assert is_runtime_subtype(r4, r) is False
+        assert is_runtime_subtype(r5, r) is False
+
+    def test_eq_and_hash(self) -> None:
+        r = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive])
+
+        # using the exact same fields
+        r1 = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive])
+        assert hash(r) == hash(r1)
+        assert r == r1
+
+        # different name
+        r2 = RStruct("Foq", ["a", "b"], [bool_rprimitive, int_rprimitive])
+        assert hash(r) != hash(r2)
+        assert r != r2
+
+        # different names
+        r3 = RStruct("Foo", ["a", "c"], [bool_rprimitive, int_rprimitive])
+        assert hash(r) != hash(r3)
+        assert r != r3
+
+        # different type
+        r4 = RStruct("Foo", ["a", "b"], [bool_rprimitive, int_rprimitive, bool_rprimitive])
+        assert hash(r) != hash(r4)
+        assert r != r4

mypyc/test/test_tuplename.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import unittest
+
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.rtypes import (
+    RInstance,
+    RTuple,
+    RUnion,
+    bool_rprimitive,
+    int_rprimitive,
+    list_rprimitive,
+    object_rprimitive,
+)
+
+
+class TestTupleNames(unittest.TestCase):
+    def setUp(self) -> None:
+        self.inst_a = RInstance(ClassIR("A", "__main__"))
+        self.inst_b = RInstance(ClassIR("B", "__main__"))
+
+    def test_names(self) -> None:
+        assert RTuple([int_rprimitive, int_rprimitive]).unique_id == "T2II"
+        assert RTuple([list_rprimitive, object_rprimitive, self.inst_a]).unique_id == "T3OOO"
+        assert RTuple([list_rprimitive, object_rprimitive, self.inst_b]).unique_id == "T3OOO"
+        assert RTuple([]).unique_id == "T0"
+        assert (
+            RTuple([RTuple([]), RTuple([int_rprimitive, int_rprimitive])]).unique_id == "T2T0T2II"
+        )
+        assert (
+            RTuple([bool_rprimitive, RUnion([bool_rprimitive, int_rprimitive])]).unique_id
+            == "T2CO"
+        )

mypyc/test/test_typeops.py

@@ -0,0 +1,97 @@
+"""Test cases for various RType operations."""
+
+from __future__ import annotations
+
+import unittest
+
+from mypyc.ir.rtypes import (
+    RUnion,
+    bit_rprimitive,
+    bool_rprimitive,
+    int16_rprimitive,
+    int32_rprimitive,
+    int64_rprimitive,
+    int_rprimitive,
+    object_rprimitive,
+    short_int_rprimitive,
+    str_rprimitive,
+)
+from mypyc.rt_subtype import is_runtime_subtype
+from mypyc.subtype import is_subtype
+
+native_int_types = [int64_rprimitive, int32_rprimitive, int16_rprimitive]
+
+
+class TestSubtype(unittest.TestCase):
+    def test_bit(self) -> None:
+        assert is_subtype(bit_rprimitive, bool_rprimitive)
+        assert is_subtype(bit_rprimitive, int_rprimitive)
+        assert is_subtype(bit_rprimitive, short_int_rprimitive)
+        for rt in native_int_types:
+            assert is_subtype(bit_rprimitive, rt)
+
+    def test_bool(self) -> None:
+        assert not is_subtype(bool_rprimitive, bit_rprimitive)
+        assert is_subtype(bool_rprimitive, int_rprimitive)
+        assert is_subtype(bool_rprimitive, short_int_rprimitive)
+        for rt in native_int_types:
+            assert is_subtype(bool_rprimitive, rt)
+
+    def test_int64(self) -> None:
+        assert is_subtype(int64_rprimitive, int64_rprimitive)
+        assert is_subtype(int64_rprimitive, int_rprimitive)
+        assert not is_subtype(int64_rprimitive, short_int_rprimitive)
+        assert not is_subtype(int64_rprimitive, int32_rprimitive)
+        assert not is_subtype(int64_rprimitive, int16_rprimitive)
+
+    def test_int32(self) -> None:
+        assert is_subtype(int32_rprimitive, int32_rprimitive)
+        assert is_subtype(int32_rprimitive, int_rprimitive)
+        assert not is_subtype(int32_rprimitive, short_int_rprimitive)
+        assert not is_subtype(int32_rprimitive, int64_rprimitive)
+        assert not is_subtype(int32_rprimitive, int16_rprimitive)
+
+    def test_int16(self) -> None:
+        assert is_subtype(int16_rprimitive, int16_rprimitive)
+        assert is_subtype(int16_rprimitive, int_rprimitive)
+        assert not is_subtype(int16_rprimitive, short_int_rprimitive)
+        assert not is_subtype(int16_rprimitive, int64_rprimitive)
+        assert not is_subtype(int16_rprimitive, int32_rprimitive)
+
+
+class TestRuntimeSubtype(unittest.TestCase):
+    def test_bit(self) -> None:
+        assert is_runtime_subtype(bit_rprimitive, bool_rprimitive)
+        assert not is_runtime_subtype(bit_rprimitive, int_rprimitive)
+
+    def test_bool(self) -> None:
+        assert not is_runtime_subtype(bool_rprimitive, bit_rprimitive)
+        assert not is_runtime_subtype(bool_rprimitive, int_rprimitive)
+
+    def test_union(self) -> None:
+        bool_int_mix = RUnion([bool_rprimitive, int_rprimitive])
+        assert not is_runtime_subtype(bool_int_mix, short_int_rprimitive)
+        assert not is_runtime_subtype(bool_int_mix, int_rprimitive)
+        assert not is_runtime_subtype(short_int_rprimitive, bool_int_mix)
+        assert not is_runtime_subtype(int_rprimitive, bool_int_mix)
+
+
+class TestUnionSimplification(unittest.TestCase):
+    def test_simple_type_result(self) -> None:
+        assert RUnion.make_simplified_union([int_rprimitive]) == int_rprimitive
+
+    def test_remove_duplicate(self) -> None:
+        assert RUnion.make_simplified_union([int_rprimitive, int_rprimitive]) == int_rprimitive
+
+    def test_cannot_simplify(self) -> None:
+        assert RUnion.make_simplified_union(
+            [int_rprimitive, str_rprimitive, object_rprimitive]
+        ) == RUnion([int_rprimitive, str_rprimitive, object_rprimitive])
+
+    def test_nested(self) -> None:
+        assert RUnion.make_simplified_union(
+            [int_rprimitive, RUnion([str_rprimitive, int_rprimitive])]
+        ) == RUnion([int_rprimitive, str_rprimitive])
+        assert RUnion.make_simplified_union(
+            [int_rprimitive, RUnion([str_rprimitive, RUnion([int_rprimitive])])]
+        ) == RUnion([int_rprimitive, str_rprimitive])

mypyc/test/testutil.py

@@ -0,0 +1,283 @@
+"""Helpers for writing tests"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import os.path
+import re
+import shutil
+from typing import Callable, 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, DataSuite
+from mypy.test.helpers import assert_string_arrays_equal
+from mypyc.analysis.ircheck import assert_func_ir_valid
+from mypyc.common import IS_32_BIT_PLATFORM, PLATFORM_SIZE
+from mypyc.errors import Errors
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.module_ir import ModuleIR
+from mypyc.irbuild.main import build_ir
+from mypyc.irbuild.mapper import Mapper
+from mypyc.options import CompilerOptions
+from mypyc.test.config import test_data_prefix
+
+# The builtins stub used during icode generation test cases.
+ICODE_GEN_BUILTINS = os.path.join(test_data_prefix, "fixtures/ir.py")
+# The testutil support library
+TESTUTIL_PATH = os.path.join(test_data_prefix, "fixtures/testutil.py")
+
+
+class MypycDataSuite(DataSuite):
+    # Need to list no files, since this will be picked up as a suite of tests
+    files: list[str] = []
+    data_prefix = test_data_prefix
+
+
+def builtins_wrapper(
+    func: Callable[[DataDrivenTestCase], None], path: str
+) -> Callable[[DataDrivenTestCase], None]:
+    """Decorate a function that implements a data-driven test case to copy an
+    alternative builtins module implementation in place before performing the
+    test case. Clean up after executing the test case.
+    """
+    return lambda testcase: perform_test(func, path, testcase)
+
+
+@contextlib.contextmanager
+def use_custom_builtins(builtins_path: str, testcase: DataDrivenTestCase) -> Iterator[None]:
+    for path, _ in testcase.files:
+        if os.path.basename(path) == "builtins.pyi":
+            default_builtins = False
+            break
+    else:
+        # Use default builtins.
+        builtins = os.path.abspath(os.path.join(test_temp_dir, "builtins.pyi"))
+        shutil.copyfile(builtins_path, builtins)
+        default_builtins = True
+
+    # Actually perform the test case.
+    try:
+        yield None
+    finally:
+        if default_builtins:
+            # Clean up.
+            os.remove(builtins)
+
+
+def perform_test(
+    func: Callable[[DataDrivenTestCase], None], builtins_path: str, testcase: DataDrivenTestCase
+) -> None:
+    for path, _ in testcase.files:
+        if os.path.basename(path) == "builtins.py":
+            default_builtins = False
+            break
+    else:
+        # Use default builtins.
+        builtins = os.path.join(test_temp_dir, "builtins.py")
+        shutil.copyfile(builtins_path, builtins)
+        default_builtins = True
+
+    # Actually perform the test case.
+    func(testcase)
+
+    if default_builtins:
+        # Clean up.
+        os.remove(builtins)
+
+
+def build_ir_for_single_file(
+    input_lines: list[str], compiler_options: CompilerOptions | None = None
+) -> list[FuncIR]:
+    return build_ir_for_single_file2(input_lines, compiler_options).functions
+
+
+def build_ir_for_single_file2(
+    input_lines: list[str], compiler_options: CompilerOptions | None = None
+) -> ModuleIR:
+    program_text = "\n".join(input_lines)
+
+    # By default generate IR compatible with the earliest supported Python C API.
+    # If a test needs more recent API features, this should be overridden.
+    compiler_options = compiler_options or CompilerOptions(capi_version=(3, 7))
+    options = Options()
+    options.show_traceback = True
+    options.hide_error_codes = True
+    options.use_builtins_fixtures = True
+    options.strict_optional = True
+    options.python_version = compiler_options.python_version or (3, 6)
+    options.export_types = True
+    options.preserve_asts = True
+    options.allow_empty_bodies = True
+    options.per_module_options["__main__"] = {"mypyc": True}
+
+    source = build.BuildSource("main", "__main__", program_text)
+    # Construct input as a single single.
+    # Parse and type check the input program.
+    result = build.build(sources=[source], options=options, alt_lib_path=test_temp_dir)
+    if result.errors:
+        raise CompileError(result.errors)
+
+    errors = Errors(options)
+    modules = build_ir(
+        [result.files["__main__"]],
+        result.graph,
+        result.types,
+        Mapper({"__main__": None}),
+        compiler_options,
+        errors,
+    )
+    if errors.num_errors:
+        raise CompileError(errors.new_messages())
+
+    module = list(modules.values())[0]
+    for fn in module.functions:
+        assert_func_ir_valid(fn)
+    return module
+
+
+def update_testcase_output(testcase: DataDrivenTestCase, output: list[str]) -> None:
+    # TODO: backport this to mypy
+    assert testcase.old_cwd is not None, "test was not properly set up"
+    testcase_path = os.path.join(testcase.old_cwd, testcase.file)
+    with open(testcase_path) as f:
+        data_lines = f.read().splitlines()
+
+    # We can't rely on the test line numbers to *find* the test, since
+    # we might fix multiple tests in a run. So find it by the case
+    # header. Give up if there are multiple tests with the same name.
+    test_slug = f"[case {testcase.name}]"
+    if data_lines.count(test_slug) != 1:
+        return
+    start_idx = data_lines.index(test_slug)
+    stop_idx = start_idx + 11
+    while stop_idx < len(data_lines) and not data_lines[stop_idx].startswith("[case "):
+        stop_idx += 1
+
+    test = data_lines[start_idx:stop_idx]
+    out_start = test.index("[out]")
+    test[out_start + 1 :] = output
+    data_lines[start_idx:stop_idx] = test + [""]
+    data = "\n".join(data_lines)
+
+    with open(testcase_path, "w") as f:
+        print(data, file=f)
+
+
+def assert_test_output(
+    testcase: DataDrivenTestCase,
+    actual: list[str],
+    message: str,
+    expected: list[str] | None = None,
+    formatted: list[str] | None = None,
+) -> None:
+    __tracebackhide__ = True
+
+    expected_output = expected if expected is not None else testcase.output
+    if expected_output != actual and testcase.config.getoption("--update-data", False):
+        update_testcase_output(testcase, actual)
+
+    assert_string_arrays_equal(
+        expected_output, actual, f"{message} ({testcase.file}, line {testcase.line})"
+    )
+
+
+def get_func_names(expected: list[str]) -> list[str]:
+    res = []
+    for s in expected:
+        m = re.match(r"def ([_a-zA-Z0-9.*$]+)\(", s)
+        if m:
+            res.append(m.group(1))
+    return res
+
+
+def remove_comment_lines(a: list[str]) -> list[str]:
+    """Return a copy of array with comments removed.
+
+    Lines starting with '--' (but not with '---') are removed.
+    """
+    r = []
+    for s in a:
+        if s.strip().startswith("--") and not s.strip().startswith("---"):
+            pass
+        else:
+            r.append(s)
+    return r
+
+
+def print_with_line_numbers(s: str) -> None:
+    lines = s.splitlines()
+    for i, line in enumerate(lines):
+        print("%-4d %s" % (i + 1, line))
+
+
+def heading(text: str) -> None:
+    print("=" * 20 + " " + text + " " + "=" * 20)
+
+
+def show_c(cfiles: list[list[tuple[str, str]]]) -> None:
+    heading("Generated C")
+    for group in cfiles:
+        for cfile, ctext in group:
+            print(f"== {cfile} ==")
+            print_with_line_numbers(ctext)
+    heading("End C")
+
+
+def fudge_dir_mtimes(dir: str, delta: int) -> None:
+    for dirpath, _, filenames in os.walk(dir):
+        for name in filenames:
+            path = os.path.join(dirpath, name)
+            new_mtime = os.stat(path).st_mtime + delta
+            os.utime(path, times=(new_mtime, new_mtime))
+
+
+def replace_word_size(text: list[str]) -> list[str]:
+    """Replace WORDSIZE with platform specific word sizes"""
+    result = []
+    for line in text:
+        index = line.find("WORD_SIZE")
+        if index != -1:
+            # get 'WORDSIZE*n' token
+            word_size_token = line[index:].split()[0]
+            n = int(word_size_token[10:])
+            replace_str = str(PLATFORM_SIZE * n)
+            result.append(line.replace(word_size_token, replace_str))
+        else:
+            result.append(line)
+    return result
+
+
+def infer_ir_build_options_from_test_name(name: str) -> CompilerOptions | None:
+    """Look for magic substrings in test case name to set compiler options.
+
+    Return None if the test case should be skipped (always pass).
+
+    Supported naming conventions:
+
+      *_64bit*:
+          Run test case only on 64-bit platforms
+      *_32bit*:
+          Run test caseonly on 32-bit platforms
+      *_python3_8* (or for any Python version):
+          Use Python 3.8+ C API features (default: lowest supported version)
+      *StripAssert*:
+          Don't generate code for assert statements
+    """
+    # If this is specific to some bit width, always pass if platform doesn't match.
+    if "_64bit" in name and IS_32_BIT_PLATFORM:
+        return None
+    if "_32bit" in name and not IS_32_BIT_PLATFORM:
+        return None
+    options = CompilerOptions(strip_asserts="StripAssert" in name, capi_version=(3, 7))
+    # A suffix like _python3.8 is used to set the target C API version.
+    m = re.search(r"_python([3-9]+)_([0-9]+)(_|\b)", name)
+    if m:
+        options.capi_version = (int(m.group(1)), int(m.group(2)))
+        options.python_version = options.capi_version
+    elif "_py" in name or "_Python" in name:
+        assert False, f"Invalid _py* suffix (should be _pythonX_Y): {name}"
+    return options