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

jaclang/vendor/mypyc/irbuild/mapper.py

@@ -2,16 +2,7 @@
 
 from __future__ import annotations
 
-from mypy.nodes import (
-    ARG_STAR,
-    ARG_STAR2,
-    GDEF,
-    ArgKind,
-    FuncDef,
-    RefExpr,
-    SymbolNode,
-    TypeInfo,
-)
+from mypy.nodes import ARG_STAR, ARG_STAR2, GDEF, ArgKind, FuncDef, RefExpr, SymbolNode, TypeInfo
 from mypy.types import (
     AnyType,
     CallableType,
@@ -135,9 +126,7 @@ class Mapper:
         elif isinstance(typ, NoneTyp):
             return none_rprimitive
         elif isinstance(typ, UnionType):
-            return RUnion.make_simplified_union(
-                [self.type_to_rtype(item) for item in typ.items]
-            )
+            return RUnion.make_simplified_union([self.type_to_rtype(item) for item in typ.items])
         elif isinstance(typ, AnyType):
             return object_rprimitive
         elif isinstance(typ, TypeType):

jaclang/vendor/mypyc/irbuild/match.py

@@ -132,9 +132,7 @@ class MatchVisitor(TraverserVisitor):
         )
 
         cond = self.builder.call_c(
-            isinstance_op,
-            [self.subject, self.builder.accept(pattern.class_ref)],
-            pattern.line,
+            isinstance_op, [self.subject, self.builder.accept(pattern.class_ref)], pattern.line
         )
 
         self.builder.add_bool_branch(cond, self.code_block, self.next_block)
@@ -163,9 +161,7 @@ class MatchVisitor(TraverserVisitor):
 
             for item in match_args_type.items:
                 proper_item = get_proper_type(item)
-                assert (
-                    isinstance(proper_item, Instance) and proper_item.last_known_value
-                )
+                assert isinstance(proper_item, Instance) and proper_item.last_known_value
 
                 match_arg = proper_item.last_known_value.value
                 assert isinstance(match_arg, str)
@@ -178,9 +174,7 @@ class MatchVisitor(TraverserVisitor):
 
                 # TODO: use faster "get_attr" method instead when calling on native or
                 # builtin objects
-                positional = self.builder.py_get_attr(
-                    self.subject, match_args[i], expr.line
-                )
+                positional = self.builder.py_get_attr(self.subject, match_args[i], expr.line)
 
                 with self.enter_subpattern(positional):
                     expr.accept(self)
@@ -222,9 +216,7 @@ class MatchVisitor(TraverserVisitor):
         self.builder.add_bool_branch(cond, self.code_block, self.next_block)
 
     def visit_mapping_pattern(self, pattern: MappingPattern) -> None:
-        is_dict = self.builder.call_c(
-            supports_mapping_protocol, [self.subject], pattern.line
-        )
+        is_dict = self.builder.call_c(supports_mapping_protocol, [self.subject], pattern.line)
 
         self.builder.add_bool_branch(is_dict, self.code_block, self.next_block)
 
@@ -237,20 +229,14 @@ class MatchVisitor(TraverserVisitor):
             key_value = self.builder.accept(key)
             keys.append(key_value)
 
-            exists = self.builder.call_c(
-                mapping_has_key, [self.subject, key_value], pattern.line
-            )
+            exists = self.builder.call_c(mapping_has_key, [self.subject, key_value], pattern.line)
 
             self.builder.add_bool_branch(exists, self.code_block, self.next_block)
             self.builder.activate_block(self.code_block)
             self.code_block = BasicBlock()
 
             item = self.builder.gen_method_call(
-                self.subject,
-                "__getitem__",
-                [key_value],
-                object_rprimitive,
-                pattern.line,
+                self.subject, "__getitem__", [key_value], object_rprimitive, pattern.line
             )
 
             with self.enter_subpattern(item):
@@ -267,27 +253,21 @@ class MatchVisitor(TraverserVisitor):
             self.builder.assign(target, rest, pattern.rest.line)
 
             for i, key_name in enumerate(keys):
-                self.builder.call_c(
-                    dict_del_item, [rest, key_name], pattern.keys[i].line
-                )
+                self.builder.call_c(dict_del_item, [rest, key_name], pattern.keys[i].line)
 
             self.builder.goto(self.code_block)
 
     def visit_sequence_pattern(self, seq_pattern: SequencePattern) -> None:
         star_index, capture, patterns = prep_sequence_pattern(seq_pattern)
 
-        is_list = self.builder.call_c(
-            supports_sequence_protocol, [self.subject], seq_pattern.line
-        )
+        is_list = self.builder.call_c(supports_sequence_protocol, [self.subject], seq_pattern.line)
 
         self.builder.add_bool_branch(is_list, self.code_block, self.next_block)
 
         self.builder.activate_block(self.code_block)
         self.code_block = BasicBlock()
 
-        actual_len = self.builder.call_c(
-            generic_ssize_t_len_op, [self.subject], seq_pattern.line
-        )
+        actual_len = self.builder.call_c(generic_ssize_t_len_op, [self.subject], seq_pattern.line)
         min_len = len(patterns)
 
         is_long_enough = self.builder.binary_op(
@@ -311,9 +291,7 @@ class MatchVisitor(TraverserVisitor):
             else:
                 current = self.builder.load_int(i)
 
-            item = self.builder.call_c(
-                sequence_get_item, [self.subject, current], pattern.line
-            )
+            item = self.builder.call_c(sequence_get_item, [self.subject, current], pattern.line)
 
             with self.enter_subpattern(item):
                 pattern.accept(self)
@@ -323,10 +301,7 @@ class MatchVisitor(TraverserVisitor):
             self.code_block = BasicBlock()
 
             capture_end = self.builder.binary_op(
-                actual_len,
-                self.builder.load_int(min_len - star_index),
-                "-",
-                capture.line,
+                actual_len, self.builder.load_int(min_len - star_index), "-", capture.line
             )
 
             rest = self.builder.call_c(

jaclang/vendor/mypyc/irbuild/nonlocalcontrol.py

@@ -68,10 +68,7 @@ class LoopNonlocalControl(NonlocalControl):
     """Nonlocal control within a loop."""
 
     def __init__(
-        self,
-        outer: NonlocalControl,
-        continue_block: BasicBlock,
-        break_block: BasicBlock,
+        self, outer: NonlocalControl, continue_block: BasicBlock, break_block: BasicBlock
     ) -> None:
         self.outer = outer
         self.continue_block = continue_block
@@ -94,9 +91,7 @@ class GeneratorNonlocalControl(BaseNonlocalControl):
         # Assign an invalid next label number so that the next time
         # __next__ is called, we jump to the case in which
         # StopIteration is raised.
-        builder.assign(
-            builder.fn_info.generator_class.next_label_target, Integer(-1), line
-        )
+        builder.assign(builder.fn_info.generator_class.next_label_target, Integer(-1), line)
 
         # Raise a StopIteration containing a field for the value that
         # should be returned. Before doing so, create a new block

jaclang/vendor/mypyc/irbuild/prebuildvisitor.py

@@ -101,10 +101,7 @@ class PreBuildVisitor(ExtendedTraverserVisitor):
             # mypy. Functions decorated only by special decorators
             # (and property setters) are not treated as decorated
             # functions by the IR builder.
-            if (
-                isinstance(dec.decorators[0], MemberExpr)
-                and dec.decorators[0].name == "setter"
-            ):
+            if isinstance(dec.decorators[0], MemberExpr) and dec.decorators[0].name == "setter":
                 # Property setters are not treated as decorated methods.
                 self.prop_setters.add(dec.func)
             else:

jaclang/vendor/mypyc/irbuild/prepare.py

@@ -50,13 +50,7 @@ from mypyc.ir.func_ir import (
     RuntimeArg,
 )
 from mypyc.ir.ops import DeserMaps
-from mypyc.ir.rtypes import (
-    RInstance,
-    RType,
-    dict_rprimitive,
-    none_rprimitive,
-    tuple_rprimitive,
-)
+from mypyc.ir.rtypes import RInstance, RType, dict_rprimitive, none_rprimitive, tuple_rprimitive
 from mypyc.irbuild.mapper import Mapper
 from mypyc.irbuild.util import (
     get_func_def,
@@ -87,10 +81,7 @@ def build_type_map(
     # references even if there are import cycles.
     for module, cdef in classes:
         class_ir = ClassIR(
-            cdef.name,
-            module.fullname,
-            is_trait(cdef),
-            is_abstract=cdef.info.is_abstract,
+            cdef.name, module.fullname, is_trait(cdef), is_abstract=cdef.info.is_abstract
         )
         class_ir.is_ext_class = is_extension_class(cdef)
         if class_ir.is_ext_class:
@@ -106,17 +97,13 @@ def build_type_map(
             if mapper.type_to_ir[cdef.info].is_ext_class:
                 prepare_class_def(module.path, module.fullname, cdef, errors, mapper)
             else:
-                prepare_non_ext_class_def(
-                    module.path, module.fullname, cdef, errors, mapper
-                )
+                prepare_non_ext_class_def(module.path, module.fullname, cdef, errors, mapper)
 
     # Prepare implicit attribute accessors as needed if an attribute overrides a property.
     for module, cdef in classes:
         class_ir = mapper.type_to_ir[cdef.info]
         if class_ir.is_ext_class:
-            prepare_implicit_property_accessors(
-                cdef.info, class_ir, module.fullname, mapper
-            )
+            prepare_implicit_property_accessors(cdef.info, class_ir, module.fullname, mapper)
 
     # Collect all the functions also. We collect from the symbol table
     # so that we can easily pick out the right copy of a function that
@@ -133,9 +120,7 @@ def build_type_map(
         for attr in class_ir.attributes:
             for base_ir in class_ir.mro[1:]:
                 if attr in base_ir.attributes:
-                    if not is_same_type(
-                        class_ir.attributes[attr], base_ir.attributes[attr]
-                    ):
+                    if not is_same_type(class_ir.attributes[attr], base_ir.attributes[attr]):
                         node = cdef.info.names[attr].node
                         assert node is not None
                         kind = "trait" if base_ir.is_trait else "class"
@@ -151,9 +136,7 @@ def is_from_module(node: SymbolNode, module: MypyFile) -> bool:
     return node.fullname == module.fullname + "." + node.name
 
 
-def load_type_map(
-    mapper: Mapper, modules: list[MypyFile], deser_ctx: DeserMaps
-) -> None:
+def load_type_map(mapper: Mapper, modules: list[MypyFile], deser_ctx: DeserMaps) -> None:
     """Populate a Mapper with deserialized IR from a list of modules."""
     for module in modules:
         for node in module.names.values():
@@ -174,9 +157,9 @@ def get_module_func_defs(module: MypyFile) -> Iterable[FuncDef]:
         # We need to filter out functions that are imported or
         # aliases.  The best way to do this seems to be by
         # checking that the fullname matches.
-        if isinstance(
-            node.node, (FuncDef, Decorator, OverloadedFuncDef)
-        ) and is_from_module(node.node, module):
+        if isinstance(node.node, (FuncDef, Decorator, OverloadedFuncDef)) and is_from_module(
+            node.node, module
+        ):
             yield get_func_def(node.node)
 
 
@@ -194,26 +177,17 @@ def prepare_func_def(
 
 
 def prepare_method_def(
-    ir: ClassIR,
-    module_name: str,
-    cdef: ClassDef,
-    mapper: Mapper,
-    node: FuncDef | Decorator,
+    ir: ClassIR, module_name: str, cdef: ClassDef, mapper: Mapper, node: FuncDef | Decorator
 ) -> None:
     if isinstance(node, FuncDef):
-        ir.method_decls[node.name] = prepare_func_def(
-            module_name, cdef.name, node, mapper
-        )
+        ir.method_decls[node.name] = prepare_func_def(module_name, cdef.name, node, mapper)
     elif isinstance(node, Decorator):
         # TODO: do something about abstract methods here. Currently, they are handled just like
         # normal methods.
         decl = prepare_func_def(module_name, cdef.name, node.func, mapper)
         if not node.decorators:
             ir.method_decls[node.name] = decl
-        elif (
-            isinstance(node.decorators[0], MemberExpr)
-            and node.decorators[0].name == "setter"
-        ):
+        elif isinstance(node.decorators[0], MemberExpr) and node.decorators[0].name == "setter":
             # Make property setter name different than getter name so there are no
             # name clashes when generating C code, and property lookup at the IR level
             # works correctly.
@@ -224,9 +198,7 @@ def prepare_method_def(
             ir.method_decls[PROPSET_PREFIX + node.name] = decl
 
         if node.func.is_property:
-            assert (
-                node.func.type
-            ), f"Expected return type annotation for property '{node.name}'"
+            assert node.func.type, f"Expected return type annotation for property '{node.name}'"
             decl.is_prop_getter = True
             ir.property_types[node.name] = decl.sig.ret_type
 
@@ -298,17 +270,11 @@ def prepare_class_def(
                 # catch it here! But this should catch a lot of the most
                 # common pitfalls.
                 errors.error(
-                    "Inheriting from most builtin types is unimplemented",
-                    path,
-                    cdef.line,
+                    "Inheriting from most builtin types is unimplemented", path, cdef.line
                 )
 
     # Set up the parent class
-    bases = [
-        mapper.type_to_ir[base.type]
-        for base in info.bases
-        if base.type in mapper.type_to_ir
-    ]
+    bases = [mapper.type_to_ir[base.type] for base in info.bases if base.type in mapper.type_to_ir]
     if len(bases) > 1 and any(not c.is_trait for c in bases) and bases[0].is_trait:
         # If the first base is a non-trait, don't ever error here. While it is correct
         # to error if a trait comes before the next non-trait base (e.g. non-trait, trait,
@@ -350,12 +316,7 @@ def prepare_class_def(
 
 
 def prepare_methods_and_attributes(
-    cdef: ClassDef,
-    ir: ClassIR,
-    path: str,
-    module_name: str,
-    errors: Errors,
-    mapper: Mapper,
+    cdef: ClassDef, ir: ClassIR, path: str, module_name: str, errors: Errors, mapper: Mapper
 ) -> None:
     """Populate attribute and method declarations."""
     info = cdef.info
@@ -385,9 +346,7 @@ def prepare_methods_and_attributes(
                     for item in node.node.items:
                         prepare_method_def(ir, module_name, cdef, mapper, item)
                 else:
-                    errors.error(
-                        "Unsupported property decorator semantics", path, cdef.line
-                    )
+                    errors.error("Unsupported property decorator semantics", path, cdef.line)
 
             # Handle case for regular function overload
             else:
@@ -439,9 +398,7 @@ def add_property_methods_for_attribute_if_needed(
             if isinstance(node, Decorator) and node.name not in ir.method_decls:
                 # Defined as a read-only property in base class/trait
                 add_getter_declaration(ir, attr_name, attr_rtype, module_name)
-            elif isinstance(
-                node, OverloadedFuncDef
-            ) and is_valid_multipart_property_def(node):
+            elif isinstance(node, OverloadedFuncDef) and is_valid_multipart_property_def(node):
                 # Defined as a read-write property in base class/trait
                 add_getter_declaration(ir, attr_name, attr_rtype, module_name)
                 add_setter_declaration(ir, attr_name, attr_rtype, module_name)
@@ -475,9 +432,7 @@ def add_setter_declaration(
     ir.method_decls[setter_name] = decl
 
 
-def prepare_init_method(
-    cdef: ClassDef, ir: ClassIR, module_name: str, mapper: Mapper
-) -> None:
+def prepare_init_method(cdef: ClassDef, ir: ClassIR, module_name: str, mapper: Mapper) -> None:
     # Set up a constructor decl
     init_node = cdef.info["__init__"].node
     if not ir.is_trait and not ir.builtin_base and isinstance(init_node, FuncDef):
@@ -520,25 +475,16 @@ def prepare_non_ext_class_def(
             # Handle case for property with both a getter and a setter
             if node.node.is_property:
                 if not is_valid_multipart_property_def(node.node):
-                    errors.error(
-                        "Unsupported property decorator semantics", path, cdef.line
-                    )
+                    errors.error("Unsupported property decorator semantics", path, cdef.line)
                 for item in node.node.items:
                     prepare_method_def(ir, module_name, cdef, mapper, item)
             # Handle case for regular function overload
             else:
-                prepare_method_def(
-                    ir, module_name, cdef, mapper, get_func_def(node.node)
-                )
+                prepare_method_def(ir, module_name, cdef, mapper, get_func_def(node.node))
 
-    if any(
-        cls in mapper.type_to_ir and mapper.type_to_ir[cls].is_ext_class
-        for cls in info.mro
-    ):
+    if any(cls in mapper.type_to_ir and mapper.type_to_ir[cls].is_ext_class for cls in info.mro):
         errors.error(
-            "Non-extension classes may not inherit from extension classes",
-            path,
-            cdef.line,
+            "Non-extension classes may not inherit from extension classes", path, cdef.line
         )
 
 
@@ -557,9 +503,7 @@ def find_singledispatch_register_impls(
     for module in modules:
         visitor.current_path = module.path
         module.accept(visitor)
-    return SingledispatchInfo(
-        visitor.singledispatch_impls, visitor.decorators_to_remove
-    )
+    return SingledispatchInfo(visitor.singledispatch_impls, visitor.decorators_to_remove)
 
 
 class SingledispatchVisitor(TraverserVisitor):
@@ -569,9 +513,7 @@ class SingledispatchVisitor(TraverserVisitor):
         super().__init__()
 
         # Map of main singledispatch function to list of registered implementations
-        self.singledispatch_impls: defaultdict[FuncDef, list[RegisterImplInfo]] = (
-            defaultdict(list)
-        )
+        self.singledispatch_impls: defaultdict[FuncDef, list[RegisterImplInfo]] = defaultdict(list)
 
         # Map of decorated function to the indices of any decorators to remove
         self.decorators_to_remove: dict[FuncDef, list[int]] = {}

jaclang/vendor/mypyc/irbuild/specialize.py

@@ -108,11 +108,7 @@ specializers: dict[tuple[str, RType | None], list[Specializer]] = {}
 
 
 def _apply_specialization(
-    builder: IRBuilder,
-    expr: CallExpr,
-    callee: RefExpr,
-    name: str | None,
-    typ: RType | None = None,
+    builder: IRBuilder, expr: CallExpr, callee: RefExpr, name: str | None, typ: RType | None = None
 ) -> Value | None:
     # TODO: Allow special cases to have default args or named args. Currently they don't since
     #       they check that everything in arg_kinds is ARG_POS.
@@ -160,9 +156,7 @@ def specialize_function(
 
 
 @specialize_function("builtins.globals")
-def translate_globals(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_globals(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if len(expr.args) == 0:
         return builder.load_globals_dict()
     return None
@@ -183,11 +177,7 @@ def translate_builtins_with_unary_dunder(
 
     E.g. i64(x) gets specialized to x.__int__() if x is a native instance.
     """
-    if (
-        len(expr.args) == 1
-        and expr.arg_kinds == [ARG_POS]
-        and isinstance(callee, NameExpr)
-    ):
+    if len(expr.args) == 1 and expr.arg_kinds == [ARG_POS] and isinstance(callee, NameExpr):
         arg = expr.args[0]
         arg_typ = builder.node_type(arg)
         shortname = callee.fullname.split(".")[1]
@@ -223,9 +213,7 @@ def translate_len(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
 
 
 @specialize_function("builtins.list")
-def dict_methods_fast_path(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def dict_methods_fast_path(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     """Specialize a common case when list() is called on a dictionary
     view method call.
 
@@ -235,11 +223,7 @@ def dict_methods_fast_path(
     if not (len(expr.args) == 1 and expr.arg_kinds == [ARG_POS]):
         return None
     arg = expr.args[0]
-    if not (
-        isinstance(arg, CallExpr)
-        and not arg.args
-        and isinstance(arg.callee, MemberExpr)
-    ):
+    if not (isinstance(arg, CallExpr) and not arg.args and isinstance(arg.callee, MemberExpr)):
         return None
     base = arg.callee.expr
     attr = arg.callee.name
@@ -403,24 +387,18 @@ def translate_safe_generator_call(
 
 
 @specialize_function("builtins.any")
-def translate_any_call(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_any_call(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if (
         len(expr.args) == 1
         and expr.arg_kinds == [ARG_POS]
         and isinstance(expr.args[0], GeneratorExpr)
     ):
-        return any_all_helper(
-            builder, expr.args[0], builder.false, lambda x: x, builder.true
-        )
+        return any_all_helper(builder, expr.args[0], builder.false, lambda x: x, builder.true)
     return None
 
 
 @specialize_function("builtins.all")
-def translate_all_call(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_all_call(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if (
         len(expr.args) == 1
         and expr.arg_kinds == [ARG_POS]
@@ -463,9 +441,7 @@ def any_all_helper(
 
 
 @specialize_function("builtins.sum")
-def translate_sum_call(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_sum_call(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     # specialized implementation is used if:
     # - only one or two arguments given (if not, sum() has been given invalid arguments)
     # - first argument is a Generator (there is no benefit to optimizing the performance of eg.
@@ -489,9 +465,7 @@ def translate_sum_call(
     gen_expr = expr.args[0]
     target_type = builder.node_type(expr)
     retval = Register(target_type)
-    builder.assign(
-        retval, builder.coerce(builder.accept(start_expr), target_type, -1), -1
-    )
+    builder.assign(retval, builder.coerce(builder.accept(start_expr), target_type, -1), -1)
 
     def gen_inner_stmts() -> None:
         call_expr = builder.accept(gen_expr.left_expr)
@@ -523,9 +497,7 @@ def translate_dataclasses_field_call(
 
 
 @specialize_function("builtins.next")
-def translate_next_call(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_next_call(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     """Special case for calling next() on a generator expression, an
     idiom that shows up some in mypy.
 
@@ -561,9 +533,7 @@ def translate_next_call(
         builder.assign(retval, default_val, gen.left_expr.line)
         builder.goto(exit_block)
     else:
-        builder.add(
-            RaiseStandardError(RaiseStandardError.STOP_ITERATION, None, expr.line)
-        )
+        builder.add(RaiseStandardError(RaiseStandardError.STOP_ITERATION, None, expr.line))
         builder.add(Unreachable())
 
     builder.activate_block(exit_block)
@@ -571,9 +541,7 @@ def translate_next_call(
 
 
 @specialize_function("builtins.isinstance")
-def translate_isinstance(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_isinstance(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     """Special case for builtins.isinstance.
 
     Prevent coercions on the thing we are checking the instance of -
@@ -590,9 +558,7 @@ def translate_isinstance(
         irs = builder.flatten_classes(expr.args[1])
         if irs is not None:
             can_borrow = all(
-                ir.is_ext_class
-                and not ir.inherits_python
-                and not ir.allow_interpreted_subclasses
+                ir.is_ext_class and not ir.inherits_python and not ir.allow_interpreted_subclasses
                 for ir in irs
             )
             obj = builder.accept(expr.args[0], can_borrow=can_borrow)
@@ -601,9 +567,7 @@ def translate_isinstance(
 
 
 @specialize_function("setdefault", dict_rprimitive)
-def translate_dict_setdefault(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_dict_setdefault(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     """Special case for 'dict.setdefault' which would only construct
     default empty collection when needed.
 
@@ -649,9 +613,7 @@ def translate_dict_setdefault(
 
 
 @specialize_function("format", str_rprimitive)
-def translate_str_format(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_str_format(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if (
         isinstance(callee, MemberExpr)
         and isinstance(callee.expr, StrExpr)
@@ -663,9 +625,7 @@ def translate_str_format(
             return None
         literals, format_ops = tokens
         # Convert variables to strings
-        substitutions = convert_format_expr_to_str(
-            builder, format_ops, expr.args, expr.line
-        )
+        substitutions = convert_format_expr_to_str(builder, format_ops, expr.args, expr.line)
         if substitutions is None:
             return None
         return join_formatted_strings(builder, literals, substitutions, expr.line)
@@ -673,9 +633,7 @@ def translate_str_format(
 
 
 @specialize_function("join", str_rprimitive)
-def translate_fstring(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_fstring(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     """Special case for f-string, which is translated into str.join()
     in mypy AST.
 
@@ -693,14 +651,10 @@ def translate_fstring(
             if isinstance(item, StrExpr):
                 continue
             elif isinstance(item, CallExpr):
-                if (
-                    not isinstance(item.callee, MemberExpr)
-                    or item.callee.name != "format"
-                ):
+                if not isinstance(item.callee, MemberExpr) or item.callee.name != "format":
                     return None
                 elif (
-                    not isinstance(item.callee.expr, StrExpr)
-                    or item.callee.expr.value != "{:{}}"
+                    not isinstance(item.callee.expr, StrExpr) or item.callee.expr.value != "{:{}}"
                 ):
                     return None
 
@@ -720,9 +674,7 @@ def translate_fstring(
                 format_ops.append(FormatOp.STR)
                 exprs.append(item.args[0])
 
-        substitutions = convert_format_expr_to_str(
-            builder, format_ops, exprs, expr.line
-        )
+        substitutions = convert_format_expr_to_str(builder, format_ops, exprs, expr.line)
         if substitutions is None:
             return None
 
@@ -859,9 +811,7 @@ def translate_bool(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
 
 
 @specialize_function("builtins.float")
-def translate_float(
-    builder: IRBuilder, expr: CallExpr, callee: RefExpr
-) -> Value | None:
+def translate_float(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
         return None
     arg = expr.args[0]