[mypyc] Remove c_ prefix in primitive registry (#9725)

relates mypyc/mypyc#781

remove the c_ prefix since we no longer have the old registry.

Author: TH3CHARLie

mypyc/irbuild/builder.py

@@ -43,7 +43,7 @@
 )
 from mypyc.ir.func_ir import FuncIR, INVALID_FUNC_DEF
 from mypyc.ir.class_ir import ClassIR, NonExtClassInfo
-from mypyc.primitives.registry import CFunctionDescription, c_function_ops
+from mypyc.primitives.registry import CFunctionDescription, function_ops
 from mypyc.primitives.list_ops import to_list, list_pop_last
 from mypyc.primitives.dict_ops import dict_get_item_op, dict_set_item_op
 from mypyc.primitives.generic_ops import py_setattr_op, iter_op, next_op
@@ -755,7 +755,7 @@ def call_refexpr_with_args(
 
         # Handle data-driven special-cased primitive call ops.
         if callee.fullname is not None and expr.arg_kinds == [ARG_POS] * len(arg_values):
-            call_c_ops_candidates = c_function_ops.get(callee.fullname, [])
+            call_c_ops_candidates = function_ops.get(callee.fullname, [])
             target = self.builder.matching_call_c(call_c_ops_candidates, arg_values,
                                                   expr.line, self.node_type(expr))
             if target:

mypyc/irbuild/ll_builder.py

@@ -39,8 +39,8 @@
     STATIC_PREFIX, PLATFORM_SIZE
 )
 from mypyc.primitives.registry import (
-    c_method_call_ops, CFunctionDescription, c_function_ops,
-    c_binary_ops, c_unary_ops, ERR_NEG_INT
+    method_call_ops, CFunctionDescription, function_ops,
+    binary_ops, unary_ops, ERR_NEG_INT
 )
 from mypyc.primitives.list_ops import (
     list_extend_op, new_list_op
@@ -542,7 +542,7 @@ def binary_op(self,
                 '&', '&=', '|', '|=', '^', '^='):
             return self.bool_bitwise_op(lreg, rreg, op[0], line)
 
-        call_c_ops_candidates = c_binary_ops.get(op, [])
+        call_c_ops_candidates = binary_ops.get(op, [])
         target = self.matching_call_c(call_c_ops_candidates, [lreg, rreg], line)
         assert target, 'Unsupported binary operation: %s' % op
         return target
@@ -749,7 +749,7 @@ def unary_op(self,
                  line: int) -> Value:
         if (is_bool_rprimitive(lreg.type) or is_bit_rprimitive(lreg.type)) and expr_op == 'not':
             return self.unary_not(lreg, line)
-        call_c_ops_candidates = c_unary_ops.get(expr_op, [])
+        call_c_ops_candidates = unary_ops.get(expr_op, [])
         target = self.matching_call_c(call_c_ops_candidates, [lreg], line)
         assert target, 'Unsupported unary operation: %s' % expr_op
         return target
@@ -813,7 +813,7 @@ def builtin_call(self,
                      args: List[Value],
                      fn_op: str,
                      line: int) -> Value:
-        call_c_ops_candidates = c_function_ops.get(fn_op, [])
+        call_c_ops_candidates = function_ops.get(fn_op, [])
         target = self.matching_call_c(call_c_ops_candidates, args, line)
         assert target, 'Unsupported builtin function: %s' % fn_op
         return target
@@ -1081,7 +1081,7 @@ def translate_special_method_call(self,
 
         Return None if no translation found; otherwise return the target register.
         """
-        call_c_ops_candidates = c_method_call_ops.get(name, [])
+        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)
         return call_c_op

mypyc/primitives/dict_ops.py

@@ -8,7 +8,7 @@
 )
 
 from mypyc.primitives.registry import (
-    c_custom_op, c_method_op, c_function_op, c_binary_op, load_address_op, ERR_NEG_INT
+    custom_op, method_op, function_op, binary_op, load_address_op, ERR_NEG_INT
 )
 
 # Get the 'dict' type object.
@@ -18,23 +18,23 @@
     src='PyDict_Type')
 
 # dict[key]
-dict_get_item_op = c_method_op(
+dict_get_item_op = method_op(
     name='__getitem__',
     arg_types=[dict_rprimitive, object_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_GetItem',
     error_kind=ERR_MAGIC)
 
 # dict[key] = value
-dict_set_item_op = c_method_op(
+dict_set_item_op = method_op(
     name='__setitem__',
     arg_types=[dict_rprimitive, object_rprimitive, object_rprimitive],
     return_type=c_int_rprimitive,
     c_function_name='CPyDict_SetItem',
     error_kind=ERR_NEG_INT)
 
 # key in dict
-c_binary_op(
+binary_op(
     name='in',
     arg_types=[object_rprimitive, dict_rprimitive],
     return_type=c_int_rprimitive,
@@ -44,7 +44,7 @@
     ordering=[1, 0])
 
 # dict1.update(dict2)
-dict_update_op = c_method_op(
+dict_update_op = method_op(
     name='update',
     arg_types=[dict_rprimitive, dict_rprimitive],
     return_type=c_int_rprimitive,
@@ -54,38 +54,38 @@
 
 # Operation used for **value in dict displays.
 # This is mostly like dict.update(obj), but has customized error handling.
-dict_update_in_display_op = c_custom_op(
+dict_update_in_display_op = custom_op(
     arg_types=[dict_rprimitive, dict_rprimitive],
     return_type=c_int_rprimitive,
     c_function_name='CPyDict_UpdateInDisplay',
     error_kind=ERR_NEG_INT)
 
 # dict.update(obj)
-c_method_op(
+method_op(
     name='update',
     arg_types=[dict_rprimitive, object_rprimitive],
     return_type=c_int_rprimitive,
     c_function_name='CPyDict_UpdateFromAny',
     error_kind=ERR_NEG_INT)
 
 # dict.get(key, default)
-c_method_op(
+method_op(
     name='get',
     arg_types=[dict_rprimitive, object_rprimitive, object_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_Get',
     error_kind=ERR_MAGIC)
 
 # dict.get(key)
-c_method_op(
+method_op(
     name='get',
     arg_types=[dict_rprimitive, object_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_GetWithNone',
     error_kind=ERR_MAGIC)
 
 # Construct an empty dictionary.
-dict_new_op = c_custom_op(
+dict_new_op = custom_op(
     arg_types=[],
     return_type=dict_rprimitive,
     c_function_name='PyDict_New',
@@ -94,15 +94,15 @@
 # Construct a dictionary from keys and values.
 # Positional argument is the number of key-value pairs
 # Variable arguments are (key1, value1, ..., keyN, valueN).
-dict_build_op = c_custom_op(
+dict_build_op = custom_op(
     arg_types=[c_pyssize_t_rprimitive],
     return_type=dict_rprimitive,
     c_function_name='CPyDict_Build',
     error_kind=ERR_MAGIC,
     var_arg_type=object_rprimitive)
 
 # Construct a dictionary from another dictionary.
-c_function_op(
+function_op(
     name='builtins.dict',
     arg_types=[dict_rprimitive],
     return_type=dict_rprimitive,
@@ -111,103 +111,103 @@
     priority=2)
 
 # Generic one-argument dict constructor: dict(obj)
-c_function_op(
+function_op(
     name='builtins.dict',
     arg_types=[object_rprimitive],
     return_type=dict_rprimitive,
     c_function_name='CPyDict_FromAny',
     error_kind=ERR_MAGIC)
 
 # dict.keys()
-c_method_op(
+method_op(
     name='keys',
     arg_types=[dict_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_KeysView',
     error_kind=ERR_MAGIC)
 
 # dict.values()
-c_method_op(
+method_op(
     name='values',
     arg_types=[dict_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_ValuesView',
     error_kind=ERR_MAGIC)
 
 # dict.items()
-c_method_op(
+method_op(
     name='items',
     arg_types=[dict_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_ItemsView',
     error_kind=ERR_MAGIC)
 
 # list(dict.keys())
-dict_keys_op = c_custom_op(
+dict_keys_op = custom_op(
     arg_types=[dict_rprimitive],
     return_type=list_rprimitive,
     c_function_name='CPyDict_Keys',
     error_kind=ERR_MAGIC)
 
 # list(dict.values())
-dict_values_op = c_custom_op(
+dict_values_op = custom_op(
     arg_types=[dict_rprimitive],
     return_type=list_rprimitive,
     c_function_name='CPyDict_Values',
     error_kind=ERR_MAGIC)
 
 # list(dict.items())
-dict_items_op = c_custom_op(
+dict_items_op = custom_op(
     arg_types=[dict_rprimitive],
     return_type=list_rprimitive,
     c_function_name='CPyDict_Items',
     error_kind=ERR_MAGIC)
 
 # PyDict_Next() fast iteration
-dict_key_iter_op = c_custom_op(
+dict_key_iter_op = custom_op(
     arg_types=[dict_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_GetKeysIter',
     error_kind=ERR_MAGIC)
 
-dict_value_iter_op = c_custom_op(
+dict_value_iter_op = custom_op(
     arg_types=[dict_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_GetValuesIter',
     error_kind=ERR_MAGIC)
 
-dict_item_iter_op = c_custom_op(
+dict_item_iter_op = custom_op(
     arg_types=[dict_rprimitive],
     return_type=object_rprimitive,
     c_function_name='CPyDict_GetItemsIter',
     error_kind=ERR_MAGIC)
 
-dict_next_key_op = c_custom_op(
+dict_next_key_op = custom_op(
     arg_types=[object_rprimitive, int_rprimitive],
     return_type=dict_next_rtuple_single,
     c_function_name='CPyDict_NextKey',
     error_kind=ERR_NEVER)
 
-dict_next_value_op = c_custom_op(
+dict_next_value_op = custom_op(
     arg_types=[object_rprimitive, int_rprimitive],
     return_type=dict_next_rtuple_single,
     c_function_name='CPyDict_NextValue',
     error_kind=ERR_NEVER)
 
-dict_next_item_op = c_custom_op(
+dict_next_item_op = custom_op(
     arg_types=[object_rprimitive, int_rprimitive],
     return_type=dict_next_rtuple_pair,
     c_function_name='CPyDict_NextItem',
     error_kind=ERR_NEVER)
 
 # check that len(dict) == const during iteration
-dict_check_size_op = c_custom_op(
+dict_check_size_op = custom_op(
     arg_types=[dict_rprimitive, int_rprimitive],
     return_type=bit_rprimitive,
     c_function_name='CPyDict_CheckSize',
     error_kind=ERR_FALSE)
 
-dict_size_op = c_custom_op(
+dict_size_op = custom_op(
     arg_types=[dict_rprimitive],
     return_type=c_pyssize_t_rprimitive,
     c_function_name='PyDict_Size',

mypyc/primitives/exc_ops.py

@@ -2,46 +2,46 @@
 
 from mypyc.ir.ops import ERR_NEVER, ERR_FALSE, ERR_ALWAYS
 from mypyc.ir.rtypes import object_rprimitive, void_rtype, exc_rtuple, bit_rprimitive
-from mypyc.primitives.registry import c_custom_op
+from mypyc.primitives.registry import custom_op
 
 # If the argument is a class, raise an instance of the class. Otherwise, assume
 # that the argument is an exception object, and raise it.
-raise_exception_op = c_custom_op(
+raise_exception_op = custom_op(
     arg_types=[object_rprimitive],
     return_type=void_rtype,
     c_function_name='CPy_Raise',
     error_kind=ERR_ALWAYS)
 
 # Raise StopIteration exception with the specified value (which can be NULL).
-set_stop_iteration_value = c_custom_op(
+set_stop_iteration_value = custom_op(
     arg_types=[object_rprimitive],
     return_type=void_rtype,
     c_function_name='CPyGen_SetStopIterationValue',
     error_kind=ERR_ALWAYS)
 
 # Raise exception with traceback.
 # Arguments are (exception type, exception value, traceback).
-raise_exception_with_tb_op = c_custom_op(
+raise_exception_with_tb_op = custom_op(
     arg_types=[object_rprimitive, object_rprimitive, object_rprimitive],
     return_type=void_rtype,
     c_function_name='CPyErr_SetObjectAndTraceback',
     error_kind=ERR_ALWAYS)
 
 # Reraise the currently raised exception.
-reraise_exception_op = c_custom_op(
+reraise_exception_op = custom_op(
     arg_types=[],
     return_type=void_rtype,
     c_function_name='CPy_Reraise',
     error_kind=ERR_ALWAYS)
 
 # Propagate exception if the CPython error indicator is set (an exception was raised).
-no_err_occurred_op = c_custom_op(
+no_err_occurred_op = custom_op(
     arg_types=[],
     return_type=bit_rprimitive,
     c_function_name='CPy_NoErrOccured',
     error_kind=ERR_FALSE)
 
-err_occurred_op = c_custom_op(
+err_occurred_op = custom_op(
     arg_types=[],
     return_type=object_rprimitive,
     c_function_name='PyErr_Occurred',
@@ -50,7 +50,7 @@
 
 # Keep propagating a raised exception by unconditionally giving an error value.
 # This doesn't actually raise an exception.
-keep_propagating_op = c_custom_op(
+keep_propagating_op = custom_op(
     arg_types=[],
     return_type=bit_rprimitive,
     c_function_name='CPy_KeepPropagating',
@@ -60,36 +60,36 @@
 # handled exception" (by sticking it into sys.exc_info()). Returns the
 # exception that was previously being handled, which must be restored
 # later.
-error_catch_op = c_custom_op(
+error_catch_op = custom_op(
     arg_types=[],
     return_type=exc_rtuple,
     c_function_name='CPy_CatchError',
     error_kind=ERR_NEVER)
 
 # Restore an old "currently handled exception" returned from.
 # error_catch (by sticking it into sys.exc_info())
-restore_exc_info_op = c_custom_op(
+restore_exc_info_op = custom_op(
     arg_types=[exc_rtuple],
     return_type=void_rtype,
     c_function_name='CPy_RestoreExcInfo',
     error_kind=ERR_NEVER)
 
 # Checks whether the exception currently being handled matches a particular type.
-exc_matches_op = c_custom_op(
+exc_matches_op = custom_op(
     arg_types=[object_rprimitive],
     return_type=bit_rprimitive,
     c_function_name='CPy_ExceptionMatches',
     error_kind=ERR_NEVER)
 
 # Get the value of the exception currently being handled.
-get_exc_value_op = c_custom_op(
+get_exc_value_op = custom_op(
     arg_types=[],
     return_type=object_rprimitive,
     c_function_name='CPy_GetExcValue',
     error_kind=ERR_NEVER)
 
 # Get exception info (exception type, exception instance, traceback object).
-get_exc_info_op = c_custom_op(
+get_exc_info_op = custom_op(
     arg_types=[],
     return_type=exc_rtuple,
     c_function_name='CPy_GetExcInfo',