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

mypyc/primitives/str_ops.py

@@ -0,0 +1,229 @@
+"""Primitive str ops."""
+
+from __future__ import annotations
+
+from mypyc.ir.ops import ERR_MAGIC, ERR_NEVER
+from mypyc.ir.rtypes import (
+    RType,
+    bit_rprimitive,
+    bool_rprimitive,
+    bytes_rprimitive,
+    c_int_rprimitive,
+    c_pyssize_t_rprimitive,
+    int_rprimitive,
+    list_rprimitive,
+    object_rprimitive,
+    pointer_rprimitive,
+    str_rprimitive,
+)
+from mypyc.primitives.registry import (
+    ERR_NEG_INT,
+    binary_op,
+    custom_op,
+    function_op,
+    load_address_op,
+    method_op,
+)
+
+# Get the 'str' type object.
+load_address_op(name="builtins.str", type=object_rprimitive, src="PyUnicode_Type")
+
+# str(obj)
+str_op = function_op(
+    name="builtins.str",
+    arg_types=[object_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="PyObject_Str",
+    error_kind=ERR_MAGIC,
+)
+
+# str1 + str2
+binary_op(
+    name="+",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="PyUnicode_Concat",
+    error_kind=ERR_MAGIC,
+)
+
+# str1 += str2
+#
+# PyUnicode_Append makes an effort to reuse the LHS when the refcount
+# is 1. This is super dodgy but oh well, the interpreter does it.
+binary_op(
+    name="+=",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPyStr_Append",
+    error_kind=ERR_MAGIC,
+    steals=[True, False],
+)
+
+unicode_compare = custom_op(
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=c_int_rprimitive,
+    c_function_name="PyUnicode_Compare",
+    error_kind=ERR_NEVER,
+)
+
+# str[index] (for an int index)
+method_op(
+    name="__getitem__",
+    arg_types=[str_rprimitive, int_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPyStr_GetItem",
+    error_kind=ERR_MAGIC,
+)
+
+# str[begin:end]
+str_slice_op = custom_op(
+    arg_types=[str_rprimitive, int_rprimitive, int_rprimitive],
+    return_type=object_rprimitive,
+    c_function_name="CPyStr_GetSlice",
+    error_kind=ERR_MAGIC,
+)
+
+# str.join(obj)
+method_op(
+    name="join",
+    arg_types=[str_rprimitive, object_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="PyUnicode_Join",
+    error_kind=ERR_MAGIC,
+)
+
+str_build_op = custom_op(
+    arg_types=[c_pyssize_t_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPyStr_Build",
+    error_kind=ERR_MAGIC,
+    var_arg_type=str_rprimitive,
+)
+
+# str.startswith(str)
+method_op(
+    name="startswith",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=bool_rprimitive,
+    c_function_name="CPyStr_Startswith",
+    error_kind=ERR_NEVER,
+)
+
+# str.endswith(str)
+method_op(
+    name="endswith",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=bool_rprimitive,
+    c_function_name="CPyStr_Endswith",
+    error_kind=ERR_NEVER,
+)
+
+# str.split(...)
+str_split_types: list[RType] = [str_rprimitive, str_rprimitive, int_rprimitive]
+str_split_functions = ["PyUnicode_Split", "PyUnicode_Split", "CPyStr_Split"]
+str_split_constants: list[list[tuple[int, RType]]] = [
+    [(0, pointer_rprimitive), (-1, c_int_rprimitive)],
+    [(-1, c_int_rprimitive)],
+    [],
+]
+for i in range(len(str_split_types)):
+    method_op(
+        name="split",
+        arg_types=str_split_types[0 : i + 1],
+        return_type=list_rprimitive,
+        c_function_name=str_split_functions[i],
+        extra_int_constants=str_split_constants[i],
+        error_kind=ERR_MAGIC,
+    )
+
+# str.replace(old, new)
+method_op(
+    name="replace",
+    arg_types=[str_rprimitive, str_rprimitive, str_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="PyUnicode_Replace",
+    error_kind=ERR_MAGIC,
+    extra_int_constants=[(-1, c_int_rprimitive)],
+)
+
+# str.replace(old, new, count)
+method_op(
+    name="replace",
+    arg_types=[str_rprimitive, str_rprimitive, str_rprimitive, int_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPyStr_Replace",
+    error_kind=ERR_MAGIC,
+)
+
+# check if a string is true (isn't an empty string)
+str_check_if_true = custom_op(
+    arg_types=[str_rprimitive],
+    return_type=bit_rprimitive,
+    c_function_name="CPyStr_IsTrue",
+    error_kind=ERR_NEVER,
+)
+
+str_ssize_t_size_op = custom_op(
+    arg_types=[str_rprimitive],
+    return_type=c_pyssize_t_rprimitive,
+    c_function_name="CPyStr_Size_size_t",
+    error_kind=ERR_NEG_INT,
+)
+
+# obj.decode()
+method_op(
+    name="decode",
+    arg_types=[bytes_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPy_Decode",
+    error_kind=ERR_MAGIC,
+    extra_int_constants=[(0, pointer_rprimitive), (0, pointer_rprimitive)],
+)
+
+# obj.decode(encoding)
+method_op(
+    name="decode",
+    arg_types=[bytes_rprimitive, str_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPy_Decode",
+    error_kind=ERR_MAGIC,
+    extra_int_constants=[(0, pointer_rprimitive)],
+)
+
+# obj.decode(encoding, errors)
+method_op(
+    name="decode",
+    arg_types=[bytes_rprimitive, str_rprimitive, str_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPy_Decode",
+    error_kind=ERR_MAGIC,
+)
+
+# str.encode()
+method_op(
+    name="encode",
+    arg_types=[str_rprimitive],
+    return_type=bytes_rprimitive,
+    c_function_name="CPy_Encode",
+    error_kind=ERR_MAGIC,
+    extra_int_constants=[(0, pointer_rprimitive), (0, pointer_rprimitive)],
+)
+
+# str.encode(encoding)
+method_op(
+    name="encode",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=bytes_rprimitive,
+    c_function_name="CPy_Encode",
+    error_kind=ERR_MAGIC,
+    extra_int_constants=[(0, pointer_rprimitive)],
+)
+
+# str.encode(encoding, errors)
+method_op(
+    name="encode",
+    arg_types=[str_rprimitive, str_rprimitive, str_rprimitive],
+    return_type=bytes_rprimitive,
+    c_function_name="CPy_Encode",
+    error_kind=ERR_MAGIC,
+)

mypyc/primitives/tuple_ops.py

@@ -0,0 +1,83 @@
+"""Primitive tuple ops for *variable-length* tuples.
+
+Note: Varying-length tuples are represented as boxed Python tuple
+objects, i.e. tuple_rprimitive (RPrimitive), not RTuple.
+"""
+
+from __future__ import annotations
+
+from mypyc.ir.ops import ERR_FALSE, ERR_MAGIC
+from mypyc.ir.rtypes import (
+    bit_rprimitive,
+    c_pyssize_t_rprimitive,
+    int_rprimitive,
+    list_rprimitive,
+    object_rprimitive,
+    tuple_rprimitive,
+)
+from mypyc.primitives.registry import custom_op, function_op, load_address_op, method_op
+
+# Get the 'builtins.tuple' type object.
+load_address_op(name="builtins.tuple", type=object_rprimitive, src="PyTuple_Type")
+
+# tuple[index] (for an int index)
+tuple_get_item_op = method_op(
+    name="__getitem__",
+    arg_types=[tuple_rprimitive, int_rprimitive],
+    return_type=object_rprimitive,
+    c_function_name="CPySequenceTuple_GetItem",
+    error_kind=ERR_MAGIC,
+)
+
+# Construct a boxed tuple from items: (item1, item2, ...)
+new_tuple_op = custom_op(
+    arg_types=[c_pyssize_t_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="PyTuple_Pack",
+    error_kind=ERR_MAGIC,
+    var_arg_type=object_rprimitive,
+)
+
+new_tuple_with_length_op = custom_op(
+    arg_types=[c_pyssize_t_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="PyTuple_New",
+    error_kind=ERR_MAGIC,
+)
+
+# PyTuple_SET_ITEM does no error checking,
+# and should only be used to fill in brand new tuples.
+new_tuple_set_item_op = custom_op(
+    arg_types=[tuple_rprimitive, int_rprimitive, object_rprimitive],
+    return_type=bit_rprimitive,
+    c_function_name="CPySequenceTuple_SetItemUnsafe",
+    error_kind=ERR_FALSE,
+    steals=[False, False, True],
+)
+
+# Construct tuple from a list.
+list_tuple_op = function_op(
+    name="builtins.tuple",
+    arg_types=[list_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="PyList_AsTuple",
+    error_kind=ERR_MAGIC,
+    priority=2,
+)
+
+# Construct tuple from an arbitrary (iterable) object.
+function_op(
+    name="builtins.tuple",
+    arg_types=[object_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="PySequence_Tuple",
+    error_kind=ERR_MAGIC,
+)
+
+# tuple[begin:end]
+tuple_slice_op = custom_op(
+    arg_types=[tuple_rprimitive, int_rprimitive, int_rprimitive],
+    return_type=object_rprimitive,
+    c_function_name="CPySequenceTuple_GetSlice",
+    error_kind=ERR_MAGIC,
+)

mypyc/rt_subtype.py

@@ -0,0 +1,77 @@
+"""'Runtime subtype' check for RTypes.
+
+A type S is a runtime subtype of T if a value of type S can be used at runtime
+when a value of type T is expected without requiring any runtime conversions.
+
+For boxed types, runtime subtyping is the same as regular subtyping.
+Unboxed subtypes, on the other hand, are not runtime subtypes of object
+(since they require boxing to be used as an object), but short ints
+are runtime subtypes of int.
+
+Subtyping is used to determine whether an object can be in a
+particular place and runtime subtyping is used to determine whether a
+coercion is necessary first.
+"""
+
+from __future__ import annotations
+
+from mypyc.ir.rtypes import (
+    RArray,
+    RInstance,
+    RPrimitive,
+    RStruct,
+    RTuple,
+    RType,
+    RTypeVisitor,
+    RUnion,
+    RVoid,
+    is_bit_rprimitive,
+    is_bool_rprimitive,
+    is_int_rprimitive,
+    is_short_int_rprimitive,
+)
+from mypyc.subtype import is_subtype
+
+
+def is_runtime_subtype(left: RType, right: RType) -> bool:
+    return left.accept(RTSubtypeVisitor(right))
+
+
+class RTSubtypeVisitor(RTypeVisitor[bool]):
+    """Is left a runtime subtype of right?
+
+    A few special cases such as right being 'object' are handled in
+    is_runtime_subtype and don't need to be covered here.
+    """
+
+    def __init__(self, right: RType) -> None:
+        self.right = right
+
+    def visit_rinstance(self, left: RInstance) -> bool:
+        return is_subtype(left, self.right)
+
+    def visit_runion(self, left: RUnion) -> bool:
+        return not self.right.is_unboxed and is_subtype(left, self.right)
+
+    def visit_rprimitive(self, left: RPrimitive) -> bool:
+        if is_short_int_rprimitive(left) and is_int_rprimitive(self.right):
+            return True
+        if is_bit_rprimitive(left) and is_bool_rprimitive(self.right):
+            return True
+        return left is self.right
+
+    def visit_rtuple(self, left: RTuple) -> bool:
+        if isinstance(self.right, RTuple):
+            return len(self.right.types) == len(left.types) and all(
+                is_runtime_subtype(t1, t2) for t1, t2 in zip(left.types, self.right.types)
+            )
+        return False
+
+    def visit_rstruct(self, left: RStruct) -> bool:
+        return isinstance(self.right, RStruct) and self.right.name == left.name
+
+    def visit_rarray(self, left: RArray) -> bool:
+        return left == self.right
+
+    def visit_rvoid(self, left: RVoid) -> bool:
+        return isinstance(self.right, RVoid)

mypyc/sametype.py

@@ -0,0 +1,83 @@
+"""Same type check for RTypes."""
+
+from __future__ import annotations
+
+from mypyc.ir.func_ir import FuncSignature
+from mypyc.ir.rtypes import (
+    RArray,
+    RInstance,
+    RPrimitive,
+    RStruct,
+    RTuple,
+    RType,
+    RTypeVisitor,
+    RUnion,
+    RVoid,
+)
+
+
+def is_same_type(a: RType, b: RType) -> bool:
+    return a.accept(SameTypeVisitor(b))
+
+
+def is_same_signature(a: FuncSignature, b: FuncSignature) -> bool:
+    return (
+        len(a.args) == len(b.args)
+        and is_same_type(a.ret_type, b.ret_type)
+        and all(
+            is_same_type(t1.type, t2.type) and t1.name == t2.name for t1, t2 in zip(a.args, b.args)
+        )
+    )
+
+
+def is_same_method_signature(a: FuncSignature, b: FuncSignature) -> bool:
+    return (
+        len(a.args) == len(b.args)
+        and is_same_type(a.ret_type, b.ret_type)
+        and all(
+            is_same_type(t1.type, t2.type)
+            and ((t1.pos_only and t2.pos_only) or t1.name == t2.name)
+            and t1.optional == t2.optional
+            for t1, t2 in zip(a.args[1:], b.args[1:])
+        )
+    )
+
+
+class SameTypeVisitor(RTypeVisitor[bool]):
+    def __init__(self, right: RType) -> None:
+        self.right = right
+
+    def visit_rinstance(self, left: RInstance) -> bool:
+        return isinstance(self.right, RInstance) and left.name == self.right.name
+
+    def visit_runion(self, left: RUnion) -> bool:
+        if isinstance(self.right, RUnion):
+            items = list(self.right.items)
+            for left_item in left.items:
+                for j, right_item in enumerate(items):
+                    if is_same_type(left_item, right_item):
+                        del items[j]
+                        break
+                else:
+                    return False
+            return not items
+        return False
+
+    def visit_rprimitive(self, left: RPrimitive) -> bool:
+        return left is self.right
+
+    def visit_rtuple(self, left: RTuple) -> bool:
+        return (
+            isinstance(self.right, RTuple)
+            and len(self.right.types) == len(left.types)
+            and all(is_same_type(t1, t2) for t1, t2 in zip(left.types, self.right.types))
+        )
+
+    def visit_rstruct(self, left: RStruct) -> bool:
+        return isinstance(self.right, RStruct) and self.right.name == left.name
+
+    def visit_rarray(self, left: RArray) -> bool:
+        return left == self.right
+
+    def visit_rvoid(self, left: RVoid) -> bool:
+        return isinstance(self.right, RVoid)

mypyc/subtype.py

@@ -0,0 +1,88 @@
+"""Subtype check for RTypes."""
+
+from __future__ import annotations
+
+from mypyc.ir.rtypes import (
+    RArray,
+    RInstance,
+    RPrimitive,
+    RStruct,
+    RTuple,
+    RType,
+    RTypeVisitor,
+    RUnion,
+    RVoid,
+    is_bit_rprimitive,
+    is_bool_rprimitive,
+    is_fixed_width_rtype,
+    is_int_rprimitive,
+    is_object_rprimitive,
+    is_short_int_rprimitive,
+    is_tagged,
+    is_tuple_rprimitive,
+)
+
+
+def is_subtype(left: RType, right: RType) -> bool:
+    if is_object_rprimitive(right):
+        return True
+    elif isinstance(right, RUnion):
+        if isinstance(left, RUnion):
+            for left_item in left.items:
+                if not any(is_subtype(left_item, right_item) for right_item in right.items):
+                    return False
+            return True
+        else:
+            return any(is_subtype(left, item) for item in right.items)
+    return left.accept(SubtypeVisitor(right))
+
+
+class SubtypeVisitor(RTypeVisitor[bool]):
+    """Is left a subtype of right?
+
+    A few special cases such as right being 'object' are handled in
+    is_subtype and don't need to be covered here.
+    """
+
+    def __init__(self, right: RType) -> None:
+        self.right = right
+
+    def visit_rinstance(self, left: RInstance) -> bool:
+        return isinstance(self.right, RInstance) and self.right.class_ir in left.class_ir.mro
+
+    def visit_runion(self, left: RUnion) -> bool:
+        return all(is_subtype(item, self.right) for item in left.items)
+
+    def visit_rprimitive(self, left: RPrimitive) -> bool:
+        right = self.right
+        if is_bool_rprimitive(left):
+            if is_tagged(right) or is_fixed_width_rtype(right):
+                return True
+        elif is_bit_rprimitive(left):
+            if is_bool_rprimitive(right) or is_tagged(right) or is_fixed_width_rtype(right):
+                return True
+        elif is_short_int_rprimitive(left):
+            if is_int_rprimitive(right):
+                return True
+        elif is_fixed_width_rtype(left):
+            if is_int_rprimitive(right):
+                return True
+        return left is right
+
+    def visit_rtuple(self, left: RTuple) -> bool:
+        if is_tuple_rprimitive(self.right):
+            return True
+        if isinstance(self.right, RTuple):
+            return len(self.right.types) == len(left.types) and all(
+                is_subtype(t1, t2) for t1, t2 in zip(left.types, self.right.types)
+            )
+        return False
+
+    def visit_rstruct(self, left: RStruct) -> bool:
+        return isinstance(self.right, RStruct) and self.right.name == left.name
+
+    def visit_rarray(self, left: RArray) -> bool:
+        return left == self.right
+
+    def visit_rvoid(self, left: RVoid) -> bool:
+        return isinstance(self.right, RVoid)

mypyc/test/config.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import os
+
+provided_prefix = os.getenv("MYPY_TEST_PREFIX", None)
+if provided_prefix:
+    PREFIX = provided_prefix
+else:
+    this_file_dir = os.path.dirname(os.path.realpath(__file__))
+    PREFIX = os.path.dirname(os.path.dirname(this_file_dir))
+
+# Location of test data files such as test case descriptions.
+test_data_prefix = os.path.join(PREFIX, "mypyc", "test-data")

mypyc/test/test_alwaysdefined.py

@@ -0,0 +1,46 @@
+"""Test cases for inferring always defined attributes in classes."""
+
+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.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    MypycDataSuite,
+    assert_test_output,
+    build_ir_for_single_file2,
+    infer_ir_build_options_from_test_name,
+    use_custom_builtins,
+)
+
+files = ["alwaysdefined.test"]
+
+
+class TestAlwaysDefined(MypycDataSuite):
+    files = files
+    base_path = test_temp_dir
+
+    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):
+            try:
+                ir = build_ir_for_single_file2(testcase.input, options)
+            except CompileError as e:
+                actual = e.messages
+            else:
+                actual = []
+                for cl in ir.classes:
+                    if cl.name.startswith("_"):
+                        continue
+                    actual.append(
+                        "{}: [{}]".format(cl.name, ", ".join(sorted(cl._always_initialized_attrs)))
+                    )
+
+            assert_test_output(testcase, actual, "Invalid test output", testcase.output)

mypyc/test/test_analysis.py

@@ -0,0 +1,77 @@
+"""Test runner for data-flow analysis test cases."""
+
+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.analysis import dataflow
+from mypyc.common import TOP_LEVEL_NAME
+from mypyc.ir.func_ir import all_values
+from mypyc.ir.ops import Value
+from mypyc.ir.pprint import format_func, generate_names_for_ir
+from mypyc.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    MypycDataSuite,
+    assert_test_output,
+    build_ir_for_single_file,
+    use_custom_builtins,
+)
+from mypyc.transform import exceptions
+
+files = ["analysis.test"]
+
+
+class TestAnalysis(MypycDataSuite):
+    files = files
+    base_path = test_temp_dir
+    optional_out = True
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        """Perform a data-flow analysis test case."""
+
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
+            try:
+                ir = build_ir_for_single_file(testcase.input)
+            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
+                    exceptions.insert_exception_handling(fn)
+                    actual.extend(format_func(fn))
+                    cfg = dataflow.get_cfg(fn.blocks)
+                    args: set[Value] = set(fn.arg_regs)
+                    name = testcase.name
+                    if name.endswith("_MaybeDefined"):
+                        # Forward, maybe
+                        analysis_result = dataflow.analyze_maybe_defined_regs(fn.blocks, cfg, args)
+                    elif name.endswith("_Liveness"):
+                        # Backward, maybe
+                        analysis_result = dataflow.analyze_live_regs(fn.blocks, cfg)
+                    elif name.endswith("_MustDefined"):
+                        # Forward, must
+                        analysis_result = dataflow.analyze_must_defined_regs(
+                            fn.blocks, cfg, args, regs=all_values(fn.arg_regs, fn.blocks)
+                        )
+                    elif name.endswith("_BorrowedArgument"):
+                        # Forward, must
+                        analysis_result = dataflow.analyze_borrowed_arguments(fn.blocks, cfg, args)
+                    else:
+                        assert False, "No recognized _AnalysisName suffix in test case"
+
+                    names = generate_names_for_ir(fn.arg_regs, fn.blocks)
+
+                    for key in sorted(
+                        analysis_result.before.keys(), key=lambda x: (x[0].label, x[1])
+                    ):
+                        pre = ", ".join(sorted(names[reg] for reg in analysis_result.before[key]))
+                        post = ", ".join(sorted(names[reg] for reg in analysis_result.after[key]))
+                        actual.append(
+                            "%-8s %-23s %s" % ((key[0].label, key[1]), "{%s}" % pre, "{%s}" % post)
+                        )
+            assert_test_output(testcase, actual, "Invalid source code output")