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

jaclang/vendor/mypyc/test-data/run-u8.test

@@ -1,303 +0,0 @@
-[case testU8BasicOps]
-from typing import Any, Tuple
-
-from mypy_extensions import u8, i16, i32, i64
-from typing_extensions import Final
-
-from testutil import assertRaises
-
-ERROR: Final = 239
-
-def test_box_and_unbox() -> None:
-    for i in range(0, 256):
-        o: Any = i
-        x: u8 = o
-        o2: Any = x
-        assert o == o2
-        assert x == i
-    with assertRaises(OverflowError, "int too large or small to convert to u8"):
-        o = 256
-        x2: u8 = o
-    with assertRaises(OverflowError, "int too large or small to convert to u8"):
-        o = -1
-        x3: u8 = o
-
-def div_by_7(x: u8) -> u8:
-    return x // 7
-
-def div(x: u8, y: u8) -> u8:
-    return x // y
-
-def test_divide_by_constant() -> None:
-    for i in range(0, 256):
-        assert div_by_7(i) == i // 7
-
-def test_divide_by_variable() -> None:
-    for x in range(0, 256):
-        for y in range(0, 256):
-            if y != 0:
-                assert div(x, y) == x // y
-            else:
-                with assertRaises(ZeroDivisionError, "integer division or modulo by zero"):
-                    div(x, y)
-
-def mod_by_7(x: u8) -> u8:
-    return x % 7
-
-def mod(x: u8, y: u8) -> u8:
-    return x % y
-
-def test_mod_by_constant() -> None:
-    for i in range(0, 256):
-        assert mod_by_7(i) == i % 7
-
-def test_mod_by_variable() -> None:
-    for x in range(0, 256):
-        for y in range(0, 256):
-            if y != 0:
-                assert mod(x, y) == x % y
-            else:
-                with assertRaises(ZeroDivisionError, "integer division or modulo by zero"):
-                    mod(x, y)
-
-def test_simple_arithmetic_ops() -> None:
-    zero: u8 = int()
-    one: u8 = zero + 1
-    two: u8 = one + 1
-    neg_one: u8 = -one
-    assert neg_one == 255
-    assert one + one == 2
-    assert one + two == 3
-    assert one + neg_one == 0
-    assert one - one == 0
-    assert one - two == 255
-    assert one * one == 1
-    assert one * two == 2
-    assert two * two == 4
-    assert two * neg_one == 254
-    assert neg_one * one == 255
-    assert neg_one * neg_one == 1
-    assert two * 0 == 0
-    assert 0 * two == 0
-    assert -one == 255
-    assert -two == 254
-    assert -neg_one == 1
-    assert -zero == 0
-
-def test_bitwise_ops() -> None:
-    x: u8 = 184 + int()
-    y: u8 = 79 + int()
-    z: u8 = 113 + int()
-    zero: u8 = int()
-    one: u8 = zero + 1
-    two: u8 = zero + 2
-    neg_one: u8 = -one
-
-    assert x & y == 8
-    assert x & z == 48
-    assert z & z == z
-    assert x & zero == 0
-
-    assert x | y == 255
-    assert x | z == 249
-    assert z | z == z
-    assert x | 0 == x
-
-    assert x ^ y == 247
-    assert x ^ z == 201
-    assert z ^ z == 0
-    assert z ^ 0 == z
-
-    assert x << one == 112
-    assert x << two == 224
-    assert z << two == 196
-    assert z << 0 == z
-
-    assert x >> one == 92
-    assert x >> two == 46
-    assert z >> two == 28
-    assert z >> 0 == z
-
-    for i in range(256):
-        t: u8 = i
-        assert ~t == (~(i + int()) & 0xff)
-
-def eq(x: u8, y: u8) -> bool:
-    return x == y
-
-def test_eq() -> None:
-    assert eq(int(), int())
-    assert eq(5 + int(), 5 + int())
-    assert not eq(int(), 1 + int())
-    assert not eq(5 + int(), 6 + int())
-
-def test_comparisons() -> None:
-    one: u8 = 1 + int()
-    one2: u8 = 1 + int()
-    two: u8 = 2 + int()
-    assert one < two
-    assert not (one < one2)
-    assert not (two < one)
-    assert two > one
-    assert not (one > one2)
-    assert not (one > two)
-    assert one <= two
-    assert one <= one2
-    assert not (two <= one)
-    assert two >= one
-    assert one >= one2
-    assert not (one >= two)
-    assert one == one2
-    assert not (one == two)
-    assert one != two
-    assert not (one != one2)
-
-def test_mixed_comparisons() -> None:
-    u8_3: u8 = int() + 3
-    int_5 = int() + 5
-    assert u8_3 < int_5
-    assert int_5 > u8_3
-    b = u8_3 > int_5
-    assert not b
-
-    int_largest = int() + 255
-    assert int_largest > u8_3
-    int_smallest = int()
-    assert u8_3 > int_smallest
-
-    int_too_big = int() + 256
-    int_too_small = int() -1
-    with assertRaises(OverflowError):
-        assert u8_3 < int_too_big
-    with assertRaises(OverflowError):
-        assert int_too_big < u8_3
-    with assertRaises(OverflowError):
-        assert u8_3 > int_too_small
-    with assertRaises(OverflowError):
-        assert int_too_small < u8_3
-
-def test_mixed_arithmetic_and_bitwise_ops() -> None:
-    u8_3: u8 = int() + 3
-    int_5 = int() + 5
-    assert u8_3 + int_5 == 8
-    assert int_5 - u8_3 == 2
-    assert u8_3 << int_5 == 96
-    assert int_5 << u8_3  == 40
-    assert u8_3 ^ int_5 == 6
-    assert int_5 | u8_3  == 7
-
-    int_largest = int() + 255
-    assert int_largest - u8_3 == 252
-    int_smallest = int()
-    assert int_smallest + u8_3 == 3
-
-    int_too_big = int() + 256
-    int_too_small = int() - 1
-    with assertRaises(OverflowError):
-        assert u8_3 & int_too_big
-    with assertRaises(OverflowError):
-        assert int_too_small & u8_3
-
-def test_coerce_to_and_from_int() -> None:
-    for n in range(0, 256):
-        x: u8 = n
-        m: int = x
-        assert m == n
-
-def test_explicit_conversion_to_u8() -> None:
-    x = u8(5)
-    assert x == 5
-    y = int() + ERROR
-    x = u8(y)
-    assert x == ERROR
-    n64: i64 = 233
-    x = u8(n64)
-    assert x == 233
-    n32: i32 = 234
-    x = u8(n32)
-    assert x == 234
-    z = u8(x)
-    assert z == 234
-    n16: i16 = 231
-    x = u8(n16)
-    assert x == 231
-
-def test_explicit_conversion_overflow() -> None:
-    max_u8 = int() + 255
-    x = u8(max_u8)
-    assert x == 255
-    assert int(x) == max_u8
-
-    min_u8 = int()
-    y = u8(min_u8)
-    assert y == 0
-    assert int(y) == min_u8
-
-    too_big = int() + 256
-    with assertRaises(OverflowError):
-        x = u8(too_big)
-
-    too_small = int() - 1
-    with assertRaises(OverflowError):
-        x = u8(too_small)
-
-def test_u8_from_large_small_literal() -> None:
-    x = u8(255) # XXX u8(2**15 - 1)
-    assert x == 255
-    x = u8(0)
-    assert x == 0
-
-def test_u8_truncate_from_i64() -> None:
-    large = i64(2**32 + 256 + 157 + int())
-    x = u8(large)
-    assert x == 157
-    small = i64(-2**32 - 256 - 157 + int())
-    x = u8(small)
-    assert x == 256 - 157
-    large2 = i64(2**8 + int())
-    x = u8(large2)
-    assert x == 0
-    small2 = i64(-2**8 - 1 - int())
-    x = u8(small2)
-    assert x == 255
-
-def test_u8_truncate_from_i32() -> None:
-    large = i32(2**16 + 2**8 + 5 + int())
-    assert u8(large) == 5
-    small = i32(-2**16 - 2**8 - 1 + int())
-    assert u8(small) == 255
-
-def from_float(x: float) -> u8:
-    return u8(x)
-
-def test_explicit_conversion_from_float() -> None:
-    assert from_float(0.0) == 0
-    assert from_float(1.456) == 1
-    assert from_float(234.567) == 234
-    assert from_float(255) == 255
-    assert from_float(0) == 0
-    assert from_float(-0.999) == 0
-    # The error message could be better, but this is acceptable
-    with assertRaises(OverflowError, "int too large or small to convert to u8"):
-        assert from_float(float(256))
-    with assertRaises(OverflowError, "int too large or small to convert to u8"):
-        # One ulp below the lowest valid i64 value
-        from_float(float(-1.0))
-
-def test_tuple_u8() -> None:
-    a: u8 = 1
-    b: u8 = 2
-    t = (a, b)
-    a, b = t
-    assert a == 1
-    assert b == 2
-    x: Any = t
-    tt: Tuple[u8, u8] = x
-    assert tt == (1, 2)
-
-def test_convert_u8_to_native_int() -> None:
-    for i in range(256):
-        x: u8 = i
-        assert i16(x) == i
-        assert i32(x) == i
-        assert i64(x) == i

jaclang/vendor/mypyc/transform/copy_propagation.py

@@ -1,94 +0,0 @@
-"""Simple copy propagation optimization.
-
-Example input:
-
-    x = f()
-    y = x
-
-The register x is redundant and we can directly assign its value to y:
-
-    y = f()
-
-This can optimize away registers that are assigned to once.
-"""
-
-from __future__ import annotations
-
-from mypyc.ir.func_ir import FuncIR
-from mypyc.ir.ops import Assign, AssignMulti, LoadAddress, LoadErrorValue, Register, Value
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-from mypyc.options import CompilerOptions
-from mypyc.sametype import is_same_type
-from mypyc.transform.ir_transform import IRTransform
-
-
-def do_copy_propagation(fn: FuncIR, options: CompilerOptions) -> None:
-    """Perform copy propagation optimization for fn."""
-
-    # Anything with an assignment count >1 will not be optimized
-    # here, as it would be require data flow analysis and we want to
-    # keep this simple and fast, at least until we've made data flow
-    # analysis much faster.
-    counts: dict[Value, int] = {}
-    replacements: dict[Value, Value] = {}
-    for arg in fn.arg_regs:
-        # Arguments are always assigned to initially
-        counts[arg] = 1
-
-    for block in fn.blocks:
-        for op in block.ops:
-            if isinstance(op, Assign):
-                c = counts.get(op.dest, 0)
-                counts[op.dest] = c + 1
-                # Does this look like a supported assignment?
-                # TODO: Something needs LoadErrorValue assignments to be preserved?
-                if (
-                    c == 0
-                    and is_same_type(op.dest.type, op.src.type)
-                    and not isinstance(op.src, LoadErrorValue)
-                ):
-                    replacements[op.dest] = op.src
-                elif c == 1:
-                    # Too many assignments -- don't replace this one
-                    replacements.pop(op.dest, 0)
-            elif isinstance(op, AssignMulti):
-                # Copy propagation not supported for AssignMulti destinations
-                counts[op.dest] = 2
-                replacements.pop(op.dest, 0)
-            elif isinstance(op, LoadAddress):
-                # We don't support taking the address of an arbitrary Value,
-                # so we'll need to preserve the operands of LoadAddress.
-                if isinstance(op.src, Register):
-                    counts[op.src] = 2
-                    replacements.pop(op.src, 0)
-
-    # Follow chains of propagation with more than one assignment.
-    for src, dst in list(replacements.items()):
-        if counts.get(dst, 0) > 1:
-            # Not supported
-            del replacements[src]
-        else:
-            while dst in replacements:
-                dst = replacements[dst]
-                if counts.get(dst, 0) > 1:
-                    # Not supported
-                    del replacements[src]
-        if src in replacements:
-            replacements[src] = dst
-
-    builder = LowLevelIRBuilder(None, options)
-    transform = CopyPropagationTransform(builder, replacements)
-    transform.transform_blocks(fn.blocks)
-    fn.blocks = builder.blocks
-
-
-class CopyPropagationTransform(IRTransform):
-    def __init__(self, builder: LowLevelIRBuilder, map: dict[Value, Value]) -> None:
-        super().__init__(builder)
-        self.op_map.update(map)
-        self.removed = set(map)
-
-    def visit_assign(self, op: Assign) -> Value | None:
-        if op.dest in self.removed:
-            return None
-        return self.add(op)

jaclang/vendor/mypyc/transform/exceptions.py

@@ -1,182 +0,0 @@
-"""Transform that inserts error checks after opcodes.
-
-When initially building the IR, the code doesn't perform error checks
-for exceptions. This module is used to insert all required error checks
-afterwards. Each Op describes how it indicates an error condition (if
-at all).
-
-We need to split basic blocks on each error check since branches can
-only be placed at the end of a basic block.
-"""
-
-from __future__ import annotations
-
-from mypyc.ir.func_ir import FuncIR
-from mypyc.ir.ops import (
-    ERR_ALWAYS,
-    ERR_FALSE,
-    ERR_MAGIC,
-    ERR_MAGIC_OVERLAPPING,
-    ERR_NEVER,
-    NO_TRACEBACK_LINE_NO,
-    BasicBlock,
-    Branch,
-    CallC,
-    ComparisonOp,
-    Float,
-    GetAttr,
-    Integer,
-    LoadErrorValue,
-    Op,
-    RegisterOp,
-    Return,
-    SetAttr,
-    TupleGet,
-    Value,
-)
-from mypyc.ir.rtypes import RTuple, bool_rprimitive, is_float_rprimitive
-from mypyc.primitives.exc_ops import err_occurred_op
-from mypyc.primitives.registry import CFunctionDescription
-
-
-def insert_exception_handling(ir: FuncIR) -> None:
-    # Generate error block if any ops may raise an exception. If an op
-    # fails without its own error handler, we'll branch to this
-    # block. The block just returns an error value.
-    error_label: BasicBlock | None = None
-    for block in ir.blocks:
-        adjust_error_kinds(block)
-        if error_label is None and any(op.can_raise() for op in block.ops):
-            error_label = add_default_handler_block(ir)
-    if error_label:
-        ir.blocks = split_blocks_at_errors(ir.blocks, error_label, ir.traceback_name)
-
-
-def add_default_handler_block(ir: FuncIR) -> BasicBlock:
-    block = BasicBlock()
-    ir.blocks.append(block)
-    op = LoadErrorValue(ir.ret_type)
-    block.ops.append(op)
-    block.ops.append(Return(op))
-    return block
-
-
-def split_blocks_at_errors(
-    blocks: list[BasicBlock], default_error_handler: BasicBlock, func_name: str | None
-) -> list[BasicBlock]:
-    new_blocks: list[BasicBlock] = []
-
-    # First split blocks on ops that may raise.
-    for block in blocks:
-        ops = block.ops
-        block.ops = []
-        cur_block = block
-        new_blocks.append(cur_block)
-
-        # If the block has an error handler specified, use it. Otherwise
-        # fall back to the default.
-        error_label = block.error_handler or default_error_handler
-        block.error_handler = None
-
-        for op in ops:
-            target: Value = op
-            cur_block.ops.append(op)
-            if isinstance(op, RegisterOp) and op.error_kind != ERR_NEVER:
-                # Split
-                new_block = BasicBlock()
-                new_blocks.append(new_block)
-
-                if op.error_kind == ERR_MAGIC:
-                    # Op returns an error value on error that depends on result RType.
-                    variant = Branch.IS_ERROR
-                    negated = False
-                elif op.error_kind == ERR_FALSE:
-                    # Op returns a C false value on error.
-                    variant = Branch.BOOL
-                    negated = True
-                elif op.error_kind == ERR_ALWAYS:
-                    variant = Branch.BOOL
-                    negated = True
-                    # this is a hack to represent the always fail
-                    # semantics, using a temporary bool with value false
-                    target = Integer(0, bool_rprimitive)
-                elif op.error_kind == ERR_MAGIC_OVERLAPPING:
-                    comp = insert_overlapping_error_value_check(cur_block.ops, target)
-                    new_block2 = BasicBlock()
-                    new_blocks.append(new_block2)
-                    branch = Branch(
-                        comp,
-                        true_label=new_block2,
-                        false_label=new_block,
-                        op=Branch.BOOL,
-                        rare=True,
-                    )
-                    cur_block.ops.append(branch)
-                    cur_block = new_block2
-                    target = primitive_call(err_occurred_op, [], target.line)
-                    cur_block.ops.append(target)
-                    variant = Branch.IS_ERROR
-                    negated = True
-                else:
-                    assert False, "unknown error kind %d" % op.error_kind
-
-                # Void ops can't generate errors since error is always
-                # indicated by a special value stored in a register.
-                if op.error_kind != ERR_ALWAYS:
-                    assert not op.is_void, "void op generating errors?"
-
-                branch = Branch(
-                    target, true_label=error_label, false_label=new_block, op=variant, line=op.line
-                )
-                branch.negated = negated
-                if op.line != NO_TRACEBACK_LINE_NO and func_name is not None:
-                    branch.traceback_entry = (func_name, op.line)
-                cur_block.ops.append(branch)
-                cur_block = new_block
-
-    return new_blocks
-
-
-def primitive_call(desc: CFunctionDescription, args: list[Value], line: int) -> CallC:
-    return CallC(
-        desc.c_function_name,
-        [],
-        desc.return_type,
-        desc.steals,
-        desc.is_borrowed,
-        desc.error_kind,
-        line,
-    )
-
-
-def adjust_error_kinds(block: BasicBlock) -> None:
-    """Infer more precise error_kind attributes for ops.
-
-    We have access here to more information than what was available
-    when the IR was initially built.
-    """
-    for op in block.ops:
-        if isinstance(op, GetAttr):
-            if op.class_type.class_ir.is_always_defined(op.attr):
-                op.error_kind = ERR_NEVER
-        if isinstance(op, SetAttr):
-            if op.class_type.class_ir.is_always_defined(op.attr):
-                op.error_kind = ERR_NEVER
-
-
-def insert_overlapping_error_value_check(ops: list[Op], target: Value) -> ComparisonOp:
-    """Append to ops to check for an overlapping error value."""
-    typ = target.type
-    if isinstance(typ, RTuple):
-        item = TupleGet(target, 0)
-        ops.append(item)
-        return insert_overlapping_error_value_check(ops, item)
-    else:
-        errvalue: Value
-        if is_float_rprimitive(target.type):
-            errvalue = Float(float(typ.c_undefined))
-        else:
-            errvalue = Integer(int(typ.c_undefined), rtype=typ)
-        op = ComparisonOp(target, errvalue, ComparisonOp.EQ)
-        ops.append(op)
-        return op

jaclang/vendor/mypyc/transform/flag_elimination.py

@@ -1,108 +0,0 @@
-"""Bool register elimination optimization.
-
-Example input:
-
-  L1:
-    r0 = f()
-    b = r0
-    goto L3
-  L2:
-    r1 = g()
-    b = r1
-    goto L3
-  L3:
-    if b goto L4 else goto L5
-
-The register b is redundant and we replace the assignments with two copies of
-the branch in L3:
-
-  L1:
-    r0 = f()
-    if r0 goto L4 else goto L5
-  L2:
-    r1 = g()
-    if r1 goto L4 else goto L5
-
-This helps generate simpler IR for tagged integers comparisons, for example.
-"""
-
-from __future__ import annotations
-
-from mypyc.ir.func_ir import FuncIR
-from mypyc.ir.ops import Assign, BasicBlock, Branch, Goto, Register, Unreachable
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-from mypyc.options import CompilerOptions
-from mypyc.transform.ir_transform import IRTransform
-
-
-def do_flag_elimination(fn: FuncIR, options: CompilerOptions) -> None:
-    # Find registers that are used exactly once as source, and in a branch.
-    counts: dict[Register, int] = {}
-    branches: dict[Register, Branch] = {}
-    labels: dict[Register, BasicBlock] = {}
-    for block in fn.blocks:
-        for i, op in enumerate(block.ops):
-            for src in op.sources():
-                if isinstance(src, Register):
-                    counts[src] = counts.get(src, 0) + 1
-            if i == 0 and isinstance(op, Branch) and isinstance(op.value, Register):
-                branches[op.value] = op
-                labels[op.value] = block
-
-    # Based on these we can find the candidate registers.
-    candidates: set[Register] = {
-        r for r in branches if counts.get(r, 0) == 1 and r not in fn.arg_regs
-    }
-
-    # Remove candidates with invalid assignments.
-    for block in fn.blocks:
-        for i, op in enumerate(block.ops):
-            if isinstance(op, Assign) and op.dest in candidates:
-                next_op = block.ops[i + 1]
-                if not (isinstance(next_op, Goto) and next_op.label is labels[op.dest]):
-                    # Not right
-                    candidates.remove(op.dest)
-
-    builder = LowLevelIRBuilder(None, options)
-    transform = FlagEliminationTransform(
-        builder, {x: y for x, y in branches.items() if x in candidates}
-    )
-    transform.transform_blocks(fn.blocks)
-    fn.blocks = builder.blocks
-
-
-class FlagEliminationTransform(IRTransform):
-    def __init__(self, builder: LowLevelIRBuilder, branch_map: dict[Register, Branch]) -> None:
-        super().__init__(builder)
-        self.branch_map = branch_map
-        self.branches = set(branch_map.values())
-
-    def visit_assign(self, op: Assign) -> None:
-        old_branch = self.branch_map.get(op.dest)
-        if old_branch:
-            # Replace assignment with a copy of the old branch, which is in a
-            # separate basic block. The old branch will be deletecd in visit_branch.
-            new_branch = Branch(
-                op.src,
-                old_branch.true,
-                old_branch.false,
-                old_branch.op,
-                old_branch.line,
-                rare=old_branch.rare,
-            )
-            new_branch.negated = old_branch.negated
-            new_branch.traceback_entry = old_branch.traceback_entry
-            self.add(new_branch)
-        else:
-            self.add(op)
-
-    def visit_goto(self, op: Goto) -> None:
-        # This is a no-op if basic block already terminated
-        self.builder.goto(op.label)
-
-    def visit_branch(self, op: Branch) -> None:
-        if op in self.branches:
-            # This branch is optimized away
-            self.add(Unreachable())
-        else:
-            self.add(op)