Update more call_c call sites

Author: JukkaL

mypyc/irbuild/builder.py

@@ -84,6 +84,7 @@
     IntOp,
     LoadStatic,
     Op,
+    PrimitiveDescription,
     RaiseStandardError,
     Register,
     SetAttr,
@@ -134,7 +135,7 @@
 from mypyc.primitives.generic_ops import iter_op, next_op, py_setattr_op
 from mypyc.primitives.list_ops import list_get_item_unsafe_op, list_pop_last, to_list
 from mypyc.primitives.misc_ops import check_unpack_count_op, get_module_dict_op, import_op
-from mypyc.primitives.registry import CFunctionDescription, PrimitiveDescription, function_ops
+from mypyc.primitives.registry import CFunctionDescription, function_ops
 
 # These int binary operations can borrow their operands safely, since the
 # primitives take this into consideration.
@@ -694,7 +695,7 @@ def assign(self, target: Register | AssignmentTarget, rvalue_reg: Value, line: i
             else:
                 key = self.load_str(target.attr)
                 boxed_reg = self.builder.box(rvalue_reg)
-                self.call_c(py_setattr_op, [target.obj, key, boxed_reg], line)
+                self.primitive_op(py_setattr_op, [target.obj, key, boxed_reg], line)
         elif isinstance(target, AssignmentTargetIndex):
             target_reg2 = self.gen_method_call(
                 target.base, "__setitem__", [target.index, rvalue_reg], None, line
@@ -771,7 +772,7 @@ def process_iterator_tuple_assignment_helper(
     def process_iterator_tuple_assignment(
         self, target: AssignmentTargetTuple, rvalue_reg: Value, line: int
     ) -> None:
-        iterator = self.call_c(iter_op, [rvalue_reg], line)
+        iterator = self.primitive_op(iter_op, [rvalue_reg], line)
 
         # This may be the whole lvalue list if there is no starred value
         split_idx = target.star_idx if target.star_idx is not None else len(target.items)
@@ -797,7 +798,7 @@ def process_iterator_tuple_assignment(
         # Assign the starred value and all values after it
         if target.star_idx is not None:
             post_star_vals = target.items[split_idx + 1 :]
-            iter_list = self.call_c(to_list, [iterator], line)
+            iter_list = self.primitive_op(to_list, [iterator], line)
             iter_list_len = self.builtin_len(iter_list, line)
             post_star_len = Integer(len(post_star_vals))
             condition = self.binary_op(post_star_len, iter_list_len, "<=", line)

mypyc/irbuild/expression.py

@@ -476,7 +476,7 @@ def translate_super_method_call(builder: IRBuilder, expr: CallExpr, callee: Supe
         # Grab first argument
         vself: Value = builder.self()
         if decl.kind == FUNC_CLASSMETHOD:
-            vself = builder.call_c(type_op, [vself], expr.line)
+            vself = builder.primitive_op(type_op, [vself], expr.line)
         elif builder.fn_info.is_generator:
             # For generator classes, the self target is the 6th value
             # in the symbol table (which is an ordered dict). This is sort
@@ -953,7 +953,7 @@ def transform_tuple_expr(builder: IRBuilder, expr: TupleExpr) -> Value:
 def _visit_tuple_display(builder: IRBuilder, expr: TupleExpr) -> Value:
     """Create a list, then turn it into a tuple."""
     val_as_list = _visit_list_display(builder, expr.items, expr.line)
-    return builder.call_c(list_tuple_op, [val_as_list], expr.line)
+    return builder.primitive_op(list_tuple_op, [val_as_list], expr.line)
 
 
 def transform_dict_expr(builder: IRBuilder, expr: DictExpr) -> Value:

mypyc/irbuild/for_helpers.py

@@ -586,7 +586,7 @@ def init(self, expr_reg: Value, target_type: RType) -> None:
         # for the for-loop. If we are inside of a generator function, spill these into the
         # environment class.
         builder = self.builder
-        iter_reg = builder.call_c(iter_op, [expr_reg], self.line)
+        iter_reg = builder.primitive_op(iter_op, [expr_reg], self.line)
         builder.maybe_spill(expr_reg)
         self.iter_target = builder.maybe_spill(iter_reg)
         self.target_type = target_type

mypyc/irbuild/format_str_tokenizer.py

@@ -146,12 +146,12 @@ def convert_format_expr_to_str(
             if is_str_rprimitive(node_type):
                 var_str = builder.accept(x)
             elif is_int_rprimitive(node_type) or is_short_int_rprimitive(node_type):
-                var_str = builder.call_c(int_to_str_op, [builder.accept(x)], line)
+                var_str = builder.primitive_op(int_to_str_op, [builder.accept(x)], line)
             else:
-                var_str = builder.call_c(str_op, [builder.accept(x)], line)
+                var_str = builder.primitive_op(str_op, [builder.accept(x)], line)
         elif format_op == FormatOp.INT:
             if is_int_rprimitive(node_type) or is_short_int_rprimitive(node_type):
-                var_str = builder.call_c(int_to_str_op, [builder.accept(x)], line)
+                var_str = builder.primitive_op(int_to_str_op, [builder.accept(x)], line)
             else:
                 return None
         else:

mypyc/irbuild/function.py

@@ -433,7 +433,7 @@ def handle_ext_method(builder: IRBuilder, cdef: ClassDef, fdef: FuncDef) -> None
 
         # Set the callable object representing the decorated method as an attribute of the
         # extension class.
-        builder.call_c(py_setattr_op, [typ, builder.load_str(name), decorated_func], fdef.line)
+        builder.primitive_op(py_setattr_op, [typ, builder.load_str(name), decorated_func], fdef.line)
 
     if fdef.is_property:
         # If there is a property setter, it will be processed after the getter,
@@ -973,7 +973,7 @@ def generate_singledispatch_callable_class_ctor(builder: IRBuilder) -> None:
         cache_dict = builder.call_c(dict_new_op, [], line)
         dispatch_cache_str = builder.load_str("dispatch_cache")
         # use the py_setattr_op instead of SetAttr so that it also gets added to our __dict__
-        builder.call_c(py_setattr_op, [builder.self(), dispatch_cache_str, cache_dict], line)
+        builder.primitive_op(py_setattr_op, [builder.self(), dispatch_cache_str, cache_dict], line)
         # the generated C code seems to expect that __init__ returns a char, so just return 1
         builder.add(Return(Integer(1, bool_rprimitive, line), line))
 
@@ -1016,7 +1016,7 @@ def maybe_insert_into_registry_dict(builder: IRBuilder, fitem: FuncDef) -> None:
         registry_dict = builder.builder.make_dict([(loaded_object_type, main_func_obj)], line)
 
         dispatch_func_obj = builder.load_global_str(fitem.name, line)
-        builder.call_c(
+        builder.primitive_op(
             py_setattr_op, [dispatch_func_obj, builder.load_str("registry"), registry_dict], line
         )
 

mypyc/irbuild/match.py

@@ -131,7 +131,7 @@ def visit_class_pattern(self, pattern: ClassPattern) -> None:
             else slow_isinstance_op
         )
 
-        cond = self.builder.call_c(
+        cond = self.builder.primitive_op(
             isinstance_op, [self.subject, self.builder.accept(pattern.class_ref)], pattern.line
         )
 
@@ -246,7 +246,7 @@ def visit_mapping_pattern(self, pattern: MappingPattern) -> None:
             self.builder.activate_block(self.code_block)
             self.code_block = BasicBlock()
 
-            rest = self.builder.call_c(dict_copy, [self.subject], pattern.rest.line)
+            rest = self.builder.primitive_op(dict_copy, [self.subject], pattern.rest.line)
 
             target = self.builder.get_assignment_target(pattern.rest)
 

mypyc/irbuild/statement.py

@@ -58,6 +58,7 @@
     LoadLiteral,
     LoadStatic,
     MethodCall,
+    PrimitiveDescription,
     RaiseStandardError,
     Register,
     Return,
@@ -757,7 +758,7 @@ def transform_with(
         value = builder.add(MethodCall(mgr_v, f"__{al}enter__", args=[], line=line))
         exit_ = None
     else:
-        typ = builder.call_c(type_op, [mgr_v], line)
+        typ = builder.primitive_op(type_op, [mgr_v], line)
         exit_ = builder.maybe_spill(builder.py_get_attr(typ, f"__{al}exit__", line))
         value = builder.py_call(builder.py_get_attr(typ, f"__{al}enter__", line), [mgr_v], line)
 
@@ -876,7 +877,7 @@ def transform_del_item(builder: IRBuilder, target: AssignmentTarget, line: int)
                     line,
                 )
         key = builder.load_str(target.attr)
-        builder.call_c(py_delattr_op, [target.obj, key], line)
+        builder.primitive_op(py_delattr_op, [target.obj, key], line)
     elif isinstance(target, AssignmentTargetRegister):
         # Delete a local by assigning an error value to it, which will
         # prompt the insertion of uninit checks.
@@ -924,7 +925,10 @@ def emit_yield_from_or_await(
     received_reg = Register(object_rprimitive)
 
     get_op = coro_op if is_await else iter_op
-    iter_val = builder.call_c(get_op, [val], line)
+    if isinstance(get_op, PrimitiveDescription):
+        iter_val = builder.primitive_op(get_op, [val], line)
+    else:
+        iter_val = builder.call_c(get_op, [val], line)
 
     iter_reg = builder.maybe_spill_assignable(iter_val)