jaclang 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

jaclang/vendor/mypyc/lower/int_ops.py

@@ -0,0 +1,113 @@
+"""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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,26 @@
+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/options.py

@@ -22,9 +22,7 @@ class CompilerOptions:
         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
+            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

jaclang/vendor/mypyc/primitives/dict_ops.py

@@ -38,10 +38,7 @@ function_op(
 
 # Construct an empty dictionary.
 dict_new_op = custom_op(
-    arg_types=[],
-    return_type=dict_rprimitive,
-    c_function_name="PyDict_New",
-    error_kind=ERR_MAGIC,
+    arg_types=[], return_type=dict_rprimitive, c_function_name="PyDict_New", error_kind=ERR_MAGIC
 )
 
 # Construct a dictionary from keys and values.

jaclang/vendor/mypyc/primitives/exc_ops.py

@@ -34,10 +34,7 @@ raise_exception_with_tb_op = custom_op(
 
 # Reraise the currently raised exception.
 reraise_exception_op = custom_op(
-    arg_types=[],
-    return_type=void_rtype,
-    c_function_name="CPy_Reraise",
-    error_kind=ERR_ALWAYS,
+    arg_types=[], return_type=void_rtype, c_function_name="CPy_Reraise", error_kind=ERR_ALWAYS
 )
 
 # Propagate exception if the CPython error indicator is set (an exception was raised).
@@ -70,10 +67,7 @@ keep_propagating_op = custom_op(
 # exception that was previously being handled, which must be restored
 # later.
 error_catch_op = custom_op(
-    arg_types=[],
-    return_type=exc_rtuple,
-    c_function_name="CPy_CatchError",
-    error_kind=ERR_NEVER,
+    arg_types=[], return_type=exc_rtuple, c_function_name="CPy_CatchError", error_kind=ERR_NEVER
 )
 
 # Restore an old "currently handled exception" returned from.
@@ -103,8 +97,5 @@ get_exc_value_op = custom_op(
 
 # Get exception info (exception type, exception instance, traceback object).
 get_exc_info_op = custom_op(
-    arg_types=[],
-    return_type=exc_rtuple,
-    c_function_name="CPy_GetExcInfo",
-    error_kind=ERR_NEVER,
+    arg_types=[], return_type=exc_rtuple, c_function_name="CPy_GetExcInfo", error_kind=ERR_NEVER
 )

jaclang/vendor/mypyc/primitives/int_ops.py

@@ -10,14 +10,12 @@ Use mypyc.ir.ops.IntOp for operations on fixed-width/C integers.
 
 from __future__ import annotations
 
-from typing import NamedTuple
-
 from mypyc.ir.ops import (
     ERR_ALWAYS,
     ERR_MAGIC,
     ERR_MAGIC_OVERLAPPING,
     ERR_NEVER,
-    ComparisonOp,
+    PrimitiveDescription,
 )
 from mypyc.ir.rtypes import (
     RType,
@@ -107,6 +105,26 @@ function_op(
 )
 
 
+def int_binary_primitive(
+    op: str, primitive_name: str, return_type: RType = int_rprimitive, error_kind: int = ERR_NEVER
+) -> PrimitiveDescription:
+    return binary_op(
+        name=op,
+        arg_types=[int_rprimitive, int_rprimitive],
+        return_type=return_type,
+        primitive_name=primitive_name,
+        error_kind=error_kind,
+    )
+
+
+int_eq = int_binary_primitive(op="==", primitive_name="int_eq", return_type=bit_rprimitive)
+int_ne = int_binary_primitive(op="!=", primitive_name="int_ne", return_type=bit_rprimitive)
+int_lt = int_binary_primitive(op="<", primitive_name="int_lt", return_type=bit_rprimitive)
+int_le = int_binary_primitive(op="<=", primitive_name="int_le", return_type=bit_rprimitive)
+int_gt = int_binary_primitive(op=">", primitive_name="int_gt", return_type=bit_rprimitive)
+int_ge = int_binary_primitive(op=">=", primitive_name="int_ge", return_type=bit_rprimitive)
+
+
 def int_binary_op(
     name: str,
     c_function_name: str,
@@ -140,10 +158,7 @@ int_binary_op(">>", "CPyTagged_Rshift", error_kind=ERR_MAGIC)
 int_binary_op("<<", "CPyTagged_Lshift", error_kind=ERR_MAGIC)
 
 int_binary_op(
-    "/",
-    "CPyTagged_TrueDivide",
-    return_type=float_rprimitive,
-    error_kind=ERR_MAGIC_OVERLAPPING,
+    "/", "CPyTagged_TrueDivide", return_type=float_rprimitive, error_kind=ERR_MAGIC_OVERLAPPING
 )
 
 # This should work because assignment operators are parsed differently
@@ -178,20 +193,6 @@ int_invert_op = int_unary_op("~", "CPyTagged_Invert")
 # Primitives related to integer comparison operations:
 
 
-# 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
-
-
 # Equals operation on two boxed tagged integers
 int_equal_ = custom_op(
     arg_types=[int_rprimitive, int_rprimitive],
@@ -208,17 +209,6 @@ int_less_than_ = custom_op(
     error_kind=ERR_NEVER,
 )
 
-# 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),
-}
-
 int64_divide_op = custom_op(
     arg_types=[int64_rprimitive, int64_rprimitive],
     return_type=int64_rprimitive,

jaclang/vendor/mypyc/primitives/list_ops.py

@@ -11,12 +11,14 @@ from mypyc.ir.rtypes import (
     int_rprimitive,
     list_rprimitive,
     object_rprimitive,
+    pointer_rprimitive,
     short_int_rprimitive,
 )
 from mypyc.primitives.registry import (
     ERR_NEG_INT,
     binary_op,
     custom_op,
+    custom_primitive_op,
     function_op,
     load_address_op,
     method_op,
@@ -60,6 +62,14 @@ list_build_op = custom_op(
     steals=True,
 )
 
+# Get pointer to list items (ob_item PyListObject field)
+list_items = custom_primitive_op(
+    name="list_items",
+    arg_types=[list_rprimitive],
+    return_type=pointer_rprimitive,
+    error_kind=ERR_NEVER,
+)
+
 # list[index] (for an integer index)
 list_get_item_op = method_op(
     name="__getitem__",

jaclang/vendor/mypyc/primitives/misc_ops.py

@@ -13,11 +13,14 @@ from mypyc.ir.rtypes import (
     int_rprimitive,
     object_pointer_rprimitive,
     object_rprimitive,
+    pointer_rprimitive,
     str_rprimitive,
+    void_rtype,
 )
 from mypyc.primitives.registry import (
     ERR_NEG_INT,
     custom_op,
+    custom_primitive_op,
     function_op,
     load_address_op,
 )
@@ -29,27 +32,19 @@ load_address_op(name="builtins.bool", type=object_rprimitive, src="PyBool_Type")
 load_address_op(name="builtins.range", type=object_rprimitive, src="PyRange_Type")
 
 # Get the boxed Python 'None' object
-none_object_op = load_address_op(
-    name="Py_None", type=object_rprimitive, src="_Py_NoneStruct"
-)
+none_object_op = load_address_op(name="Py_None", type=object_rprimitive, src="_Py_NoneStruct")
 
 # Get the boxed object '...'
-ellipsis_op = load_address_op(
-    name="...", type=object_rprimitive, src="_Py_EllipsisObject"
-)
+ellipsis_op = load_address_op(name="...", type=object_rprimitive, src="_Py_EllipsisObject")
 
 # Get the boxed NotImplemented object
 not_implemented_op = load_address_op(
-    name="builtins.NotImplemented",
-    type=object_rprimitive,
-    src="_Py_NotImplementedStruct",
+    name="builtins.NotImplemented", type=object_rprimitive, src="_Py_NotImplementedStruct"
 )
 
 # Get the boxed StopAsyncIteration object
 stop_async_iteration_op = load_address_op(
-    name="builtins.StopAsyncIteration",
-    type=object_rprimitive,
-    src="PyExc_StopAsyncIteration",
+    name="builtins.StopAsyncIteration", type=object_rprimitive, src="PyExc_StopAsyncIteration"
 )
 
 # id(obj)
@@ -150,12 +145,7 @@ import_many_op = custom_op(
 
 # From import helper op
 import_from_many_op = custom_op(
-    arg_types=[
-        object_rprimitive,
-        object_rprimitive,
-        object_rprimitive,
-        object_rprimitive,
-    ],
+    arg_types=[object_rprimitive, object_rprimitive, object_rprimitive, object_rprimitive],
     return_type=object_rprimitive,
     c_function_name="CPyImport_ImportFromMany",
     error_kind=ERR_MAGIC,
@@ -220,9 +210,7 @@ type_op = function_op(
 )
 
 # Get 'builtins.type' (base class of all classes)
-type_object_op = load_address_op(
-    name="builtins.type", type=object_rprimitive, src="PyType_Type"
-)
+type_object_op = load_address_op(name="builtins.type", type=object_rprimitive, src="PyType_Type")
 
 # Create a heap type based on a template non-heap type.
 # See CPyType_FromTemplate for more docs.
@@ -252,10 +240,28 @@ check_unpack_count_op = custom_op(
 )
 
 
-# register an implementation for a singledispatch function
+# Register an implementation for a singledispatch function
 register_function = custom_op(
     arg_types=[object_rprimitive, object_rprimitive, object_rprimitive],
     return_type=object_rprimitive,
     c_function_name="CPySingledispatch_RegisterFunction",
     error_kind=ERR_MAGIC,
 )
+
+
+# Initialize a PyObject * item in a memory buffer (steal the value)
+buf_init_item = custom_primitive_op(
+    name="buf_init_item",
+    arg_types=[pointer_rprimitive, c_pyssize_t_rprimitive, object_rprimitive],
+    return_type=void_rtype,
+    error_kind=ERR_NEVER,
+    steals=[False, False, True],
+)
+
+# Get length of PyVarObject instance (e.g. list or tuple)
+var_object_size = custom_primitive_op(
+    name="var_object_size",
+    arg_types=[object_rprimitive],
+    return_type=c_pyssize_t_rprimitive,
+    error_kind=ERR_NEVER,
+)

jaclang/vendor/mypyc/primitives/registry.py

@@ -39,7 +39,7 @@ from __future__ import annotations
 
 from typing import Final, NamedTuple
 
-from mypyc.ir.ops import StealsDescription
+from mypyc.ir.ops import PrimitiveDescription, StealsDescription
 from mypyc.ir.rtypes import RType
 
 # Error kind for functions that return negative integer on exception. This
@@ -76,7 +76,7 @@ method_call_ops: dict[str, list[CFunctionDescription]] = {}
 function_ops: dict[str, list[CFunctionDescription]] = {}
 
 # CallC op for binary ops
-binary_ops: dict[str, list[CFunctionDescription]] = {}
+binary_ops: dict[str, list[PrimitiveDescription]] = {}
 
 # CallC op for unary ops
 unary_ops: dict[str, list[CFunctionDescription]] = {}
@@ -192,8 +192,9 @@ def binary_op(
     name: str,
     arg_types: list[RType],
     return_type: RType,
-    c_function_name: str,
     error_kind: int,
+    c_function_name: str | None = None,
+    primitive_name: str | None = None,
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
@@ -201,7 +202,7 @@ def binary_op(
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
-) -> CFunctionDescription:
+) -> PrimitiveDescription:
     """Define a c function call op for a binary operation.
 
     This will be automatically generated by matching against the AST.
@@ -209,22 +210,24 @@ def binary_op(
     Most arguments are similar to method_op(), but exactly two argument types
     are expected.
     """
+    assert c_function_name is not None or primitive_name is not None
+    assert not (c_function_name is not None and primitive_name is not None)
     if extra_int_constants is None:
         extra_int_constants = []
     ops = binary_ops.setdefault(name, [])
-    desc = CFunctionDescription(
-        name,
-        arg_types,
-        return_type,
-        var_arg_type,
-        truncated_type,
-        c_function_name,
-        error_kind,
-        steals,
-        is_borrowed,
-        ordering,
-        extra_int_constants,
-        priority,
+    desc = PrimitiveDescription(
+        name=primitive_name or name,
+        arg_types=arg_types,
+        return_type=return_type,
+        var_arg_type=var_arg_type,
+        truncated_type=truncated_type,
+        c_function_name=c_function_name,
+        error_kind=error_kind,
+        steals=steals,
+        is_borrowed=is_borrowed,
+        ordering=ordering,
+        extra_int_constants=extra_int_constants,
+        priority=priority,
     )
     ops.append(desc)
     return desc
@@ -264,6 +267,41 @@ def custom_op(
     )
 
 
+def custom_primitive_op(
+    name: str,
+    arg_types: list[RType],
+    return_type: RType,
+    error_kind: int,
+    c_function_name: str | None = None,
+    var_arg_type: RType | None = None,
+    truncated_type: RType | None = None,
+    ordering: list[int] | None = None,
+    extra_int_constants: list[tuple[int, RType]] | None = None,
+    steals: StealsDescription = False,
+    is_borrowed: bool = False,
+) -> PrimitiveDescription:
+    """Define a primitive op that can't be automatically generated based on the AST.
+
+    Most arguments are similar to method_op().
+    """
+    if extra_int_constants is None:
+        extra_int_constants = []
+    return PrimitiveDescription(
+        name=name,
+        arg_types=arg_types,
+        return_type=return_type,
+        var_arg_type=var_arg_type,
+        truncated_type=truncated_type,
+        c_function_name=c_function_name,
+        error_kind=error_kind,
+        steals=steals,
+        is_borrowed=is_borrowed,
+        ordering=ordering,
+        extra_int_constants=extra_int_constants,
+        priority=0,
+    )
+
+
 def unary_op(
     name: str,
     arg_type: RType,
@@ -311,11 +349,10 @@ def load_address_op(name: str, type: RType, src: str) -> LoadAddressDescription:
     return LoadAddressDescription(name, type, src)
 
 
+# Import various modules that set up global state.
 import mypyc.primitives.bytes_ops
 import mypyc.primitives.dict_ops
 import mypyc.primitives.float_ops
-
-# Import various modules that set up global state.
 import mypyc.primitives.int_ops
 import mypyc.primitives.list_ops
 import mypyc.primitives.misc_ops

jaclang/vendor/mypyc/primitives/set_ops.py

@@ -23,9 +23,7 @@ from mypyc.primitives.registry import (
 load_address_op(name="builtins.set", type=object_rprimitive, src="PySet_Type")
 
 # Get the 'builtins.frozenset' tyoe object.
-load_address_op(
-    name="builtins.frozenset", type=object_rprimitive, src="PyFrozenSet_Type"
-)
+load_address_op(name="builtins.frozenset", type=object_rprimitive, src="PyFrozenSet_Type")
 
 # Construct an empty set.
 new_set_op = function_op(

jaclang/vendor/mypyc/rt_subtype.py

@@ -63,8 +63,7 @@ class RTSubtypeVisitor(RTypeVisitor[bool]):
     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)
+                is_runtime_subtype(t1, t2) for t1, t2 in zip(left.types, self.right.types)
             )
         return False
 

jaclang/vendor/mypyc/sametype.py

@@ -25,8 +25,7 @@ def is_same_signature(a: FuncSignature, b: FuncSignature) -> bool:
         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)
+            is_same_type(t1.type, t2.type) and t1.name == t2.name for t1, t2 in zip(a.args, b.args)
         )
     )
 
@@ -71,9 +70,7 @@ class SameTypeVisitor(RTypeVisitor[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)
-            )
+            and all(is_same_type(t1, t2) for t1, t2 in zip(left.types, self.right.types))
         )
 
     def visit_rstruct(self, left: RStruct) -> bool: