jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/lower/int_ops.py

@@ -1,113 +0,0 @@
-"""Convert tagged int primitive ops to lower-level ops."""
-
-from __future__ import annotations
-
-from typing import NamedTuple
-
-from mypyc.ir.ops import Assign, BasicBlock, Branch, ComparisonOp, Register, Value
-from mypyc.ir.rtypes import bool_rprimitive, is_short_int_rprimitive
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-from mypyc.lower.registry import lower_primitive_op
-from mypyc.primitives.int_ops import int_equal_, int_less_than_
-from mypyc.primitives.registry import CFunctionDescription
-
-
-# Description for building int comparison ops
-#
-# Fields:
-#   binary_op_variant: identify which IntOp to use when operands are short integers
-#   c_func_description: the C function to call when operands are tagged integers
-#   c_func_negated: whether to negate the C function call's result
-#   c_func_swap_operands: whether to swap lhs and rhs when call the function
-class IntComparisonOpDescription(NamedTuple):
-    binary_op_variant: int
-    c_func_description: CFunctionDescription
-    c_func_negated: bool
-    c_func_swap_operands: bool
-
-
-# Provide mapping from textual op to short int's op variant and boxed int's description.
-# Note that these are not complete implementations and require extra IR.
-int_comparison_op_mapping: dict[str, IntComparisonOpDescription] = {
-    "==": IntComparisonOpDescription(ComparisonOp.EQ, int_equal_, False, False),
-    "!=": IntComparisonOpDescription(ComparisonOp.NEQ, int_equal_, True, False),
-    "<": IntComparisonOpDescription(ComparisonOp.SLT, int_less_than_, False, False),
-    "<=": IntComparisonOpDescription(ComparisonOp.SLE, int_less_than_, True, True),
-    ">": IntComparisonOpDescription(ComparisonOp.SGT, int_less_than_, False, True),
-    ">=": IntComparisonOpDescription(ComparisonOp.SGE, int_less_than_, True, False),
-}
-
-
-def compare_tagged(self: LowLevelIRBuilder, lhs: Value, rhs: Value, op: str, line: int) -> Value:
-    """Compare two tagged integers using given operator (value context)."""
-    # generate fast binary logic ops on short ints
-    if (is_short_int_rprimitive(lhs.type) or is_short_int_rprimitive(rhs.type)) and op in (
-        "==",
-        "!=",
-    ):
-        quick = True
-    else:
-        quick = is_short_int_rprimitive(lhs.type) and is_short_int_rprimitive(rhs.type)
-    if quick:
-        return self.comparison_op(lhs, rhs, int_comparison_op_mapping[op][0], line)
-    op_type, c_func_desc, negate_result, swap_op = int_comparison_op_mapping[op]
-    result = Register(bool_rprimitive)
-    short_int_block, int_block, out = BasicBlock(), BasicBlock(), BasicBlock()
-    check_lhs = self.check_tagged_short_int(lhs, line, negated=True)
-    if op in ("==", "!="):
-        self.add(Branch(check_lhs, int_block, short_int_block, Branch.BOOL))
-    else:
-        # for non-equality logical ops (less/greater than, etc.), need to check both sides
-        short_lhs = BasicBlock()
-        self.add(Branch(check_lhs, int_block, short_lhs, Branch.BOOL))
-        self.activate_block(short_lhs)
-        check_rhs = self.check_tagged_short_int(rhs, line, negated=True)
-        self.add(Branch(check_rhs, int_block, short_int_block, Branch.BOOL))
-    self.activate_block(int_block)
-    if swap_op:
-        args = [rhs, lhs]
-    else:
-        args = [lhs, rhs]
-    call = self.call_c(c_func_desc, args, line)
-    if negate_result:
-        # TODO: introduce UnaryIntOp?
-        call_result = self.unary_op(call, "not", line)
-    else:
-        call_result = call
-    self.add(Assign(result, call_result, line))
-    self.goto(out)
-    self.activate_block(short_int_block)
-    eq = self.comparison_op(lhs, rhs, op_type, line)
-    self.add(Assign(result, eq, line))
-    self.goto_and_activate(out)
-    return result
-
-
-@lower_primitive_op("int_eq")
-def lower_int_eq(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    return compare_tagged(builder, args[0], args[1], "==", line)
-
-
-@lower_primitive_op("int_ne")
-def lower_int_ne(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    return compare_tagged(builder, args[0], args[1], "!=", line)
-
-
-@lower_primitive_op("int_lt")
-def lower_int_lt(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    return compare_tagged(builder, args[0], args[1], "<", line)
-
-
-@lower_primitive_op("int_le")
-def lower_int_le(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    return compare_tagged(builder, args[0], args[1], "<=", line)
-
-
-@lower_primitive_op("int_gt")
-def lower_int_gt(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    return compare_tagged(builder, args[0], args[1], ">", line)
-
-
-@lower_primitive_op("int_ge")
-def lower_int_ge(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    return compare_tagged(builder, args[0], args[1], ">=", line)

jaclang/vendor/mypyc/lower/list_ops.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-from mypyc.common import PLATFORM_SIZE
-from mypyc.ir.ops import GetElementPtr, Integer, IntOp, LoadMem, SetMem, Value
-from mypyc.ir.rtypes import (
-    PyListObject,
-    c_pyssize_t_rprimitive,
-    object_rprimitive,
-    pointer_rprimitive,
-)
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-from mypyc.lower.registry import lower_primitive_op
-
-
-@lower_primitive_op("buf_init_item")
-def buf_init_item(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    """Initialize an item in a buffer of "PyObject *" values at given index.
-
-    This can be used to initialize the data buffer of a freshly allocated list
-    object.
-    """
-    base = args[0]
-    index_value = args[1]
-    value = args[2]
-    assert isinstance(index_value, Integer)
-    index = index_value.numeric_value()
-    if index == 0:
-        ptr = base
-    else:
-        ptr = builder.add(
-            IntOp(
-                pointer_rprimitive,
-                base,
-                Integer(index * PLATFORM_SIZE, c_pyssize_t_rprimitive),
-                IntOp.ADD,
-                line,
-            )
-        )
-    return builder.add(SetMem(object_rprimitive, ptr, value, line))
-
-
-@lower_primitive_op("list_items")
-def list_items(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    ob_item_ptr = builder.add(GetElementPtr(args[0], PyListObject, "ob_item", line))
-    return builder.add(LoadMem(pointer_rprimitive, ob_item_ptr, line))

jaclang/vendor/mypyc/lower/misc_ops.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from mypyc.ir.ops import GetElementPtr, LoadMem, Value
-from mypyc.ir.rtypes import PyVarObject, c_pyssize_t_rprimitive
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-from mypyc.lower.registry import lower_primitive_op
-
-
-@lower_primitive_op("var_object_size")
-def var_object_size(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
-    elem_address = builder.add(GetElementPtr(args[0], PyVarObject, "ob_size"))
-    return builder.add(LoadMem(c_pyssize_t_rprimitive, elem_address))

jaclang/vendor/mypyc/lower/registry.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from typing import Callable, Final, List
-
-from mypyc.ir.ops import Value
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-
-LowerFunc = Callable[[LowLevelIRBuilder, List[Value], int], Value]
-
-
-lowering_registry: Final[dict[str, LowerFunc]] = {}
-
-
-def lower_primitive_op(name: str) -> Callable[[LowerFunc], LowerFunc]:
-    """Register a handler that generates low-level IR for a primitive op."""
-
-    def wrapper(f: LowerFunc) -> LowerFunc:
-        assert name not in lowering_registry
-        lowering_registry[name] = f
-        return f
-
-    return wrapper
-
-
-# Import various modules that set up global state.
-from mypyc.lower import int_ops, list_ops, misc_ops  # noqa: F401

jaclang/vendor/mypyc/namegen.py

@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-from typing import Iterable
-
-
-class NameGenerator:
-    """Utility for generating distinct C names from Python names.
-
-    Since C names can't use '.' (or unicode), some care is required to
-    make C names generated from Python names unique. Also, we want to
-    avoid generating overly long C names since they make the generated
-    code harder to read.
-
-    Note that we don't restrict ourselves to a 32-character distinguishing
-    prefix guaranteed by the C standard since all the compilers we care
-    about at the moment support longer names without issues.
-
-    For names that are exported in a shared library (not static) use
-    exported_name() instead.
-
-    Summary of the approach:
-
-    * Generate a unique name prefix from suffix of fully-qualified
-      module name used for static names. If only compiling a single
-      module, this can be empty. For example, if the modules are
-      'foo.bar' and 'foo.baz', the prefixes can be 'bar_' and 'baz_',
-      respectively. If the modules are 'bar.foo' and 'baz.foo', the
-      prefixes will be 'bar_foo_' and 'baz_foo_'.
-
-    * Replace '.' in the Python name with '___' in the C name. (And
-      replace the unlikely but possible '___' with '___3_'. This
-      collides '___' with '.3_', but this is OK because names
-      may not start with a digit.)
-
-    The generated should be internal to a build and thus the mapping is
-    arbitrary. Just generating names '1', '2', ... would be correct,
-    though not very usable.
-    """
-
-    def __init__(self, groups: Iterable[list[str]]) -> None:
-        """Initialize with a list of modules in each compilation group.
-
-        The names of modules are used to shorten names referring to
-        modules, for convenience. Arbitrary module
-        names are supported for generated names, but uncompiled modules
-        will use long names.
-        """
-        self.module_map: dict[str, str] = {}
-        for names in groups:
-            self.module_map.update(make_module_translation_map(names))
-        self.translations: dict[tuple[str, str], str] = {}
-        self.used_names: set[str] = set()
-
-    def private_name(self, module: str, partial_name: str | None = None) -> str:
-        """Return a C name usable for a static definition.
-
-        Return a distinct result for each (module, partial_name) pair.
-
-        The caller should add a suitable prefix to the name to avoid
-        conflicts with other C names. Only ensure that the results of
-        this function are unique, not that they aren't overlapping with
-        arbitrary names.
-
-        If a name is not specific to any module, the module argument can
-        be an empty string.
-        """
-        # TODO: Support unicode
-        if partial_name is None:
-            return exported_name(self.module_map[module].rstrip("."))
-        if (module, partial_name) in self.translations:
-            return self.translations[module, partial_name]
-        if module in self.module_map:
-            module_prefix = self.module_map[module]
-        elif module:
-            module_prefix = module + "."
-        else:
-            module_prefix = ""
-        actual = exported_name(f"{module_prefix}{partial_name}")
-        self.translations[module, partial_name] = actual
-        return actual
-
-
-def exported_name(fullname: str) -> str:
-    """Return a C name usable for an exported definition.
-
-    This is like private_name(), but the output only depends on the
-    'fullname' argument, so the names are distinct across multiple
-    builds.
-    """
-    # TODO: Support unicode
-    return fullname.replace("___", "___3_").replace(".", "___")
-
-
-def make_module_translation_map(names: list[str]) -> dict[str, str]:
-    num_instances: dict[str, int] = {}
-    for name in names:
-        for suffix in candidate_suffixes(name):
-            num_instances[suffix] = num_instances.get(suffix, 0) + 1
-    result = {}
-    for name in names:
-        for suffix in candidate_suffixes(name):
-            if num_instances[suffix] == 1:
-                result[name] = suffix
-                break
-        else:
-            assert False, names
-    return result
-
-
-def candidate_suffixes(fullname: str) -> list[str]:
-    components = fullname.split(".")
-    result = [""]
-    for i in range(len(components)):
-        result.append(".".join(components[-i - 1 :]) + ".")
-    return result

jaclang/vendor/mypyc/options.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import sys
-
-
-class CompilerOptions:
-    def __init__(
-        self,
-        strip_asserts: bool = False,
-        multi_file: bool = False,
-        verbose: bool = False,
-        separate: bool = False,
-        target_dir: str | None = None,
-        include_runtime_files: bool | None = None,
-        capi_version: tuple[int, int] | None = None,
-        python_version: tuple[int, int] | None = None,
-    ) -> None:
-        self.strip_asserts = strip_asserts
-        self.multi_file = multi_file
-        self.verbose = verbose
-        self.separate = separate
-        self.global_opts = not separate
-        self.target_dir = target_dir or "build"
-        self.include_runtime_files = (
-            include_runtime_files if include_runtime_files is not None else not multi_file
-        )
-        # The target Python C API version. Overriding this is mostly
-        # useful in IR tests, since there's no guarantee that
-        # binaries are backward compatible even if no recent API
-        # features are used.
-        self.capi_version = capi_version or sys.version_info[:2]
-        self.python_version = python_version

jaclang/vendor/mypyc/primitives/bytes_ops.py

@@ -1,101 +0,0 @@
-"""Primitive bytes ops."""
-
-from __future__ import annotations
-
-from mypyc.ir.ops import ERR_MAGIC
-from mypyc.ir.rtypes import (
-    RUnion,
-    bytes_rprimitive,
-    c_int_rprimitive,
-    c_pyssize_t_rprimitive,
-    dict_rprimitive,
-    int_rprimitive,
-    list_rprimitive,
-    object_rprimitive,
-    str_rprimitive,
-)
-from mypyc.primitives.registry import (
-    ERR_NEG_INT,
-    binary_op,
-    custom_op,
-    function_op,
-    load_address_op,
-    method_op,
-)
-
-# Get the 'bytes' type object.
-load_address_op(name="builtins.bytes", type=object_rprimitive, src="PyBytes_Type")
-
-# bytes(obj)
-function_op(
-    name="builtins.bytes",
-    arg_types=[RUnion([list_rprimitive, dict_rprimitive, str_rprimitive])],
-    return_type=bytes_rprimitive,
-    c_function_name="PyBytes_FromObject",
-    error_kind=ERR_MAGIC,
-)
-
-# bytearray(obj)
-function_op(
-    name="builtins.bytearray",
-    arg_types=[object_rprimitive],
-    return_type=bytes_rprimitive,
-    c_function_name="PyByteArray_FromObject",
-    error_kind=ERR_MAGIC,
-)
-
-# bytes ==/!= (return -1/0/1)
-bytes_compare = custom_op(
-    arg_types=[bytes_rprimitive, bytes_rprimitive],
-    return_type=c_int_rprimitive,
-    c_function_name="CPyBytes_Compare",
-    error_kind=ERR_NEG_INT,
-)
-
-# bytes + bytes
-# bytearray + bytearray
-binary_op(
-    name="+",
-    arg_types=[bytes_rprimitive, bytes_rprimitive],
-    return_type=bytes_rprimitive,
-    c_function_name="CPyBytes_Concat",
-    error_kind=ERR_MAGIC,
-    steals=[True, False],
-)
-
-# bytes[begin:end]
-bytes_slice_op = custom_op(
-    arg_types=[bytes_rprimitive, int_rprimitive, int_rprimitive],
-    return_type=bytes_rprimitive,
-    c_function_name="CPyBytes_GetSlice",
-    error_kind=ERR_MAGIC,
-)
-
-# bytes[index]
-# bytearray[index]
-method_op(
-    name="__getitem__",
-    arg_types=[bytes_rprimitive, int_rprimitive],
-    return_type=int_rprimitive,
-    c_function_name="CPyBytes_GetItem",
-    error_kind=ERR_MAGIC,
-)
-
-# bytes.join(obj)
-method_op(
-    name="join",
-    arg_types=[bytes_rprimitive, object_rprimitive],
-    return_type=bytes_rprimitive,
-    c_function_name="CPyBytes_Join",
-    error_kind=ERR_MAGIC,
-)
-
-# Join bytes objects and return a new bytes.
-# The first argument is the total number of the following bytes.
-bytes_build_op = custom_op(
-    arg_types=[c_pyssize_t_rprimitive],
-    return_type=bytes_rprimitive,
-    c_function_name="CPyBytes_Build",
-    error_kind=ERR_MAGIC,
-    var_arg_type=bytes_rprimitive,
-)