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

jaclang/vendor/mypyc/transform/ir_transform.py

@@ -1,368 +0,0 @@
-"""Helpers for implementing generic IR to IR transforms."""
-
-from __future__ import annotations
-
-from typing import Final, Optional
-
-from mypyc.ir.ops import (
-    Assign,
-    AssignMulti,
-    BasicBlock,
-    Box,
-    Branch,
-    Call,
-    CallC,
-    Cast,
-    ComparisonOp,
-    DecRef,
-    Extend,
-    FloatComparisonOp,
-    FloatNeg,
-    FloatOp,
-    GetAttr,
-    GetElementPtr,
-    Goto,
-    IncRef,
-    InitStatic,
-    IntOp,
-    KeepAlive,
-    LoadAddress,
-    LoadErrorValue,
-    LoadGlobal,
-    LoadLiteral,
-    LoadMem,
-    LoadStatic,
-    MethodCall,
-    Op,
-    OpVisitor,
-    PrimitiveOp,
-    RaiseStandardError,
-    Return,
-    SetAttr,
-    SetMem,
-    Truncate,
-    TupleGet,
-    TupleSet,
-    Unborrow,
-    Unbox,
-    Unreachable,
-    Value,
-)
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-
-
-class IRTransform(OpVisitor[Optional[Value]]):
-    """Identity transform.
-
-    Subclass and override to perform changes to IR.
-
-    Subclass IRTransform and override any OpVisitor visit_* methods
-    that perform any IR changes. The default implementations implement
-    an identity transform.
-
-    A visit method can return None to remove ops. In this case the
-    transform must ensure that no op uses the original removed op
-    as a source after the transform.
-
-    You can retain old BasicBlock and op references in ops. The transform
-    will automatically patch these for you as needed.
-    """
-
-    def __init__(self, builder: LowLevelIRBuilder) -> None:
-        self.builder = builder
-        # Subclasses add additional op mappings here. A None value indicates
-        # that the op/register is deleted.
-        self.op_map: dict[Value, Value | None] = {}
-
-    def transform_blocks(self, blocks: list[BasicBlock]) -> None:
-        """Transform basic blocks that represent a single function.
-
-        The result of the transform will be collected at self.builder.blocks.
-        """
-        block_map: dict[BasicBlock, BasicBlock] = {}
-        op_map = self.op_map
-        empties = set()
-        for block in blocks:
-            new_block = BasicBlock()
-            block_map[block] = new_block
-            self.builder.activate_block(new_block)
-            new_block.error_handler = block.error_handler
-            for op in block.ops:
-                new_op = op.accept(self)
-                if new_op is not op:
-                    op_map[op] = new_op
-            # A transform can produce empty blocks which can be removed.
-            if is_empty_block(new_block) and not is_empty_block(block):
-                empties.add(new_block)
-        self.builder.blocks = [block for block in self.builder.blocks if block not in empties]
-        # Update all op/block references to point to the transformed ones.
-        patcher = PatchVisitor(op_map, block_map)
-        for block in self.builder.blocks:
-            for op in block.ops:
-                op.accept(patcher)
-            if block.error_handler is not None:
-                block.error_handler = block_map.get(block.error_handler, block.error_handler)
-
-    def add(self, op: Op) -> Value:
-        return self.builder.add(op)
-
-    def visit_goto(self, op: Goto) -> None:
-        self.add(op)
-
-    def visit_branch(self, op: Branch) -> None:
-        self.add(op)
-
-    def visit_return(self, op: Return) -> None:
-        self.add(op)
-
-    def visit_unreachable(self, op: Unreachable) -> None:
-        self.add(op)
-
-    def visit_assign(self, op: Assign) -> Value | None:
-        return self.add(op)
-
-    def visit_assign_multi(self, op: AssignMulti) -> Value | None:
-        return self.add(op)
-
-    def visit_load_error_value(self, op: LoadErrorValue) -> Value | None:
-        return self.add(op)
-
-    def visit_load_literal(self, op: LoadLiteral) -> Value | None:
-        return self.add(op)
-
-    def visit_get_attr(self, op: GetAttr) -> Value | None:
-        return self.add(op)
-
-    def visit_set_attr(self, op: SetAttr) -> Value | None:
-        return self.add(op)
-
-    def visit_load_static(self, op: LoadStatic) -> Value | None:
-        return self.add(op)
-
-    def visit_init_static(self, op: InitStatic) -> Value | None:
-        return self.add(op)
-
-    def visit_tuple_get(self, op: TupleGet) -> Value | None:
-        return self.add(op)
-
-    def visit_tuple_set(self, op: TupleSet) -> Value | None:
-        return self.add(op)
-
-    def visit_inc_ref(self, op: IncRef) -> Value | None:
-        return self.add(op)
-
-    def visit_dec_ref(self, op: DecRef) -> Value | None:
-        return self.add(op)
-
-    def visit_call(self, op: Call) -> Value | None:
-        return self.add(op)
-
-    def visit_method_call(self, op: MethodCall) -> Value | None:
-        return self.add(op)
-
-    def visit_cast(self, op: Cast) -> Value | None:
-        return self.add(op)
-
-    def visit_box(self, op: Box) -> Value | None:
-        return self.add(op)
-
-    def visit_unbox(self, op: Unbox) -> Value | None:
-        return self.add(op)
-
-    def visit_raise_standard_error(self, op: RaiseStandardError) -> Value | None:
-        return self.add(op)
-
-    def visit_call_c(self, op: CallC) -> Value | None:
-        return self.add(op)
-
-    def visit_primitive_op(self, op: PrimitiveOp) -> Value | None:
-        return self.add(op)
-
-    def visit_truncate(self, op: Truncate) -> Value | None:
-        return self.add(op)
-
-    def visit_extend(self, op: Extend) -> Value | None:
-        return self.add(op)
-
-    def visit_load_global(self, op: LoadGlobal) -> Value | None:
-        return self.add(op)
-
-    def visit_int_op(self, op: IntOp) -> Value | None:
-        return self.add(op)
-
-    def visit_comparison_op(self, op: ComparisonOp) -> Value | None:
-        return self.add(op)
-
-    def visit_float_op(self, op: FloatOp) -> Value | None:
-        return self.add(op)
-
-    def visit_float_neg(self, op: FloatNeg) -> Value | None:
-        return self.add(op)
-
-    def visit_float_comparison_op(self, op: FloatComparisonOp) -> Value | None:
-        return self.add(op)
-
-    def visit_load_mem(self, op: LoadMem) -> Value | None:
-        return self.add(op)
-
-    def visit_set_mem(self, op: SetMem) -> Value | None:
-        return self.add(op)
-
-    def visit_get_element_ptr(self, op: GetElementPtr) -> Value | None:
-        return self.add(op)
-
-    def visit_load_address(self, op: LoadAddress) -> Value | None:
-        return self.add(op)
-
-    def visit_keep_alive(self, op: KeepAlive) -> Value | None:
-        return self.add(op)
-
-    def visit_unborrow(self, op: Unborrow) -> Value | None:
-        return self.add(op)
-
-
-class PatchVisitor(OpVisitor[None]):
-    def __init__(
-        self, op_map: dict[Value, Value | None], block_map: dict[BasicBlock, BasicBlock]
-    ) -> None:
-        self.op_map: Final = op_map
-        self.block_map: Final = block_map
-
-    def fix_op(self, op: Value) -> Value:
-        new = self.op_map.get(op, op)
-        assert new is not None, "use of removed op"
-        return new
-
-    def fix_block(self, block: BasicBlock) -> BasicBlock:
-        return self.block_map.get(block, block)
-
-    def visit_goto(self, op: Goto) -> None:
-        op.label = self.fix_block(op.label)
-
-    def visit_branch(self, op: Branch) -> None:
-        op.value = self.fix_op(op.value)
-        op.true = self.fix_block(op.true)
-        op.false = self.fix_block(op.false)
-
-    def visit_return(self, op: Return) -> None:
-        op.value = self.fix_op(op.value)
-
-    def visit_unreachable(self, op: Unreachable) -> None:
-        pass
-
-    def visit_assign(self, op: Assign) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_assign_multi(self, op: AssignMulti) -> None:
-        op.src = [self.fix_op(s) for s in op.src]
-
-    def visit_load_error_value(self, op: LoadErrorValue) -> None:
-        pass
-
-    def visit_load_literal(self, op: LoadLiteral) -> None:
-        pass
-
-    def visit_get_attr(self, op: GetAttr) -> None:
-        op.obj = self.fix_op(op.obj)
-
-    def visit_set_attr(self, op: SetAttr) -> None:
-        op.obj = self.fix_op(op.obj)
-        op.src = self.fix_op(op.src)
-
-    def visit_load_static(self, op: LoadStatic) -> None:
-        pass
-
-    def visit_init_static(self, op: InitStatic) -> None:
-        op.value = self.fix_op(op.value)
-
-    def visit_tuple_get(self, op: TupleGet) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_tuple_set(self, op: TupleSet) -> None:
-        op.items = [self.fix_op(item) for item in op.items]
-
-    def visit_inc_ref(self, op: IncRef) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_dec_ref(self, op: DecRef) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_call(self, op: Call) -> None:
-        op.args = [self.fix_op(arg) for arg in op.args]
-
-    def visit_method_call(self, op: MethodCall) -> None:
-        op.obj = self.fix_op(op.obj)
-        op.args = [self.fix_op(arg) for arg in op.args]
-
-    def visit_cast(self, op: Cast) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_box(self, op: Box) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_unbox(self, op: Unbox) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_raise_standard_error(self, op: RaiseStandardError) -> None:
-        if isinstance(op.value, Value):
-            op.value = self.fix_op(op.value)
-
-    def visit_call_c(self, op: CallC) -> None:
-        op.args = [self.fix_op(arg) for arg in op.args]
-
-    def visit_primitive_op(self, op: PrimitiveOp) -> None:
-        op.args = [self.fix_op(arg) for arg in op.args]
-
-    def visit_truncate(self, op: Truncate) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_extend(self, op: Extend) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_load_global(self, op: LoadGlobal) -> None:
-        pass
-
-    def visit_int_op(self, op: IntOp) -> None:
-        op.lhs = self.fix_op(op.lhs)
-        op.rhs = self.fix_op(op.rhs)
-
-    def visit_comparison_op(self, op: ComparisonOp) -> None:
-        op.lhs = self.fix_op(op.lhs)
-        op.rhs = self.fix_op(op.rhs)
-
-    def visit_float_op(self, op: FloatOp) -> None:
-        op.lhs = self.fix_op(op.lhs)
-        op.rhs = self.fix_op(op.rhs)
-
-    def visit_float_neg(self, op: FloatNeg) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_float_comparison_op(self, op: FloatComparisonOp) -> None:
-        op.lhs = self.fix_op(op.lhs)
-        op.rhs = self.fix_op(op.rhs)
-
-    def visit_load_mem(self, op: LoadMem) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_set_mem(self, op: SetMem) -> None:
-        op.dest = self.fix_op(op.dest)
-        op.src = self.fix_op(op.src)
-
-    def visit_get_element_ptr(self, op: GetElementPtr) -> None:
-        op.src = self.fix_op(op.src)
-
-    def visit_load_address(self, op: LoadAddress) -> None:
-        if isinstance(op.src, LoadStatic):
-            new = self.fix_op(op.src)
-            assert isinstance(new, LoadStatic)
-            op.src = new
-
-    def visit_keep_alive(self, op: KeepAlive) -> None:
-        op.src = [self.fix_op(s) for s in op.src]
-
-    def visit_unborrow(self, op: Unborrow) -> None:
-        op.src = self.fix_op(op.src)
-
-
-def is_empty_block(block: BasicBlock) -> bool:
-    return len(block.ops) == 1 and isinstance(block.ops[0], Unreachable)

jaclang/vendor/mypyc/transform/lower.py

@@ -1,33 +0,0 @@
-"""Transform IR to lower-level ops.
-
-Higher-level ops are used in earlier compiler passes, as they make
-various analyses, optimizations and transforms easier to implement.
-Later passes use lower-level ops, as they are easier to generate code
-from, and they help with lower-level optimizations.
-
-Lowering of various primitive ops is implemented in the mypyc.lower
-package.
-"""
-
-from mypyc.ir.func_ir import FuncIR
-from mypyc.ir.ops import PrimitiveOp, Value
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-from mypyc.lower.registry import lowering_registry
-from mypyc.options import CompilerOptions
-from mypyc.transform.ir_transform import IRTransform
-
-
-def lower_ir(ir: FuncIR, options: CompilerOptions) -> None:
-    builder = LowLevelIRBuilder(None, options)
-    visitor = LoweringVisitor(builder)
-    visitor.transform_blocks(ir.blocks)
-    ir.blocks = builder.blocks
-
-
-class LoweringVisitor(IRTransform):
-    def visit_primitive_op(self, op: PrimitiveOp) -> Value:
-        # The lowering implementation functions of various primitive ops are stored
-        # in a registry, which is populated using function decorators. The name
-        # of op (such as "int_eq") is used as the key.
-        lower_fn = lowering_registry[op.desc.name]
-        return lower_fn(self.builder, op.args, op.line)

jaclang/vendor/mypyc/transform/refcount.py

@@ -1,294 +0,0 @@
-"""Transformation for inserting refrecence count inc/dec opcodes.
-
-This transformation happens towards the end of compilation. Before this
-transformation, reference count management is not explicitly handled at all.
-By postponing this pass, the previous passes are simpler as they don't have
-to update reference count opcodes.
-
-The approach is to decrement reference counts soon after a value is no
-longer live, to quickly free memory (and call __del__ methods), though
-there are no strict guarantees -- other than that local variables are
-freed before return from a function.
-
-Function arguments are a little special. They are initially considered
-'borrowed' from the caller and their reference counts don't need to be
-decremented before returning. An assignment to a borrowed value turns it
-into a regular, owned reference that needs to freed before return.
-"""
-
-from __future__ import annotations
-
-from typing import Dict, Iterable, Tuple
-
-from mypyc.analysis.dataflow import (
-    AnalysisDict,
-    analyze_borrowed_arguments,
-    analyze_live_regs,
-    analyze_must_defined_regs,
-    cleanup_cfg,
-    get_cfg,
-)
-from mypyc.ir.func_ir import FuncIR, all_values
-from mypyc.ir.ops import (
-    Assign,
-    BasicBlock,
-    Branch,
-    ControlOp,
-    DecRef,
-    Goto,
-    IncRef,
-    Integer,
-    KeepAlive,
-    LoadAddress,
-    Op,
-    Register,
-    RegisterOp,
-    Value,
-)
-
-Decs = Tuple[Tuple[Value, bool], ...]
-Incs = Tuple[Value, ...]
-
-# A cache of basic blocks that decrement and increment specific values
-# and then jump to some target block. This lets us cut down on how
-# much code we generate in some circumstances.
-BlockCache = Dict[Tuple[BasicBlock, Decs, Incs], BasicBlock]
-
-
-def insert_ref_count_opcodes(ir: FuncIR) -> None:
-    """Insert reference count inc/dec opcodes to a function.
-
-    This is the entry point to this module.
-    """
-    cfg = get_cfg(ir.blocks)
-    values = all_values(ir.arg_regs, ir.blocks)
-
-    borrowed = {value for value in values if value.is_borrowed}
-    args: set[Value] = set(ir.arg_regs)
-    live = analyze_live_regs(ir.blocks, cfg)
-    borrow = analyze_borrowed_arguments(ir.blocks, cfg, borrowed)
-    defined = analyze_must_defined_regs(ir.blocks, cfg, args, values, strict_errors=True)
-    ordering = make_value_ordering(ir)
-    cache: BlockCache = {}
-    for block in ir.blocks.copy():
-        if isinstance(block.ops[-1], (Branch, Goto)):
-            insert_branch_inc_and_decrefs(
-                block,
-                cache,
-                ir.blocks,
-                live.before,
-                borrow.before,
-                borrow.after,
-                defined.after,
-                ordering,
-            )
-        transform_block(block, live.before, live.after, borrow.before, defined.after)
-
-    cleanup_cfg(ir.blocks)
-
-
-def is_maybe_undefined(post_must_defined: set[Value], src: Value) -> bool:
-    return isinstance(src, Register) and src not in post_must_defined
-
-
-def maybe_append_dec_ref(
-    ops: list[Op], dest: Value, defined: AnalysisDict[Value], key: tuple[BasicBlock, int]
-) -> None:
-    if dest.type.is_refcounted and not isinstance(dest, Integer):
-        ops.append(DecRef(dest, is_xdec=is_maybe_undefined(defined[key], dest)))
-
-
-def maybe_append_inc_ref(ops: list[Op], dest: Value) -> None:
-    if dest.type.is_refcounted:
-        ops.append(IncRef(dest))
-
-
-def transform_block(
-    block: BasicBlock,
-    pre_live: AnalysisDict[Value],
-    post_live: AnalysisDict[Value],
-    pre_borrow: AnalysisDict[Value],
-    post_must_defined: AnalysisDict[Value],
-) -> None:
-    old_ops = block.ops
-    ops: list[Op] = []
-    for i, op in enumerate(old_ops):
-        key = (block, i)
-
-        assert op not in pre_live[key]
-        dest = op.dest if isinstance(op, Assign) else op
-        stolen = op.stolen()
-
-        # Incref any references that are being stolen that stay live, were borrowed,
-        # or are stolen more than once by this operation.
-        for j, src in enumerate(stolen):
-            if src in post_live[key] or src in pre_borrow[key] or src in stolen[:j]:
-                maybe_append_inc_ref(ops, src)
-                # For assignments to registers that were already live,
-                # decref the old value.
-                if dest not in pre_borrow[key] and dest in pre_live[key]:
-                    assert isinstance(op, Assign)
-                    maybe_append_dec_ref(ops, dest, post_must_defined, key)
-
-        # Strip KeepAlive. Its only purpose is to help with this transform.
-        if not isinstance(op, KeepAlive):
-            ops.append(op)
-
-        # Control ops don't have any space to insert ops after them, so
-        # their inc/decrefs get inserted by insert_branch_inc_and_decrefs.
-        if isinstance(op, ControlOp):
-            continue
-
-        for src in op.unique_sources():
-            # Decrement source that won't be live afterwards.
-            if src not in post_live[key] and src not in pre_borrow[key] and src not in stolen:
-                maybe_append_dec_ref(ops, src, post_must_defined, key)
-        # Decrement the destination if it is dead after the op and
-        # wasn't a borrowed RegisterOp
-        if (
-            not dest.is_void
-            and dest not in post_live[key]
-            and not (isinstance(op, RegisterOp) and dest.is_borrowed)
-        ):
-            maybe_append_dec_ref(ops, dest, post_must_defined, key)
-    block.ops = ops
-
-
-def insert_branch_inc_and_decrefs(
-    block: BasicBlock,
-    cache: BlockCache,
-    blocks: list[BasicBlock],
-    pre_live: AnalysisDict[Value],
-    pre_borrow: AnalysisDict[Value],
-    post_borrow: AnalysisDict[Value],
-    post_must_defined: AnalysisDict[Value],
-    ordering: dict[Value, int],
-) -> None:
-    """Insert inc_refs and/or dec_refs after a branch/goto.
-
-    Add dec_refs for registers that become dead after a branch.
-    Add inc_refs for registers that become unborrowed after a branch or goto.
-
-    Branches are special as the true and false targets may have a different
-    live and borrowed register sets. Add new blocks before the true/false target
-    blocks that tweak reference counts.
-
-    Example where we need to add an inc_ref:
-
-      def f(a: int) -> None
-          if a:
-              a = 1
-          return a  # a is borrowed if condition is false and unborrowed if true
-    """
-    prev_key = (block, len(block.ops) - 1)
-    source_live_regs = pre_live[prev_key]
-    source_borrowed = post_borrow[prev_key]
-    source_defined = post_must_defined[prev_key]
-
-    term = block.terminator
-    for i, target in enumerate(term.targets()):
-        # HAX: After we've checked against an error value the value we must not touch the
-        #      refcount since it will be a null pointer. The correct way to do this would be
-        #      to perform data flow analysis on whether a value can be null (or is always
-        #      null).
-        omitted: Iterable[Value]
-        if isinstance(term, Branch) and term.op == Branch.IS_ERROR and i == 0:
-            omitted = (term.value,)
-        else:
-            omitted = ()
-
-        decs = after_branch_decrefs(
-            target, pre_live, source_defined, source_borrowed, source_live_regs, ordering, omitted
-        )
-        incs = after_branch_increfs(target, pre_live, pre_borrow, source_borrowed, ordering)
-        term.set_target(i, add_block(decs, incs, cache, blocks, target))
-
-
-def after_branch_decrefs(
-    label: BasicBlock,
-    pre_live: AnalysisDict[Value],
-    source_defined: set[Value],
-    source_borrowed: set[Value],
-    source_live_regs: set[Value],
-    ordering: dict[Value, int],
-    omitted: Iterable[Value],
-) -> tuple[tuple[Value, bool], ...]:
-    target_pre_live = pre_live[label, 0]
-    decref = source_live_regs - target_pre_live - source_borrowed
-    if decref:
-        return tuple(
-            (reg, is_maybe_undefined(source_defined, reg))
-            for reg in sorted(decref, key=lambda r: ordering[r])
-            if reg.type.is_refcounted and reg not in omitted
-        )
-    return ()
-
-
-def after_branch_increfs(
-    label: BasicBlock,
-    pre_live: AnalysisDict[Value],
-    pre_borrow: AnalysisDict[Value],
-    source_borrowed: set[Value],
-    ordering: dict[Value, int],
-) -> tuple[Value, ...]:
-    target_pre_live = pre_live[label, 0]
-    target_borrowed = pre_borrow[label, 0]
-    incref = (source_borrowed - target_borrowed) & target_pre_live
-    if incref:
-        return tuple(
-            reg for reg in sorted(incref, key=lambda r: ordering[r]) if reg.type.is_refcounted
-        )
-    return ()
-
-
-def add_block(
-    decs: Decs, incs: Incs, cache: BlockCache, blocks: list[BasicBlock], label: BasicBlock
-) -> BasicBlock:
-    if not decs and not incs:
-        return label
-
-    # TODO: be able to share *partial* results
-    if (label, decs, incs) in cache:
-        return cache[label, decs, incs]
-
-    block = BasicBlock()
-    blocks.append(block)
-    block.ops.extend(DecRef(reg, is_xdec=xdec) for reg, xdec in decs)
-    block.ops.extend(IncRef(reg) for reg in incs)
-    block.ops.append(Goto(label))
-    cache[label, decs, incs] = block
-    return block
-
-
-def make_value_ordering(ir: FuncIR) -> dict[Value, int]:
-    """Create a ordering of values that allows them to be sorted.
-
-    This omits registers that are only ever read.
-    """
-    # TODO: Never initialized values??
-    result: dict[Value, int] = {}
-    n = 0
-
-    for arg in ir.arg_regs:
-        result[arg] = n
-        n += 1
-
-    for block in ir.blocks:
-        for op in block.ops:
-            if (
-                isinstance(op, LoadAddress)
-                and isinstance(op.src, Register)
-                and op.src not in result
-            ):
-                # Taking the address of a register allows initialization.
-                result[op.src] = n
-                n += 1
-            if isinstance(op, Assign):
-                if op.dest not in result:
-                    result[op.dest] = n
-                    n += 1
-            elif op not in result:
-                result[op] = n
-                n += 1
-
-    return result