jaclang 0.6.0__py3-none-any.whl → 0.6.5__py3-none-any.whl

jaclang/vendor/mypyc/external/googletest/src/gtest_main.cc

@@ -0,0 +1,38 @@
+// Copyright 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <stdio.h>
+
+#include "gtest/gtest.h"
+
+GTEST_API_ int main(int argc, char **argv) {
+  printf("Running main() from gtest_main.cc\n");
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}

jaclang/vendor/mypyc/ir/class_ir.py

@@ -130,9 +130,7 @@ class ClassIR:
         # in a few ad-hoc cases.
         self.builtin_base: str | None = None
         # Default empty constructor
-        self.ctor = FuncDecl(
-            name, None, module_name, FuncSignature([], RInstance(self))
-        )
+        self.ctor = FuncDecl(name, None, module_name, FuncSignature([], RInstance(self)))
         # Attributes defined in the class (not inherited)
         self.attributes: dict[str, RType] = {}
         # Deletable attributes
@@ -373,15 +371,12 @@ class ClassIR:
             ],
             # We serialize properties and property_types separately out of an
             # abundance of caution about preserving dict ordering...
-            "property_types": [
-                (k, t.serialize()) for k, t in self.property_types.items()
-            ],
+            "property_types": [(k, t.serialize()) for k, t in self.property_types.items()],
             "properties": list(self.properties),
             "vtable": self.vtable,
             "vtable_entries": serialize_vtable(self.vtable_entries),
             "trait_vtables": [
-                (cir.fullname, serialize_vtable(v))
-                for cir, v in self.trait_vtables.items()
+                (cir.fullname, serialize_vtable(v)) for cir, v in self.trait_vtables.items()
             ],
             # References to class IRs are all just names
             "base": self.base.fullname if self.base else None,
@@ -389,9 +384,7 @@ class ClassIR:
             "mro": [cir.fullname for cir in self.mro],
             "base_mro": [cir.fullname for cir in self.base_mro],
             "children": (
-                [cir.fullname for cir in self.children]
-                if self.children is not None
-                else None
+                [cir.fullname for cir in self.children] if self.children is not None else None
             ),
             "deletable": self.deletable,
             "attrs_with_defaults": sorted(self.attrs_with_defaults),
@@ -420,23 +413,16 @@ class ClassIR:
         ir.ctor = FuncDecl.deserialize(data["ctor"], ctx)
         ir.attributes = {k: deserialize_type(t, ctx) for k, t in data["attributes"]}
         ir.method_decls = {
-            k: (
-                ctx.functions[v].decl
-                if isinstance(v, str)
-                else FuncDecl.deserialize(v, ctx)
-            )
+            k: ctx.functions[v].decl if isinstance(v, str) else FuncDecl.deserialize(v, ctx)
             for k, v in data["method_decls"]
         }
         ir.methods = {k: ctx.functions[v] for k, v in data["methods"]}
         ir.glue_methods = {
             (ctx.classes[c], k): ctx.functions[v] for (c, k), v in data["glue_methods"]
         }
-        ir.property_types = {
-            k: deserialize_type(t, ctx) for k, t in data["property_types"]
-        }
+        ir.property_types = {k: deserialize_type(t, ctx) for k, t in data["property_types"]}
         ir.properties = {
-            k: (ir.methods[k], ir.methods.get(PROPSET_PREFIX + k))
-            for k in data["properties"]
+            k: (ir.methods[k], ir.methods.get(PROPSET_PREFIX + k)) for k in data["properties"]
         }
 
         ir.vtable = data["vtable"]
@@ -467,9 +453,7 @@ class NonExtClassInfo:
     the class annotations dictionary, and the metaclass.
     """
 
-    def __init__(
-        self, dict: Value, bases: Value, anns: Value, metaclass: Value
-    ) -> None:
+    def __init__(self, dict: Value, bases: Value, anns: Value, metaclass: Value) -> None:
         self.dict = dict
         self.bases = bases
         self.anns = anns

jaclang/vendor/mypyc/ir/func_ir.py

@@ -5,13 +5,7 @@ from __future__ import annotations
 from typing import Final, Sequence
 
 from mypy.nodes import ARG_POS, ArgKind, Block, FuncDef
-from mypyc.common import (
-    BITMAP_BITS,
-    JsonDict,
-    bitmap_name,
-    get_id_from_name,
-    short_id_from_name,
-)
+from mypyc.common import BITMAP_BITS, JsonDict, bitmap_name, get_id_from_name, short_id_from_name
 from mypyc.ir.ops import (
     Assign,
     AssignMulti,
@@ -105,10 +99,7 @@ class FuncSignature:
             args = self.args[: -self.num_bitmap_args]
         else:
             args = self.args
-        return {
-            "args": [t.serialize() for t in args],
-            "ret_type": self.ret_type.serialize(),
-        }
+        return {"args": [t.serialize() for t in args], "ret_type": self.ret_type.serialize()}
 
     @classmethod
     def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> FuncSignature:
@@ -315,11 +306,7 @@ class FuncIR:
     @classmethod
     def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> FuncIR:
         return FuncIR(
-            FuncDecl.deserialize(data["decl"], ctx),
-            [],
-            [],
-            data["line"],
-            data["traceback_name"],
+            FuncDecl.deserialize(data["decl"], ctx), [], [], data["line"], data["traceback_name"]
         )
 
 

jaclang/vendor/mypyc/ir/module_ir.py

@@ -48,9 +48,7 @@ class ModuleIR:
         )
 
 
-def deserialize_modules(
-    data: dict[str, JsonDict], ctx: DeserMaps
-) -> dict[str, ModuleIR]:
+def deserialize_modules(data: dict[str, JsonDict], ctx: DeserMaps) -> dict[str, ModuleIR]:
     """Deserialize a collection of modules.
 
     The modules can contain dependencies on each other.
@@ -69,9 +67,7 @@ def deserialize_modules(
         # First create ClassIRs for every class so that we can construct types and whatnot
         for cls in mod["classes"]:
             ir = ClassIR(cls["name"], cls["module_name"])
-            assert ir.fullname not in ctx.classes, (
-                "Class %s already in map" % ir.fullname
-            )
+            assert ir.fullname not in ctx.classes, "Class %s already in map" % ir.fullname
             ctx.classes[ir.fullname] = ir
 
     for mod in data.values():

jaclang/vendor/mypyc/ir/ops.py

@@ -12,16 +12,7 @@ value has a type (RType). A value can hold various things, such as:
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import (
-    TYPE_CHECKING,
-    Final,
-    Generic,
-    List,
-    NamedTuple,
-    Sequence,
-    TypeVar,
-    Union,
-)
+from typing import TYPE_CHECKING, Final, Generic, List, NamedTuple, Sequence, TypeVar, Union
 
 from mypy_extensions import trait
 
@@ -161,9 +152,7 @@ class Register(Value):
     to refer to arbitrary Values (for example, in RegisterOp).
     """
 
-    def __init__(
-        self, type: RType, name: str = "", is_arg: bool = False, line: int = -1
-    ) -> None:
+    def __init__(self, type: RType, name: str = "", is_arg: bool = False, line: int = -1) -> None:
         self.type = type
         self.name = name
         self.is_arg = is_arg
@@ -194,9 +183,7 @@ class Integer(Value):
      * Null pointers (value 0) of various types, including object_rprimitive
     """
 
-    def __init__(
-        self, value: int, rtype: RType = short_int_rprimitive, line: int = -1
-    ) -> None:
+    def __init__(self, value: int, rtype: RType = short_int_rprimitive, line: int = -1) -> None:
         if is_short_int_rprimitive(rtype) or is_int_rprimitive(rtype):
             self.value = value * 2
         else:
@@ -564,15 +551,11 @@ class Call(RegisterOp):
 class MethodCall(RegisterOp):
     """Native method call obj.method(arg, ...)"""
 
-    def __init__(
-        self, obj: Value, method: str, args: list[Value], line: int = -1
-    ) -> None:
+    def __init__(self, obj: Value, method: str, args: list[Value], line: int = -1) -> None:
         self.obj = obj
         self.method = method
         self.args = args
-        assert isinstance(
-            obj.type, RInstance
-        ), "Methods can only be called on instances"
+        assert isinstance(obj.type, RInstance), "Methods can only be called on instances"
         self.receiver_type = obj.type
         method_ir = self.receiver_type.class_ir.method_sig(method)
         assert method_ir is not None, "{} doesn't have method {}".format(
@@ -593,6 +576,86 @@ class MethodCall(RegisterOp):
         return visitor.visit_method_call(self)
 
 
+class PrimitiveDescription:
+    """Description of a primitive op.
+
+    Primitives get lowered into lower-level ops before code generation.
+
+    If c_function_name is provided, a primitive will be lowered into a CallC op.
+    Otherwise custom logic will need to be implemented to transform the
+    primitive into lower-level ops.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        arg_types: list[RType],
+        return_type: RType,  # TODO: What about generic?
+        var_arg_type: RType | None,
+        truncated_type: RType | None,
+        c_function_name: str | None,
+        error_kind: int,
+        steals: StealsDescription,
+        is_borrowed: bool,
+        ordering: list[int] | None,
+        extra_int_constants: list[tuple[int, RType]],
+        priority: int,
+    ) -> None:
+        # Each primitive much have a distinct name, but otherwise they are arbitrary.
+        self.name: Final = name
+        self.arg_types: Final = arg_types
+        self.return_type: Final = return_type
+        self.var_arg_type: Final = var_arg_type
+        self.truncated_type: Final = truncated_type
+        # If non-None, this will map to a call of a C helper function; if None,
+        # there must be a custom handler function that gets invoked during the lowering
+        # pass to generate low-level IR for the primitive (in the mypyc.lower package)
+        self.c_function_name: Final = c_function_name
+        self.error_kind: Final = error_kind
+        self.steals: Final = steals
+        self.is_borrowed: Final = is_borrowed
+        self.ordering: Final = ordering
+        self.extra_int_constants: Final = extra_int_constants
+        self.priority: Final = priority
+
+    def __repr__(self) -> str:
+        return f"<PrimitiveDescription {self.name}>"
+
+
+class PrimitiveOp(RegisterOp):
+    """A higher-level primitive operation.
+
+    Some of these have special compiler support. These will be lowered
+    (transformed) into lower-level IR ops before code generation, and after
+    reference counting op insertion. Others will be transformed into CallC
+    ops.
+
+    Tagged integer equality is a typical primitive op with non-trivial
+    lowering. It gets transformed into a tag check, followed by different
+    code paths for short and long representations.
+    """
+
+    def __init__(self, args: list[Value], desc: PrimitiveDescription, line: int = -1) -> None:
+        self.args = args
+        self.type = desc.return_type
+        self.error_kind = desc.error_kind
+        self.desc = desc
+
+    def sources(self) -> list[Value]:
+        return self.args
+
+    def stolen(self) -> list[Value]:
+        steals = self.desc.steals
+        if isinstance(steals, list):
+            assert len(steals) == len(self.args)
+            return [arg for arg, steal in zip(self.args, steals) if steal]
+        else:
+            return [] if not steals else self.sources()
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_primitive_op(self)
+
+
 class LoadErrorValue(RegisterOp):
     """Load an error value.
 
@@ -603,11 +666,7 @@ class LoadErrorValue(RegisterOp):
     error_kind = ERR_NEVER
 
     def __init__(
-        self,
-        rtype: RType,
-        line: int = -1,
-        is_borrowed: bool = False,
-        undefines: bool = False,
+        self, rtype: RType, line: int = -1, is_borrowed: bool = False, undefines: bool = False
     ) -> None:
         super().__init__(line)
         self.type = rtype
@@ -661,15 +720,11 @@ class GetAttr(RegisterOp):
 
     error_kind = ERR_MAGIC
 
-    def __init__(
-        self, obj: Value, attr: str, line: int, *, borrow: bool = False
-    ) -> None:
+    def __init__(self, obj: Value, attr: str, line: int, *, borrow: bool = False) -> None:
         super().__init__(line)
         self.obj = obj
         self.attr = attr
-        assert isinstance(obj.type, RInstance), (
-            "Attribute access not supported: %s" % obj.type
-        )
+        assert isinstance(obj.type, RInstance), "Attribute access not supported: %s" % obj.type
         self.class_type = obj.type
         attr_type = obj.type.attr_type(attr)
         self.type = attr_type
@@ -697,9 +752,7 @@ class SetAttr(RegisterOp):
         self.obj = obj
         self.attr = attr
         self.src = src
-        assert isinstance(obj.type, RInstance), (
-            "Attribute access not supported: %s" % obj.type
-        )
+        assert isinstance(obj.type, RInstance), "Attribute access not supported: %s" % obj.type
         self.class_type = obj.type
         self.type = bool_rprimitive
         # If True, we can safely assume that the attribute is previously undefined
@@ -831,9 +884,7 @@ class TupleGet(RegisterOp):
 
     error_kind = ERR_NEVER
 
-    def __init__(
-        self, src: Value, index: int, line: int = -1, *, borrow: bool = False
-    ) -> None:
+    def __init__(self, src: Value, index: int, line: int = -1, *, borrow: bool = False) -> None:
         super().__init__(line)
         self.src = src
         self.index = index
@@ -859,9 +910,7 @@ class Cast(RegisterOp):
 
     error_kind = ERR_MAGIC
 
-    def __init__(
-        self, src: Value, typ: RType, line: int, *, borrow: bool = False
-    ) -> None:
+    def __init__(self, src: Value, typ: RType, line: int, *, borrow: bool = False) -> None:
         super().__init__(line)
         self.src = src
         self.type = typ
@@ -1053,9 +1102,7 @@ class Extend(RegisterOp):
 
     error_kind = ERR_NEVER
 
-    def __init__(
-        self, src: Value, dst_type: RType, signed: bool, line: int = -1
-    ) -> None:
+    def __init__(self, src: Value, dst_type: RType, signed: bool, line: int = -1) -> None:
         super().__init__(line)
         self.src = src
         self.type = dst_type
@@ -1083,9 +1130,7 @@ class LoadGlobal(RegisterOp):
     error_kind = ERR_NEVER
     is_borrowed = True
 
-    def __init__(
-        self, type: RType, identifier: str, line: int = -1, ann: object = None
-    ) -> None:
+    def __init__(self, type: RType, identifier: str, line: int = -1, ann: object = None) -> None:
         super().__init__(line)
         self.identifier = identifier
         self.type = type
@@ -1140,9 +1185,7 @@ class IntOp(RegisterOp):
         RIGHT_SHIFT: ">>",
     }
 
-    def __init__(
-        self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1
-    ) -> None:
+    def __init__(self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
         super().__init__(line)
         self.type = type
         self.lhs = lhs
@@ -1203,14 +1246,7 @@ class ComparisonOp(RegisterOp):
     }
 
     signed_ops: Final = {"==": EQ, "!=": NEQ, "<": SLT, ">": SGT, "<=": SLE, ">=": SGE}
-    unsigned_ops: Final = {
-        "==": EQ,
-        "!=": NEQ,
-        "<": ULT,
-        ">": UGT,
-        "<=": ULE,
-        ">=": UGE,
-    }
+    unsigned_ops: Final = {"==": EQ, "!=": NEQ, "<": ULT, ">": UGT, "<=": ULE, ">=": UGE}
 
     def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
         super().__init__(line)
@@ -1311,9 +1347,7 @@ class FloatComparisonOp(RegisterOp):
 
 # We can't have this in the FloatOp class body, because of
 # https://github.com/mypyc/mypyc/issues/932.
-float_comparison_op_to_id: Final = {
-    op: op_id for op_id, op in FloatComparisonOp.op_str.items()
-}
+float_comparison_op_to_id: Final = {op: op_id for op_id, op in FloatComparisonOp.op_str.items()}
 
 
 class LoadMem(RegisterOp):
@@ -1406,9 +1440,7 @@ class LoadAddress(RegisterOp):
     error_kind = ERR_NEVER
     is_borrowed = True
 
-    def __init__(
-        self, type: RType, src: str | Register | LoadStatic, line: int = -1
-    ) -> None:
+    def __init__(self, type: RType, src: str | Register | LoadStatic, line: int = -1) -> None:
         super().__init__(line)
         self.type = type
         self.src = src
@@ -1494,7 +1526,8 @@ class Unborrow(RegisterOp):
 
     error_kind = ERR_NEVER
 
-    def __init__(self, src: Value) -> None:
+    def __init__(self, src: Value, line: int = -1) -> None:
+        super().__init__(line)
         assert src.is_borrowed
         self.src = src
         self.type = src.type
@@ -1603,6 +1636,10 @@ class OpVisitor(Generic[T]):
     def visit_call_c(self, op: CallC) -> T:
         raise NotImplementedError
 
+    @abstractmethod
+    def visit_primitive_op(self, op: PrimitiveOp) -> T:
+        raise NotImplementedError
+
     @abstractmethod
     def visit_truncate(self, op: Truncate) -> T:
         raise NotImplementedError

jaclang/vendor/mypyc/ir/pprint.py

@@ -43,6 +43,7 @@ from mypyc.ir.ops import (
     MethodCall,
     Op,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
     Return,
@@ -73,10 +74,7 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
     def visit_goto(self, op: Goto) -> str:
         return self.format("goto %l", op.label)
 
-    branch_op_names: Final = {
-        Branch.BOOL: ("%r", "bool"),
-        Branch.IS_ERROR: ("is_error(%r)", ""),
-    }
+    branch_op_names: Final = {Branch.BOOL: ("%r", "bool"), Branch.IS_ERROR: ("is_error(%r)", "")}
 
     def visit_branch(self, op: Branch) -> str:
         fmt, typ = self.branch_op_names[op.op]
@@ -102,9 +100,7 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
         return self.format("%r = %r", op.dest, op.src)
 
     def visit_assign_multi(self, op: AssignMulti) -> str:
-        return self.format(
-            "%r = [%s]", op.dest, ", ".join(self.format("%r", v) for v in op.src)
-        )
+        return self.format("%r = [%s]", op.dest, ", ".join(self.format("%r", v) for v in op.src))
 
     def visit_load_error_value(self, op: LoadErrorValue) -> str:
         return self.format("%r = <error> :: %s", op, op.type)
@@ -159,9 +155,7 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
         return self.format("%s = %r :: %s", name, op.value, op.namespace)
 
     def visit_tuple_get(self, op: TupleGet) -> str:
-        return self.format(
-            "%r = %s%r[%d]", op, self.borrow_prefix(op), op.src, op.index
-        )
+        return self.format("%r = %s%r[%d]", op, self.borrow_prefix(op), op.src, op.index)
 
     def visit_tuple_set(self, op: TupleSet) -> str:
         item_str = ", ".join(self.format("%r", item) for item in op.items)
@@ -198,9 +192,7 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
         return s
 
     def visit_cast(self, op: Cast) -> str:
-        return self.format(
-            "%r = %scast(%s, %r)", op, self.borrow_prefix(op), op.type, op.src
-        )
+        return self.format("%r = %scast(%s, %r)", op, self.borrow_prefix(op), op.type, op.src)
 
     def visit_box(self, op: Box) -> str:
         return self.format("%r = box(%s, %r)", op, op.src.type, op.src)
@@ -211,9 +203,7 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
     def visit_raise_standard_error(self, op: RaiseStandardError) -> str:
         if op.value is not None:
             if isinstance(op.value, str):
-                return self.format(
-                    "%r = raise %s(%s)", op, op.class_name, repr(op.value)
-                )
+                return self.format("%r = raise %s(%s)", op, op.class_name, repr(op.value))
             elif isinstance(op.value, Value):
                 return self.format("%r = raise %s(%r)", op, op.class_name, op.value)
             else:
@@ -228,19 +218,34 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
         else:
             return self.format("%r = %s(%s)", op, op.function_name, args_str)
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> str:
+        args = []
+        arg_index = 0
+        type_arg_index = 0
+        for arg_type in zip(op.desc.arg_types):
+            if arg_type:
+                args.append(self.format("%r", op.args[arg_index]))
+                arg_index += 1
+            else:
+                assert op.type_args
+                args.append(self.format("%r", op.type_args[type_arg_index]))
+                type_arg_index += 1
+
+        args_str = ", ".join(args)
+        if op.is_void:
+            return self.format("%s %s", op.desc.name, args_str)
+        else:
+            return self.format("%r = %s %s", op, op.desc.name, args_str)
+
     def visit_truncate(self, op: Truncate) -> str:
-        return self.format(
-            "%r = truncate %r: %t to %t", op, op.src, op.src_type, op.type
-        )
+        return self.format("%r = truncate %r: %t to %t", op, op.src, op.src_type, op.type)
 
     def visit_extend(self, op: Extend) -> str:
         if op.signed:
             extra = " signed"
         else:
             extra = ""
-        return self.format(
-            "%r = extend%s %r: %t to %t", op, extra, op.src, op.src_type, op.type
-        )
+        return self.format("%r = extend%s %r: %t to %t", op, extra, op.src, op.src_type, op.type)
 
     def visit_load_global(self, op: LoadGlobal) -> str:
         ann = f"  ({repr(op.ann)})" if op.ann else ""
@@ -250,29 +255,14 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
         return self.format("%r = %r %s %r", op, op.lhs, IntOp.op_str[op.op], op.rhs)
 
     def visit_comparison_op(self, op: ComparisonOp) -> str:
-        if op.op in (
-            ComparisonOp.SLT,
-            ComparisonOp.SGT,
-            ComparisonOp.SLE,
-            ComparisonOp.SGE,
-        ):
+        if op.op in (ComparisonOp.SLT, ComparisonOp.SGT, ComparisonOp.SLE, ComparisonOp.SGE):
             sign_format = " :: signed"
-        elif op.op in (
-            ComparisonOp.ULT,
-            ComparisonOp.UGT,
-            ComparisonOp.ULE,
-            ComparisonOp.UGE,
-        ):
+        elif op.op in (ComparisonOp.ULT, ComparisonOp.UGT, ComparisonOp.ULE, ComparisonOp.UGE):
             sign_format = " :: unsigned"
         else:
             sign_format = ""
         return self.format(
-            "%r = %r %s %r%s",
-            op,
-            op.lhs,
-            ComparisonOp.op_str[op.op],
-            op.rhs,
-            sign_format,
+            "%r = %r %s %r%s", op, op.lhs, ComparisonOp.op_str[op.op], op.rhs, sign_format
         )
 
     def visit_float_op(self, op: FloatOp) -> str:
@@ -291,9 +281,7 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
         return self.format("set_mem %r, %r :: %t*", op.dest, op.src, op.dest_type)
 
     def visit_get_element_ptr(self, op: GetElementPtr) -> str:
-        return self.format(
-            "%r = get_element_ptr %r %s :: %t", op, op.src, op.field, op.src_type
-        )
+        return self.format("%r = get_element_ptr %r %s :: %t", op, op.src, op.field, op.src_type)
 
     def visit_load_address(self, op: LoadAddress) -> str:
         if isinstance(op.src, Register):
@@ -312,9 +300,7 @@ class IRPrettyPrintVisitor(OpVisitor[str]):
         else:
             steal = ""
         return self.format(
-            "keep_alive {}{}".format(
-                steal, ", ".join(self.format("%r", v) for v in op.src)
-            )
+            "keep_alive {}{}".format(steal, ", ".join(self.format("%r", v) for v in op.src))
         )
 
     def visit_unborrow(self, op: Unborrow) -> str:
@@ -445,15 +431,11 @@ def format_blocks(
     return lines
 
 
-def format_func(
-    fn: FuncIR, errors: Sequence[tuple[ErrorSource, str]] = ()
-) -> list[str]:
+def format_func(fn: FuncIR, errors: Sequence[tuple[ErrorSource, str]] = ()) -> list[str]:
     lines = []
     cls_prefix = fn.class_name + "." if fn.class_name else ""
     lines.append(
-        "def {}{}({}):".format(
-            cls_prefix, fn.name, ", ".join(arg.name for arg in fn.args)
-        )
+        "def {}{}({}):".format(cls_prefix, fn.name, ", ".join(arg.name for arg in fn.args))
     )
     names = generate_names_for_ir(fn.arg_regs, fn.blocks)
     for line in format_registers(fn, names):
@@ -477,9 +459,7 @@ def format_modules(modules: ModuleIRs) -> list[str]:
     return ops
 
 
-def generate_names_for_ir(
-    args: list[Register], blocks: list[BasicBlock]
-) -> dict[Value, str]:
+def generate_names_for_ir(args: list[Register], blocks: list[BasicBlock]) -> dict[Value, str]:
     """Generate unique names for IR values.
 
     Give names such as 'r5' to temp values in IR which are useful when