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

jaclang/vendor/mypyc/irbuild/ll_builder.py

@@ -63,9 +63,10 @@ from mypyc.ir.ops import (
     LoadStatic,
     MethodCall,
     Op,
+    PrimitiveDescription,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
-    SetMem,
     Truncate,
     TupleGet,
     TupleSet,
@@ -77,10 +78,8 @@ from mypyc.ir.ops import (
     int_op_to_id,
 )
 from mypyc.ir.rtypes import (
-    PyListObject,
     PyObject,
     PySetObject,
-    PyVarObject,
     RArray,
     RInstance,
     RPrimitive,
@@ -126,7 +125,6 @@ from mypyc.ir.rtypes import (
     short_int_rprimitive,
     str_rprimitive,
 )
-from mypyc.irbuild.mapper import Mapper
 from mypyc.irbuild.util import concrete_arg_kind
 from mypyc.options import CompilerOptions
 from mypyc.primitives.bytes_ops import bytes_compare
@@ -158,14 +156,19 @@ from mypyc.primitives.int_ops import (
     int64_divide_op,
     int64_mod_op,
     int64_to_int_op,
-    int_comparison_op_mapping,
     int_to_int32_op,
     int_to_int64_op,
     ssize_t_to_int_op,
     uint8_overflow,
 )
-from mypyc.primitives.list_ops import list_build_op, list_extend_op, new_list_op
-from mypyc.primitives.misc_ops import bool_op, fast_isinstance_op, none_object_op
+from mypyc.primitives.list_ops import list_build_op, list_extend_op, list_items, new_list_op
+from mypyc.primitives.misc_ops import (
+    bool_op,
+    buf_init_item,
+    fast_isinstance_op,
+    none_object_op,
+    var_object_size,
+)
 from mypyc.primitives.registry import (
     ERR_NEG_INT,
     CFunctionDescription,
@@ -174,16 +177,8 @@ from mypyc.primitives.registry import (
     unary_ops,
 )
 from mypyc.primitives.set_ops import new_set_op
-from mypyc.primitives.str_ops import (
-    str_check_if_true,
-    str_ssize_t_size_op,
-    unicode_compare,
-)
-from mypyc.primitives.tuple_ops import (
-    list_tuple_op,
-    new_tuple_op,
-    new_tuple_with_length_op,
-)
+from mypyc.primitives.str_ops import str_check_if_true, str_ssize_t_size_op, unicode_compare
+from mypyc.primitives.tuple_ops import list_tuple_op, new_tuple_op, new_tuple_with_length_op
 from mypyc.rt_subtype import is_runtime_subtype
 from mypyc.sametype import is_same_type
 from mypyc.subtype import is_subtype
@@ -224,33 +219,12 @@ FIXED_WIDTH_INT_BINARY_OPS: Final = {
 }
 
 # Binary operations on bools that are specialized and don't just promote operands to int
-BOOL_BINARY_OPS: Final = {
-    "&",
-    "&=",
-    "|",
-    "|=",
-    "^",
-    "^=",
-    "==",
-    "!=",
-    "<",
-    "<=",
-    ">",
-    ">=",
-}
+BOOL_BINARY_OPS: Final = {"&", "&=", "|", "|=", "^", "^=", "==", "!=", "<", "<=", ">", ">="}
 
 
 class LowLevelIRBuilder:
-    def __init__(
-        self,
-        current_module: str,
-        errors: Errors,
-        mapper: Mapper,
-        options: CompilerOptions,
-    ) -> None:
-        self.current_module = current_module
+    def __init__(self, errors: Errors | None, options: CompilerOptions) -> None:
         self.errors = errors
-        self.mapper = mapper
         self.options = options
         self.args: list[Register] = []
         self.blocks: list[BasicBlock] = []
@@ -365,17 +339,13 @@ class LowLevelIRBuilder:
             ):
                 value = src.numeric_value()
                 if not check_native_int_range(target_type, value):
-                    self.error(
-                        f'Value {value} is out of range for "{target_type}"', line
-                    )
+                    self.error(f'Value {value} is out of range for "{target_type}"', line)
                 return Integer(src.value >> 1, target_type)
             elif is_int_rprimitive(src_type) and is_fixed_width_rtype(target_type):
                 return self.coerce_int_to_fixed_width(src, target_type, line)
             elif is_fixed_width_rtype(src_type) and is_int_rprimitive(target_type):
                 return self.coerce_fixed_width_to_int(src, line)
-            elif is_short_int_rprimitive(src_type) and is_fixed_width_rtype(
-                target_type
-            ):
+            elif is_short_int_rprimitive(src_type) and is_fixed_width_rtype(target_type):
                 return self.coerce_short_int_to_fixed_width(src, target_type, line)
             elif (
                 isinstance(src_type, RPrimitive)
@@ -387,9 +357,9 @@ class LowLevelIRBuilder:
             ):
                 # Equivalent types
                 return src
-            elif (
-                is_bool_rprimitive(src_type) or is_bit_rprimitive(src_type)
-            ) and is_tagged(target_type):
+            elif (is_bool_rprimitive(src_type) or is_bit_rprimitive(src_type)) and is_tagged(
+                target_type
+            ):
                 shifted = self.int_op(
                     bool_rprimitive, src, Integer(1, bool_rprimitive), IntOp.LEFT_SHIFT
                 )
@@ -424,11 +394,7 @@ class LowLevelIRBuilder:
                     values.append(v)
                 return self.add(
                     TupleSet(
-                        [
-                            self.coerce(v, t, line)
-                            for v, t in zip(values, target_type.types)
-                        ],
-                        line,
+                        [self.coerce(v, t, line) for v, t in zip(values, target_type.types)], line
                     )
                 )
             # To go between any other unboxed types, we go through a boxed
@@ -445,9 +411,7 @@ class LowLevelIRBuilder:
             return tmp
         return src
 
-    def coerce_int_to_fixed_width(
-        self, src: Value, target_type: RType, line: int
-    ) -> Value:
+    def coerce_int_to_fixed_width(self, src: Value, target_type: RType, line: int) -> Value:
         assert is_fixed_width_rtype(target_type), target_type
         assert isinstance(target_type, RPrimitive)
 
@@ -467,18 +431,14 @@ class LowLevelIRBuilder:
             upper_bound = 1 << (size * 8 - 1)
             if not target_type.is_signed:
                 upper_bound *= 2
-            check2 = self.add(
-                ComparisonOp(src, Integer(upper_bound, src.type), ComparisonOp.SLT)
-            )
+            check2 = self.add(ComparisonOp(src, Integer(upper_bound, src.type), ComparisonOp.SLT))
             self.add(Branch(check2, fast2, slow, Branch.BOOL))
             self.activate_block(fast2)
             if target_type.is_signed:
                 lower_bound = -upper_bound
             else:
                 lower_bound = 0
-            check3 = self.add(
-                ComparisonOp(src, Integer(lower_bound, src.type), ComparisonOp.SGE)
-            )
+            check3 = self.add(ComparisonOp(src, Integer(lower_bound, src.type), ComparisonOp.SGE))
             self.add(Branch(check3, fast3, slow, Branch.BOOL))
             self.activate_block(fast3)
             tmp = self.int_op(
@@ -494,9 +454,7 @@ class LowLevelIRBuilder:
                 tmp = self.add(Extend(src, target_type, signed=True))
             else:
                 tmp = src
-            tmp = self.int_op(
-                target_type, tmp, Integer(1, target_type), IntOp.RIGHT_SHIFT, line
-            )
+            tmp = self.int_op(target_type, tmp, Integer(1, target_type), IntOp.RIGHT_SHIFT, line)
 
         self.add(Assign(res, tmp))
         self.goto(end)
@@ -537,13 +495,9 @@ class LowLevelIRBuilder:
         self.activate_block(end)
         return res
 
-    def coerce_short_int_to_fixed_width(
-        self, src: Value, target_type: RType, line: int
-    ) -> Value:
+    def coerce_short_int_to_fixed_width(self, src: Value, target_type: RType, line: int) -> Value:
         if is_int64_rprimitive(target_type):
-            return self.int_op(
-                target_type, src, Integer(1, target_type), IntOp.RIGHT_SHIFT, line
-            )
+            return self.int_op(target_type, src, Integer(1, target_type), IntOp.RIGHT_SHIFT, line)
         # TODO: i32
         assert False, (src.type, target_type)
 
@@ -554,9 +508,7 @@ class LowLevelIRBuilder:
             or is_uint8_rprimitive(src.type)
         ):
             # Simple case -- just sign extend and shift.
-            extended = self.add(
-                Extend(src, c_pyssize_t_rprimitive, signed=src.type.is_signed)
-            )
+            extended = self.add(Extend(src, c_pyssize_t_rprimitive, signed=src.type.is_signed))
             return self.int_op(
                 int_rprimitive,
                 extended,
@@ -573,15 +525,11 @@ class LowLevelIRBuilder:
 
         fast, fast2, slow, end = BasicBlock(), BasicBlock(), BasicBlock(), BasicBlock()
 
-        c1 = self.add(
-            ComparisonOp(src, Integer(MAX_SHORT_INT, src_type), ComparisonOp.SLE)
-        )
+        c1 = self.add(ComparisonOp(src, Integer(MAX_SHORT_INT, src_type), ComparisonOp.SLE))
         self.add(Branch(c1, fast, slow, Branch.BOOL))
 
         self.activate_block(fast)
-        c2 = self.add(
-            ComparisonOp(src, Integer(MIN_SHORT_INT, src_type), ComparisonOp.SGE)
-        )
+        c2 = self.add(ComparisonOp(src, Integer(MIN_SHORT_INT, src_type), ComparisonOp.SGE))
         self.add(Branch(c2, fast2, slow, Branch.BOOL))
 
         self.activate_block(slow)
@@ -601,9 +549,7 @@ class LowLevelIRBuilder:
             tmp = self.add(Truncate(src, c_pyssize_t_rprimitive))
         else:
             tmp = src
-        s = self.int_op(
-            int_rprimitive, tmp, Integer(1, tmp.type), IntOp.LEFT_SHIFT, line
-        )
+        s = self.int_op(int_rprimitive, tmp, Integer(1, tmp.type), IntOp.LEFT_SHIFT, line)
         self.add(Assign(res, s))
         self.goto(end)
 
@@ -638,13 +584,7 @@ class LowLevelIRBuilder:
     # Attribute access
 
     def get_attr(
-        self,
-        obj: Value,
-        attr: str,
-        result_type: RType,
-        line: int,
-        *,
-        borrow: bool = False,
+        self, obj: Value, attr: str, result_type: RType, line: int, *, borrow: bool = False
     ) -> Value:
         """Get a native or Python attribute of an object."""
         if (
@@ -683,9 +623,7 @@ class LowLevelIRBuilder:
 
     # isinstance() checks
 
-    def isinstance_helper(
-        self, obj: Value, class_irs: list[ClassIR], line: int
-    ) -> Value:
+    def isinstance_helper(self, obj: Value, class_irs: list[ClassIR], line: int) -> Value:
         """Fast path for isinstance() that checks against a list of native classes."""
         if not class_irs:
             return self.false()
@@ -695,9 +633,7 @@ class LowLevelIRBuilder:
             def other() -> Value:
                 return self.isinstance_native(obj, class_ir, line)
 
-            ret = self.shortcircuit_helper(
-                "or", bool_rprimitive, lambda: ret, other, line
-            )
+            ret = self.shortcircuit_helper("or", bool_rprimitive, lambda: ret, other, line)
         return ret
 
     def get_type_of_obj(self, obj: Value, line: int) -> Value:
@@ -719,9 +655,7 @@ class LowLevelIRBuilder:
         """
         concrete = all_concrete_classes(class_ir)
         if concrete is None or len(concrete) > FAST_ISINSTANCE_MAX_SUBCLASSES + 1:
-            return self.call_c(
-                fast_isinstance_op, [obj, self.get_native_type(class_ir)], line
-            )
+            return self.call_c(fast_isinstance_op, [obj, self.get_native_type(class_ir)], line)
         if not concrete:
             # There can't be any concrete instance that matches this.
             return self.false()
@@ -732,9 +666,7 @@ class LowLevelIRBuilder:
             def other() -> Value:
                 return self.type_is_op(obj, self.get_native_type(c), line)
 
-            ret = self.shortcircuit_helper(
-                "or", bool_rprimitive, lambda: ret, other, line
-            )
+            ret = self.shortcircuit_helper("or", bool_rprimitive, lambda: ret, other, line)
         return ret
 
     # Calls
@@ -836,9 +768,7 @@ class LowLevelIRBuilder:
             else:
                 nullable = kind.is_optional()
                 maybe_pos = kind.is_positional() and has_star
-                maybe_named = kind.is_named() or (
-                    kind.is_optional() and name and has_star2
-                )
+                maybe_named = kind.is_named() or (kind.is_optional() and name and has_star2)
 
                 # If the argument is nullable, we need to create the
                 # relevant args/kwargs objects so that we can
@@ -884,9 +814,7 @@ class LowLevelIRBuilder:
                 # version! What a pain!
                 if maybe_pos and maybe_named and seen_empty_reg:
                     pos_block, named_block = BasicBlock(), BasicBlock()
-                    self.add(
-                        Branch(seen_empty_reg, named_block, pos_block, Branch.BOOL)
-                    )
+                    self.add(Branch(seen_empty_reg, named_block, pos_block, Branch.BOOL))
                 else:
                     pos_block = named_block = BasicBlock()
                     self.goto(pos_block)
@@ -905,11 +833,7 @@ class LowLevelIRBuilder:
                     key = self.load_str(name)
                     assert star2_result
                     self.translate_special_method_call(
-                        star2_result,
-                        "__setitem__",
-                        [key, value],
-                        result_type=None,
-                        line=line,
+                        star2_result, "__setitem__", [key, value], result_type=None, line=line
                     )
                     self.goto(out)
 
@@ -952,9 +876,7 @@ class LowLevelIRBuilder:
         """
         if use_vectorcall(self.options.capi_version):
             # More recent Python versions support faster vectorcalls.
-            result = self._py_vector_call(
-                function, arg_values, line, arg_kinds, arg_names
-            )
+            result = self._py_vector_call(function, arg_values, line, arg_kinds, arg_names)
             if result is not None:
                 return result
 
@@ -966,16 +888,11 @@ class LowLevelIRBuilder:
         assert arg_names is not None
 
         pos_args_tuple, kw_args_dict = self._construct_varargs(
-            list(zip(arg_values, arg_kinds, arg_names)),
-            line,
-            has_star=True,
-            has_star2=True,
+            list(zip(arg_values, arg_kinds, arg_names)), line, has_star=True, has_star2=True
         )
         assert pos_args_tuple and kw_args_dict
 
-        return self.call_c(
-            py_call_with_kwargs_op, [function, pos_args_tuple, kw_args_dict], line
-        )
+        return self.call_c(py_call_with_kwargs_op, [function, pos_args_tuple, kw_args_dict], line)
 
     def _py_vector_call(
         self,
@@ -996,12 +913,8 @@ class LowLevelIRBuilder:
         ):
             if arg_values:
                 # Create a C array containing all arguments as boxed values.
-                coerced_args = [
-                    self.coerce(arg, object_rprimitive, line) for arg in arg_values
-                ]
-                arg_ptr = self.setup_rarray(
-                    object_rprimitive, coerced_args, object_ptr=True
-                )
+                coerced_args = [self.coerce(arg, object_rprimitive, line) for arg in arg_values]
+                arg_ptr = self.setup_rarray(object_rprimitive, coerced_args, object_ptr=True)
             else:
                 arg_ptr = Integer(0, object_pointer_rprimitive)
             num_pos = num_positional_args(arg_values, arg_kinds)
@@ -1051,15 +964,11 @@ class LowLevelIRBuilder:
         if arg_kinds is None or all(kind == ARG_POS for kind in arg_kinds):
             # Use legacy method call API
             method_name_reg = self.load_str(method_name)
-            return self.call_c(
-                py_method_call_op, [obj, method_name_reg] + arg_values, line
-            )
+            return self.call_c(py_method_call_op, [obj, method_name_reg] + arg_values, line)
         else:
             # Use py_call since it supports keyword arguments (and vectorcalls).
             method = self.py_get_attr(obj, method_name, line)
-            return self.py_call(
-                method, arg_values, line, arg_kinds=arg_kinds, arg_names=arg_names
-            )
+            return self.py_call(method, arg_values, line, arg_kinds=arg_kinds, arg_names=arg_names)
 
     def _py_vector_method_call(
         self,
@@ -1082,9 +991,7 @@ class LowLevelIRBuilder:
             coerced_args = [
                 self.coerce(arg, object_rprimitive, line) for arg in [obj] + arg_values
             ]
-            arg_ptr = self.setup_rarray(
-                object_rprimitive, coerced_args, object_ptr=True
-            )
+            arg_ptr = self.setup_rarray(object_rprimitive, coerced_args, object_ptr=True)
             num_pos = num_positional_args(arg_values, arg_kinds)
             keywords = self._vectorcall_keywords(arg_names)
             value = self.call_c(
@@ -1092,10 +999,7 @@ class LowLevelIRBuilder:
                 [
                     method_name_reg,
                     arg_ptr,
-                    Integer(
-                        (num_pos + 1) | PY_VECTORCALL_ARGUMENTS_OFFSET,
-                        c_size_t_rprimitive,
-                    ),
+                    Integer((num_pos + 1) | PY_VECTORCALL_ARGUMENTS_OFFSET, c_size_t_rprimitive),
                     keywords,
                 ],
                 line,
@@ -1170,9 +1074,7 @@ class LowLevelIRBuilder:
         star_arg_entries = []
         for lst, arg in zip(formal_to_actual, sig_args):
             if arg.kind.is_star():
-                star_arg_entries.extend(
-                    [(args[i], arg_kinds[i], arg_names[i]) for i in lst]
-                )
+                star_arg_entries.extend([(args[i], arg_kinds[i], arg_names[i]) for i in lst])
             has_star = has_star or arg.kind == ARG_STAR
             has_star2 = has_star2 or arg.kind == ARG_STAR2
 
@@ -1240,9 +1142,7 @@ class LowLevelIRBuilder:
         """Generate either a native or Python method call."""
         # If we have *args, then fallback to Python method call.
         if arg_kinds is not None and any(kind.is_star() for kind in arg_kinds):
-            return self.py_method_call(
-                base, name, arg_values, base.line, arg_kinds, arg_names
-            )
+            return self.py_method_call(base, name, arg_values, base.line, arg_kinds, arg_names)
 
         # If the base type is one of ours, do a MethodCall
         if (
@@ -1257,9 +1157,7 @@ class LowLevelIRBuilder:
                     arg_kinds = [ARG_POS for _ in arg_values]
                     arg_names = [None for _ in arg_values]
                 else:
-                    assert (
-                        arg_names is not None
-                    ), "arg_kinds present but arg_names is not"
+                    assert arg_names is not None, "arg_kinds present but arg_names is not"
 
                 # Normalize args to positionals.
                 assert decl.bound_sig
@@ -1275,14 +1173,7 @@ class LowLevelIRBuilder:
 
         elif isinstance(base.type, RUnion):
             return self.union_method_call(
-                base,
-                base.type,
-                name,
-                arg_values,
-                result_type,
-                line,
-                arg_kinds,
-                arg_names,
+                base, base.type, name, arg_values, result_type, line, arg_kinds, arg_names
             )
 
         # Try to do a special-cased method call
@@ -1317,9 +1208,7 @@ class LowLevelIRBuilder:
                 value, name, arg_values, return_rtype, line, arg_kinds, arg_names
             )
 
-        return self.decompose_union_helper(
-            base, obj_type, return_rtype, call_union_item, line
-        )
+        return self.decompose_union_helper(base, obj_type, return_rtype, call_union_item, line)
 
     # Loading various values
 
@@ -1410,11 +1299,7 @@ class LowLevelIRBuilder:
         rtype = rreg.type
 
         # Special case tuple comparison here so that nested tuples can be supported
-        if (
-            isinstance(ltype, RTuple)
-            and isinstance(rtype, RTuple)
-            and op in ("==", "!=")
-        ):
+        if isinstance(ltype, RTuple) and isinstance(rtype, RTuple) and op in ("==", "!="):
             return self.compare_tuples(lreg, rreg, op, line)
 
         # Special case == and != when we can resolve the method call statically
@@ -1430,19 +1315,9 @@ class LowLevelIRBuilder:
         # call to PyErr_Occurred()
         if is_str_rprimitive(ltype) and is_str_rprimitive(rtype) and op in ("==", "!="):
             return self.compare_strings(lreg, rreg, op, line)
-        if (
-            is_bytes_rprimitive(ltype)
-            and is_bytes_rprimitive(rtype)
-            and op in ("==", "!=")
-        ):
+        if is_bytes_rprimitive(ltype) and is_bytes_rprimitive(rtype) and op in ("==", "!="):
             return self.compare_bytes(lreg, rreg, op, line)
-        if is_tagged(ltype) and is_tagged(rtype) and op in int_comparison_op_mapping:
-            return self.compare_tagged(lreg, rreg, op, line)
-        if (
-            is_bool_rprimitive(ltype)
-            and is_bool_rprimitive(rtype)
-            and op in BOOL_BINARY_OPS
-        ):
+        if is_bool_rprimitive(ltype) and is_bool_rprimitive(rtype) and op in BOOL_BINARY_OPS:
             if op in ComparisonOp.signed_ops:
                 return self.bool_comparison_op(lreg, rreg, op, line)
             else:
@@ -1475,9 +1350,7 @@ class LowLevelIRBuilder:
                 if is_fixed_width_rtype(rreg.type):
                     return self.comparison_op(lreg, rreg, op_id, line)
                 if isinstance(rreg, Integer):
-                    return self.comparison_op(
-                        lreg, self.coerce(rreg, ltype, line), op_id, line
-                    )
+                    return self.comparison_op(lreg, self.coerce(rreg, ltype, line), op_id, line)
         elif is_fixed_width_rtype(rtype):
             if op in FIXED_WIDTH_INT_BINARY_OPS:
                 if op.endswith("="):
@@ -1502,28 +1375,10 @@ class LowLevelIRBuilder:
                     lreg = self.coerce(lreg, rtype, line)
                 op_id = ComparisonOp.signed_ops[op]
                 if isinstance(lreg, Integer):
-                    return self.comparison_op(
-                        self.coerce(lreg, rtype, line), rreg, op_id, line
-                    )
+                    return self.comparison_op(self.coerce(lreg, rtype, line), rreg, op_id, line)
                 if is_fixed_width_rtype(lreg.type):
                     return self.comparison_op(lreg, rreg, op_id, line)
 
-        # Mixed int comparisons
-        if op in ("==", "!="):
-            op_id = ComparisonOp.signed_ops[op]
-            if is_tagged(ltype) and is_subtype(rtype, ltype):
-                rreg = self.coerce(rreg, int_rprimitive, line)
-                return self.comparison_op(lreg, rreg, op_id, line)
-            if is_tagged(rtype) and is_subtype(ltype, rtype):
-                lreg = self.coerce(lreg, int_rprimitive, line)
-                return self.comparison_op(lreg, rreg, op_id, line)
-        elif op in op in int_comparison_op_mapping:
-            if is_tagged(ltype) and is_subtype(rtype, ltype):
-                rreg = self.coerce(rreg, short_int_rprimitive, line)
-                return self.compare_tagged(lreg, rreg, op, line)
-            if is_tagged(rtype) and is_subtype(ltype, rtype):
-                lreg = self.coerce(lreg, short_int_rprimitive, line)
-                return self.compare_tagged(lreg, rreg, op, line)
         if is_float_rprimitive(ltype) or is_float_rprimitive(rtype):
             if isinstance(lreg, Integer):
                 lreg = Float(float(lreg.numeric_value()))
@@ -1535,9 +1390,7 @@ class LowLevelIRBuilder:
                 rreg = self.int_to_float(rreg, line)
             if is_float_rprimitive(lreg.type) and is_float_rprimitive(rreg.type):
                 if op in float_comparison_op_to_id:
-                    return self.compare_floats(
-                        lreg, rreg, float_comparison_op_to_id[op], line
-                    )
+                    return self.compare_floats(lreg, rreg, float_comparison_op_to_id[op], line)
                 if op.endswith("="):
                     base_op = op[:-1]
                 else:
@@ -1545,14 +1398,12 @@ class LowLevelIRBuilder:
                 if base_op in float_op_to_id:
                     return self.float_op(lreg, rreg, base_op, line)
 
-        call_c_ops_candidates = binary_ops.get(op, [])
-        target = self.matching_call_c(call_c_ops_candidates, [lreg, rreg], line)
+        primitive_ops_candidates = binary_ops.get(op, [])
+        target = self.matching_primitive_op(primitive_ops_candidates, [lreg, rreg], line)
         assert target, "Unsupported binary operation: %s" % op
         return target
 
-    def check_tagged_short_int(
-        self, val: Value, line: int, negated: bool = False
-    ) -> Value:
+    def check_tagged_short_int(self, val: Value, line: int, negated: bool = False) -> Value:
         """Check if a tagged integer is a short integer.
 
         Return the result of the check (value of type 'bit').
@@ -1564,104 +1415,6 @@ class LowLevelIRBuilder:
         check = self.comparison_op(bitwise_and, zero, op, line)
         return check
 
-    def compare_tagged(self, 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) and is_short_int_rprimitive(rhs.type):
-            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)
-        if op in ("==", "!="):
-            check = check_lhs
-        else:
-            # for non-equality logical ops (less/greater than, etc.), need to check both sides
-            check_rhs = self.check_tagged_short_int(rhs, line)
-            check = self.int_op(bit_rprimitive, check_lhs, check_rhs, IntOp.AND, line)
-        self.add(Branch(check, short_int_block, int_block, Branch.BOOL))
-        self.activate_block(short_int_block)
-        eq = self.comparison_op(lhs, rhs, op_type, line)
-        self.add(Assign(result, eq, line))
-        self.goto(out)
-        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_and_activate(out)
-        return result
-
-    def compare_tagged_condition(
-        self,
-        lhs: Value,
-        rhs: Value,
-        op: str,
-        true: BasicBlock,
-        false: BasicBlock,
-        line: int,
-    ) -> None:
-        """Compare two tagged integers using given operator (conditional context).
-
-        Assume lhs and rhs are tagged integers.
-
-        Args:
-            lhs: Left operand
-            rhs: Right operand
-            op: Operation, one of '==', '!=', '<', '<=', '>', '<='
-            true: Branch target if comparison is true
-            false: Branch target if comparison is false
-        """
-        is_eq = op in ("==", "!=")
-        if (
-            is_short_int_rprimitive(lhs.type) and is_short_int_rprimitive(rhs.type)
-        ) or (
-            is_eq
-            and (is_short_int_rprimitive(lhs.type) or is_short_int_rprimitive(rhs.type))
-        ):
-            # We can skip the tag check
-            check = self.comparison_op(lhs, rhs, int_comparison_op_mapping[op][0], line)
-            self.flush_keep_alives()
-            self.add(Branch(check, true, false, Branch.BOOL))
-            return
-        op_type, c_func_desc, negate_result, swap_op = int_comparison_op_mapping[op]
-        int_block, short_int_block = BasicBlock(), BasicBlock()
-        check_lhs = self.check_tagged_short_int(lhs, line, negated=True)
-        if is_eq or is_short_int_rprimitive(rhs.type):
-            self.flush_keep_alives()
-            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
-            rhs_block = BasicBlock()
-            self.add(Branch(check_lhs, int_block, rhs_block, Branch.BOOL))
-            self.activate_block(rhs_block)
-            check_rhs = self.check_tagged_short_int(rhs, line, negated=True)
-            self.flush_keep_alives()
-            self.add(Branch(check_rhs, int_block, short_int_block, Branch.BOOL))
-        # Arbitrary integers (slow path)
-        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:
-            self.add(Branch(call, false, true, Branch.BOOL))
-        else:
-            self.flush_keep_alives()
-            self.add(Branch(call, true, false, Branch.BOOL))
-        # Short integers (fast path)
-        self.activate_block(short_int_block)
-        eq = self.comparison_op(lhs, rhs, op_type, line)
-        self.add(Branch(eq, true, false, Branch.BOOL))
-
     def compare_strings(self, lhs: Value, rhs: Value, op: str, line: int) -> Value:
         """Compare two strings"""
         compare_result = self.call_c(unicode_compare, [lhs, rhs], line)
@@ -1669,14 +1422,8 @@ class LowLevelIRBuilder:
         compare_error_check = self.add(
             ComparisonOp(compare_result, error_constant, ComparisonOp.EQ, line)
         )
-        exception_check, propagate, final_compare = (
-            BasicBlock(),
-            BasicBlock(),
-            BasicBlock(),
-        )
-        branch = Branch(
-            compare_error_check, exception_check, final_compare, Branch.BOOL
-        )
+        exception_check, propagate, final_compare = BasicBlock(), BasicBlock(), BasicBlock()
+        branch = Branch(compare_error_check, exception_check, final_compare, Branch.BOOL)
         branch.negated = False
         self.add(branch)
         self.activate_block(exception_check)
@@ -1693,16 +1440,12 @@ class LowLevelIRBuilder:
         self.goto(final_compare)
         self.activate_block(final_compare)
         op_type = ComparisonOp.EQ if op == "==" else ComparisonOp.NEQ
-        return self.add(
-            ComparisonOp(compare_result, Integer(0, c_int_rprimitive), op_type, line)
-        )
+        return self.add(ComparisonOp(compare_result, Integer(0, c_int_rprimitive), op_type, line))
 
     def compare_bytes(self, lhs: Value, rhs: Value, op: str, line: int) -> Value:
         compare_result = self.call_c(bytes_compare, [lhs, rhs], line)
         op_type = ComparisonOp.EQ if op == "==" else ComparisonOp.NEQ
-        return self.add(
-            ComparisonOp(compare_result, Integer(1, c_int_rprimitive), op_type, line)
-        )
+        return self.add(ComparisonOp(compare_result, Integer(1, c_int_rprimitive), op_type, line))
 
     def compare_tuples(self, lhs: Value, rhs: Value, op: str, line: int = -1) -> Value:
         """Compare two tuples item by item"""
@@ -1750,16 +1493,12 @@ class LowLevelIRBuilder:
         self.goto_and_activate(out)
         return result
 
-    def translate_instance_contains(
-        self, inst: Value, item: Value, op: str, line: int
-    ) -> Value:
+    def translate_instance_contains(self, inst: Value, item: Value, op: str, line: int) -> Value:
         res = self.gen_method_call(inst, "__contains__", [item], None, line)
         if not is_bool_rprimitive(res.type):
             res = self.call_c(bool_op, [res], line)
         if op == "not in":
-            res = self.bool_bitwise_op(
-                res, Integer(1, rtype=bool_rprimitive), "^", line
-            )
+            res = self.bool_bitwise_op(res, Integer(1, rtype=bool_rprimitive), "^", line)
         return res
 
     def bool_bitwise_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value:
@@ -1888,19 +1627,11 @@ class LowLevelIRBuilder:
         if not values:
             return result_list
         args = [self.coerce(item, object_rprimitive, line) for item in values]
-        ob_item_ptr = self.add(
-            GetElementPtr(result_list, PyListObject, "ob_item", line)
-        )
-        ob_item_base = self.add(LoadMem(pointer_rprimitive, ob_item_ptr, line))
+        ob_item_base = self.add(PrimitiveOp([result_list], list_items, line))
         for i in range(len(values)):
-            if i == 0:
-                item_address = ob_item_base
-            else:
-                offset = Integer(PLATFORM_SIZE * i, c_pyssize_t_rprimitive, line)
-                item_address = self.add(
-                    IntOp(pointer_rprimitive, ob_item_base, offset, IntOp.ADD, line)
-                )
-            self.add(SetMem(object_rprimitive, item_address, args[i], line))
+            self.primitive_op(
+                buf_init_item, [ob_item_base, Integer(i, c_pyssize_t_rprimitive), args[i]], line
+            )
         self.add(KeepAlive([result_list]))
         return result_list
 
@@ -1914,9 +1645,7 @@ class LowLevelIRBuilder:
         array = Register(RArray(item_type, len(values)))
         self.add(AssignMulti(array, list(values)))
         return self.add(
-            LoadAddress(
-                object_pointer_rprimitive if object_ptr else c_pointer_rprimitive, array
-            )
+            LoadAddress(object_pointer_rprimitive if object_ptr else c_pointer_rprimitive, array)
         )
 
     def shortcircuit_helper(
@@ -1934,9 +1663,7 @@ class LowLevelIRBuilder:
         # true_body is taken if the left is true, false_body if it is false.
         # For 'and' the value is the right side if the left is true, and for 'or'
         # it is the right side if the left is false.
-        true_body, false_body = (
-            (right_body, left_body) if op == "and" else (left_body, right_body)
-        )
+        true_body, false_body = (right_body, left_body) if op == "and" else (left_body, right_body)
 
         left_value = left()
         self.add_bool_branch(left_value, true_body, false_body)
@@ -1982,19 +1709,13 @@ class LowLevelIRBuilder:
             and value.type.class_ir.has_method("__bool__")
         ):
             # Directly call the __bool__ method on classes that have it.
-            result = self.gen_method_call(
-                value, "__bool__", [], bool_rprimitive, value.line
-            )
+            result = self.gen_method_call(value, "__bool__", [], bool_rprimitive, value.line)
         elif is_float_rprimitive(value.type):
-            result = self.compare_floats(
-                value, Float(0.0), FloatComparisonOp.NEQ, value.line
-            )
+            result = self.compare_floats(value, Float(0.0), FloatComparisonOp.NEQ, value.line)
         else:
             value_type = optional_value_type(value.type)
             if value_type is not None:
-                not_none = self.translate_is_op(
-                    value, self.none_object(), "is not", value.line
-                )
+                not_none = self.translate_is_op(value, self.none_object(), "is not", value.line)
                 always_truthy = False
                 if isinstance(value_type, RInstance):
                     # check whether X.__bool__ is always just the default (object.__bool__)
@@ -2026,18 +1747,14 @@ class LowLevelIRBuilder:
                 result = self.call_c(bool_op, [value], value.line)
         return result
 
-    def add_bool_branch(
-        self, value: Value, true: BasicBlock, false: BasicBlock
-    ) -> None:
+    def add_bool_branch(self, value: Value, true: BasicBlock, false: BasicBlock) -> None:
         opt_value_type = optional_value_type(value.type)
         if opt_value_type is None:
             bool_value = self.bool_value(value)
             self.add(Branch(bool_value, true, false, Branch.BOOL))
         else:
             # Special-case optional types
-            is_none = self.translate_is_op(
-                value, self.none_object(), "is not", value.line
-            )
+            is_none = self.translate_is_op(value, self.none_object(), "is not", value.line)
             branch = Branch(is_none, true, false, Branch.BOOL)
             self.add(branch)
             always_truthy = False
@@ -2114,9 +1831,7 @@ class LowLevelIRBuilder:
                 if not isinstance(arg, (Integer, LoadLiteral)):
                     self.keep_alives.append(arg)
         if desc.error_kind == ERR_NEG_INT:
-            comp = ComparisonOp(
-                target, Integer(0, desc.return_type, line), ComparisonOp.SGE, line
-            )
+            comp = ComparisonOp(target, Integer(0, desc.return_type, line), ComparisonOp.SGE, line)
             comp.error_kind = ERR_FALSE
             self.add(comp)
 
@@ -2131,9 +1846,7 @@ class LowLevelIRBuilder:
                 # and so we can't just coerce it.
                 result = self.none()
             else:
-                result = self.coerce(
-                    target, result_type, line, can_borrow=desc.is_borrowed
-                )
+                result = self.coerce(target, result_type, line, can_borrow=desc.is_borrowed)
         return result
 
     def matching_call_c(
@@ -2149,13 +1862,12 @@ class LowLevelIRBuilder:
             if len(desc.arg_types) != len(args):
                 continue
             if all(
-                is_subtype(actual.type, formal)
-                for actual, formal in zip(args, desc.arg_types)
+                is_subtype(actual.type, formal) for actual, formal in zip(args, desc.arg_types)
             ) and (not desc.is_borrowed or can_borrow):
                 if matching:
-                    assert (
-                        matching.priority != desc.priority
-                    ), "Ambiguous:\n1) {}\n2) {}".format(matching, desc)
+                    assert matching.priority != desc.priority, "Ambiguous:\n1) {}\n2) {}".format(
+                        matching, desc
+                    )
                     if desc.priority > matching.priority:
                         matching = desc
                 else:
@@ -2165,9 +1877,103 @@ class LowLevelIRBuilder:
             return target
         return None
 
-    def int_op(
-        self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1
+    def primitive_op(
+        self,
+        desc: PrimitiveDescription,
+        args: list[Value],
+        line: int,
+        result_type: RType | None = None,
     ) -> Value:
+        """Add a primitive op."""
+        # Does this primitive map into calling a Python C API
+        # or an internal mypyc C API function?
+        if desc.c_function_name:
+            # TODO: Generate PrimitiOps here and transform them into CallC
+            # ops only later in the lowering pass
+            c_desc = CFunctionDescription(
+                desc.name,
+                desc.arg_types,
+                desc.return_type,
+                desc.var_arg_type,
+                desc.truncated_type,
+                desc.c_function_name,
+                desc.error_kind,
+                desc.steals,
+                desc.is_borrowed,
+                desc.ordering,
+                desc.extra_int_constants,
+                desc.priority,
+            )
+            return self.call_c(c_desc, args, line, result_type)
+
+        # This primitve gets transformed in a lowering pass to
+        # lower-level IR ops using a custom transform function.
+
+        coerced = []
+        # Coerce fixed number arguments
+        for i in range(min(len(args), len(desc.arg_types))):
+            formal_type = desc.arg_types[i]
+            arg = args[i]
+            assert formal_type is not None  # TODO
+            arg = self.coerce(arg, formal_type, line)
+            coerced.append(arg)
+        assert desc.ordering is None
+        assert desc.var_arg_type is None
+        assert not desc.extra_int_constants
+        target = self.add(PrimitiveOp(coerced, desc, line=line))
+        if desc.is_borrowed:
+            # If the result is borrowed, force the arguments to be
+            # kept alive afterwards, as otherwise the result might be
+            # immediately freed, at the risk of a dangling pointer.
+            for arg in coerced:
+                if not isinstance(arg, (Integer, LoadLiteral)):
+                    self.keep_alives.append(arg)
+        if desc.error_kind == ERR_NEG_INT:
+            comp = ComparisonOp(target, Integer(0, desc.return_type, line), ComparisonOp.SGE, line)
+            comp.error_kind = ERR_FALSE
+            self.add(comp)
+
+        assert desc.truncated_type is None
+        result = target
+        if result_type and not is_runtime_subtype(result.type, result_type):
+            if is_none_rprimitive(result_type):
+                # Special case None return. The actual result may actually be a bool
+                # and so we can't just coerce it.
+                result = self.none()
+            else:
+                result = self.coerce(result, result_type, line, can_borrow=desc.is_borrowed)
+        return result
+
+    def matching_primitive_op(
+        self,
+        candidates: list[PrimitiveDescription],
+        args: list[Value],
+        line: int,
+        result_type: RType | None = None,
+        can_borrow: bool = False,
+    ) -> Value | None:
+        matching: PrimitiveDescription | None = None
+        for desc in candidates:
+            if len(desc.arg_types) != len(args):
+                continue
+            if all(
+                # formal is not None and # TODO
+                is_subtype(actual.type, formal)
+                for actual, formal in zip(args, desc.arg_types)
+            ) and (not desc.is_borrowed or can_borrow):
+                if matching:
+                    assert matching.priority != desc.priority, "Ambiguous:\n1) {}\n2) {}".format(
+                        matching, desc
+                    )
+                    if desc.priority > matching.priority:
+                        matching = desc
+                else:
+                    matching = desc
+        if matching:
+            return self.primitive_op(matching, args, line=line)
+        return None
+
+    def int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1) -> Value:
         """Generate a native integer binary op.
 
         Use native/C semantics, which sometimes differ from Python
@@ -2199,11 +2005,7 @@ class LowLevelIRBuilder:
                     msg = "float division by zero"
                 else:
                     msg = "float modulo"
-                self.add(
-                    RaiseStandardError(
-                        RaiseStandardError.ZERO_DIVISION_ERROR, msg, line
-                    )
-                )
+                self.add(RaiseStandardError(RaiseStandardError.ZERO_DIVISION_ERROR, msg, line))
                 self.add(Unreachable())
                 self.activate_block(ok)
         if op_id == FloatOp.MOD:
@@ -2217,15 +2019,8 @@ class LowLevelIRBuilder:
         mod = self.add(FloatOp(lhs, rhs, FloatOp.MOD, line))
         res = Register(float_rprimitive)
         self.add(Assign(res, mod))
-        tricky, adjust, copysign, done = (
-            BasicBlock(),
-            BasicBlock(),
-            BasicBlock(),
-            BasicBlock(),
-        )
-        is_zero = self.add(
-            FloatComparisonOp(res, Float(0.0), FloatComparisonOp.EQ, line)
-        )
+        tricky, adjust, copysign, done = BasicBlock(), BasicBlock(), BasicBlock(), BasicBlock()
+        is_zero = self.add(FloatComparisonOp(res, Float(0.0), FloatComparisonOp.EQ, line))
         self.add(Branch(is_zero, copysign, tricky, Branch.BOOL))
         self.activate_block(tricky)
         same_signs = self.is_same_float_signs(lhs, rhs, line)
@@ -2308,17 +2103,13 @@ class LowLevelIRBuilder:
         self.activate_block(err)
         self.add(
             RaiseStandardError(
-                RaiseStandardError.ZERO_DIVISION_ERROR,
-                "integer division or modulo by zero",
-                line,
+                RaiseStandardError.ZERO_DIVISION_ERROR, "integer division or modulo by zero", line
             )
         )
         self.add(Unreachable())
         self.activate_block(ok)
 
-    def inline_fixed_width_divide(
-        self, type: RType, lhs: Value, rhs: Value, line: int
-    ) -> Value:
+    def inline_fixed_width_divide(self, type: RType, lhs: Value, rhs: Value, line: int) -> Value:
         # Perform floor division (native division truncates)
         res = Register(type)
         div = self.int_op(type, lhs, rhs, IntOp.DIV, line)
@@ -2337,9 +2128,7 @@ class LowLevelIRBuilder:
         self.activate_block(done)
         return res
 
-    def inline_fixed_width_mod(
-        self, type: RType, lhs: Value, rhs: Value, line: int
-    ) -> Value:
+    def inline_fixed_width_mod(self, type: RType, lhs: Value, rhs: Value, line: int) -> Value:
         # Perform floor modulus
         res = Register(type)
         mod = self.int_op(type, lhs, rhs, IntOp.MOD, line)
@@ -2357,9 +2146,7 @@ class LowLevelIRBuilder:
         self.activate_block(done)
         return res
 
-    def is_same_native_int_signs(
-        self, type: RType, a: Value, b: Value, line: int
-    ) -> Value:
+    def is_same_native_int_signs(self, type: RType, a: Value, b: Value, line: int) -> Value:
         neg1 = self.add(ComparisonOp(a, Integer(0, type), ComparisonOp.SLT, line))
         neg2 = self.add(ComparisonOp(b, Integer(0, type), ComparisonOp.SLT, line))
         return self.add(ComparisonOp(neg1, neg2, ComparisonOp.EQ, line))
@@ -2380,14 +2167,8 @@ class LowLevelIRBuilder:
         """
         typ = val.type
         size_value = None
-        if (
-            is_list_rprimitive(typ)
-            or is_tuple_rprimitive(typ)
-            or is_bytes_rprimitive(typ)
-        ):
-            elem_address = self.add(GetElementPtr(val, PyVarObject, "ob_size"))
-            size_value = self.add(LoadMem(c_pyssize_t_rprimitive, elem_address))
-            self.add(KeepAlive([val]))
+        if is_list_rprimitive(typ) or is_tuple_rprimitive(typ) or is_bytes_rprimitive(typ):
+            size_value = self.primitive_op(var_object_size, [val], line)
         elif is_set_rprimitive(typ):
             elem_address = self.add(GetElementPtr(val, PySetObject, "used"))
             size_value = self.add(LoadMem(c_pyssize_t_rprimitive, elem_address))
@@ -2401,9 +2182,7 @@ class LowLevelIRBuilder:
             if use_pyssize_t:
                 return size_value
             offset = Integer(1, c_pyssize_t_rprimitive, line)
-            return self.int_op(
-                short_int_rprimitive, size_value, offset, IntOp.LEFT_SHIFT, line
-            )
+            return self.int_op(short_int_rprimitive, size_value, offset, IntOp.LEFT_SHIFT, line)
 
         if isinstance(typ, RInstance):
             # TODO: Support use_pyssize_t
@@ -2411,7 +2190,8 @@ class LowLevelIRBuilder:
             length = self.gen_method_call(val, "__len__", [], int_rprimitive, line)
             length = self.coerce(length, int_rprimitive, line)
             ok, fail = BasicBlock(), BasicBlock()
-            self.compare_tagged_condition(length, Integer(0), ">=", ok, fail, line)
+            cond = self.binary_op(length, Integer(0), ">=", line)
+            self.add_bool_branch(cond, ok, fail)
             self.activate_block(fail)
             self.add(
                 RaiseStandardError(
@@ -2533,17 +2313,11 @@ class LowLevelIRBuilder:
         """
         call_c_ops_candidates = method_call_ops.get(name, [])
         call_c_op = self.matching_call_c(
-            call_c_ops_candidates,
-            [base_reg] + args,
-            line,
-            result_type,
-            can_borrow=can_borrow,
+            call_c_ops_candidates, [base_reg] + args, line, result_type, can_borrow=can_borrow
         )
         return call_c_op
 
-    def translate_eq_cmp(
-        self, lreg: Value, rreg: Value, expr_op: str, line: int
-    ) -> Value | None:
+    def translate_eq_cmp(self, lreg: Value, rreg: Value, expr_op: str, line: int) -> Value | None:
         """Add a equality comparison operation.
 
         Args:
@@ -2577,9 +2351,7 @@ class LowLevelIRBuilder:
 
         return self.gen_method_call(lreg, op_methods[expr_op], [rreg], ltype, line)
 
-    def translate_is_op(
-        self, lreg: Value, rreg: Value, expr_op: str, line: int
-    ) -> Value:
+    def translate_is_op(self, lreg: Value, rreg: Value, expr_op: str, line: int) -> Value:
         """Create equality comparison operation between object identities
 
         Args:
@@ -2603,12 +2375,11 @@ class LowLevelIRBuilder:
             return self.call_c(dict_new_op, [], line)
 
     def error(self, msg: str, line: int) -> None:
+        assert self.errors is not None, "cannot generate errors in this compiler phase"
         self.errors.error(msg, self.module_path, line)
 
 
-def num_positional_args(
-    arg_values: list[Value], arg_kinds: list[ArgKind] | None
-) -> int:
+def num_positional_args(arg_values: list[Value], arg_kinds: list[ArgKind] | None) -> int:
     if arg_kinds is None:
         return len(arg_values)
     num_pos = 0