[mypyc] Obsolete several old-style registry functions (#9310)

This PR merges the generic in and op as well as misc builtins.bool op, and 
obsoletes unused old-style registry functions: call_void_emit, call_and_fail_emit, 
call_negative_bool_emit, negative_int_emit, call_negative_magic_emit.

A test for generic in and misc builtins.bool is added.

Author: TH3CHARLie

mypyc/irbuild/ll_builder.py

@@ -623,12 +623,12 @@ def unary_op(self,
                  lreg: Value,
                  expr_op: str,
                  line: int) -> Value:
-        call_c_ops_candidates = c_unary_ops.get(expr_op, [])
-        target = self.matching_call_c(call_c_ops_candidates, [lreg], line)
-        if target:
-            return target
         ops = unary_ops.get(expr_op, [])
         target = self.matching_primitive_op(ops, [lreg], line)
+        if target:
+            return target
+        call_c_ops_candidates = c_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
 
@@ -745,7 +745,7 @@ def add_bool_branch(self, value: Value, true: BasicBlock, false: BasicBlock) ->
                     self.add_bool_branch(remaining, true, false)
                 return
             elif not is_same_type(value.type, bool_rprimitive):
-                value = self.primitive_op(bool_op, [value], value.line)
+                value = self.call_c(bool_op, [value], value.line)
         self.add(Branch(value, true, false, Branch.BOOL_EXPR))
 
     def call_c(self,

mypyc/primitives/generic_ops.py

@@ -12,8 +12,7 @@
 from mypyc.ir.ops import ERR_NEVER, ERR_MAGIC, ERR_NEG_INT
 from mypyc.ir.rtypes import object_rprimitive, int_rprimitive, bool_rprimitive, c_int_rprimitive
 from mypyc.primitives.registry import (
-    binary_op, unary_op, custom_op, call_emit, simple_emit,
-    call_negative_magic_emit, negative_int_emit,
+    binary_op, custom_op, call_emit, simple_emit,
     c_binary_op, c_unary_op, c_method_op, c_function_op, c_custom_op
 )
 
@@ -79,12 +78,15 @@
           emit=simple_emit('{dest} = PyNumber_Power({args[0]}, {args[1]}, Py_None);'),
           priority=0)
 
-binary_op('in',
-          arg_types=[object_rprimitive, object_rprimitive],
-          result_type=bool_rprimitive,
-          error_kind=ERR_MAGIC,
-          emit=negative_int_emit('{dest} = PySequence_Contains({args[1]}, {args[0]});'),
-          priority=0)
+c_binary_op(
+    name='in',
+    arg_types=[object_rprimitive, object_rprimitive],
+    return_type=c_int_rprimitive,
+    c_function_name='PySequence_Contains',
+    error_kind=ERR_NEG_INT,
+    truncated_type=bool_rprimitive,
+    ordering=[1, 0],
+    priority=0)
 
 binary_op('is',
           arg_types=[object_rprimitive, object_rprimitive],
@@ -113,14 +115,14 @@
                error_kind=ERR_MAGIC,
                priority=0)
 
-unary_op(op='not',
-         arg_type=object_rprimitive,
-         result_type=bool_rprimitive,
-         error_kind=ERR_MAGIC,
-         format_str='{dest} = not {args[0]}',
-         emit=call_negative_magic_emit('PyObject_Not'),
-         priority=0)
-
+c_unary_op(
+    name='not',
+    arg_type=object_rprimitive,
+    return_type=c_int_rprimitive,
+    c_function_name='PyObject_Not',
+    error_kind=ERR_NEG_INT,
+    truncated_type=bool_rprimitive,
+    priority=0)
 
 # obj1[obj2]
 c_method_op(name='__getitem__',

mypyc/primitives/misc_ops.py

@@ -7,7 +7,7 @@
 )
 from mypyc.primitives.registry import (
     simple_emit, unary_op, func_op, custom_op, call_emit, name_emit,
-    call_negative_magic_emit, c_function_op, c_custom_op, load_address_op
+    c_function_op, c_custom_op, load_address_op
 )
 
 
@@ -159,12 +159,13 @@
     emit=simple_emit('{dest} = Py_TYPE({args[0]}) == (PyTypeObject *){args[1]};'))
 
 # bool(obj) with unboxed result
-bool_op = func_op(
-    'builtins.bool',
+bool_op = c_function_op(
+    name='builtins.bool',
     arg_types=[object_rprimitive],
-    result_type=bool_rprimitive,
-    error_kind=ERR_MAGIC,
-    emit=call_negative_magic_emit('PyObject_IsTrue'))
+    return_type=c_int_rprimitive,
+    c_function_name='PyObject_IsTrue',
+    error_kind=ERR_NEG_INT,
+    truncated_type=bool_rprimitive)
 
 # slice(start, stop, step)
 new_slice_op = c_function_op(

mypyc/primitives/registry.py

@@ -40,7 +40,7 @@
 from mypyc.ir.ops import (
     OpDescription, EmitterInterface, EmitCallback, StealsDescription, short_name
 )
-from mypyc.ir.rtypes import RType,  bool_rprimitive
+from mypyc.ir.rtypes import RType
 
 CFunctionDescription = NamedTuple(
     'CFunctionDescription',  [('name', str),
@@ -125,45 +125,6 @@ def call_emit(func: str) -> EmitCallback:
     return simple_emit('{dest} = %s({comma_args});' % func)
 
 
-def call_void_emit(func: str) -> EmitCallback:
-    return simple_emit('%s({comma_args});' % func)
-
-
-def call_and_fail_emit(func: str) -> EmitCallback:
-    # This is a hack for our always failing operations like CPy_Raise,
-    # since we want the optimizer to see that it always fails but we
-    # don't have an ERR_ALWAYS yet.
-    # TODO: Have an ERR_ALWAYS.
-    return simple_emit('%s({comma_args}); {dest} = 0;' % func)
-
-
-def call_negative_bool_emit(func: str) -> EmitCallback:
-    """Construct an emit callback that calls a function and checks for negative return.
-
-    The negative return value is converted to a bool (true -> no error).
-    """
-    return simple_emit('{dest} = %s({comma_args}) >= 0;' % func)
-
-
-def negative_int_emit(template: str) -> EmitCallback:
-    """Construct a simple PrimitiveOp emit callback function that checks for -1 return."""
-
-    def emit(emitter: EmitterInterface, args: List[str], dest: str) -> None:
-        temp = emitter.temp_name()
-        emitter.emit_line(template.format(args=args, dest='int %s' % temp,
-                                          comma_args=', '.join(args)))
-        emitter.emit_lines('if (%s < 0)' % temp,
-                           '    %s = %s;' % (dest, emitter.c_error_value(bool_rprimitive)),
-                           'else',
-                           '    %s = %s;' % (dest, temp))
-
-    return emit
-
-
-def call_negative_magic_emit(func: str) -> EmitCallback:
-    return negative_int_emit('{dest} = %s({comma_args});' % func)
-
-
 def binary_op(op: str,
               arg_types: List[RType],
               result_type: RType,

mypyc/test-data/irbuild-basic.test

@@ -207,18 +207,20 @@ def f(x: object, y: object) -> str:
 def f(x, y):
     x, y :: object
     r0, r1 :: str
-    r2 :: bool
-    r3 :: str
+    r2 :: int32
+    r3 :: bool
+    r4 :: str
 L0:
     r1 = PyObject_Str(x)
-    r2 = bool r1 :: object
-    if r2 goto L1 else goto L2 :: bool
+    r2 = PyObject_IsTrue(r1)
+    r3 = truncate r2: int32 to builtins.bool
+    if r3 goto L1 else goto L2 :: bool
 L1:
     r0 = r1
     goto L3
 L2:
-    r3 = PyObject_Str(y)
-    r0 = r3
+    r4 = PyObject_Str(y)
+    r0 = r4
 L3:
     return r0
 
@@ -288,18 +290,20 @@ def f(x: object, y: object) -> str:
 def f(x, y):
     x, y :: object
     r0, r1 :: str
-    r2 :: bool
-    r3 :: str
+    r2 :: int32
+    r3 :: bool
+    r4 :: str
 L0:
     r1 = PyObject_Str(x)
-    r2 = bool r1 :: object
-    if r2 goto L2 else goto L1 :: bool
+    r2 = PyObject_IsTrue(r1)
+    r3 = truncate r2: int32 to builtins.bool
+    if r3 goto L2 else goto L1 :: bool
 L1:
     r0 = r1
     goto L3
 L2:
-    r3 = PyObject_Str(y)
-    r0 = r3
+    r4 = PyObject_Str(y)
+    r0 = r4
 L3:
     return r0
 
@@ -1315,10 +1319,12 @@ def lst(x: List[int]) -> int:
 [out]
 def obj(x):
     x :: object
-    r0 :: bool
+    r0 :: int32
+    r1 :: bool
 L0:
-    r0 = bool x :: object
-    if r0 goto L1 else goto L2 :: bool
+    r0 = PyObject_IsTrue(x)
+    r1 = truncate r0: int32 to builtins.bool
+    if r1 goto L1 else goto L2 :: bool
 L1:
     return 2
 L2:
@@ -1444,15 +1450,17 @@ def opt_o(x):
     r0 :: object
     r1 :: bool
     r2 :: object
-    r3 :: bool
+    r3 :: int32
+    r4 :: bool
 L0:
     r0 = builtins.None :: object
     r1 = x is not r0
     if r1 goto L1 else goto L3 :: bool
 L1:
     r2 = cast(object, x)
-    r3 = bool r2 :: object
-    if r3 goto L2 else goto L3 :: bool
+    r3 = PyObject_IsTrue(r2)
+    r4 = truncate r3: int32 to builtins.bool
+    if r4 goto L2 else goto L3 :: bool
 L2:
     return 2
 L3:
@@ -2740,17 +2748,20 @@ L0:
 def A.__ne__(self, rhs):
     self :: __main__.A
     rhs, r0, r1 :: object
-    r2, r3 :: bool
-    r4 :: object
+    r2 :: bool
+    r3 :: int32
+    r4 :: bool
+    r5 :: object
 L0:
     r0 = self.__eq__(rhs)
     r1 = load_address _Py_NotImplementedStruct
     r2 = r0 is r1
     if r2 goto L2 else goto L1 :: bool
 L1:
-    r3 = not r0
-    r4 = box(bool, r3)
-    return r4
+    r3 = PyObject_Not(r0)
+    r4 = truncate r3: int32 to builtins.bool
+    r5 = box(bool, r4)
+    return r5
 L2:
     return r1
 
@@ -3535,3 +3546,16 @@ def h(x):
 L0:
     r0 = PySequence_List(x)
     return r0
+
+[case testBoolFunction]
+def f(x: object) -> bool:
+    return bool(x)
+[out]
+def f(x):
+    x :: object
+    r0 :: int32
+    r1 :: bool
+L0:
+    r0 = PyObject_IsTrue(x)
+    r1 = truncate r0: int32 to builtins.bool
+    return r1

mypyc/test-data/irbuild-classes.test

@@ -795,17 +795,20 @@ L0:
 def Base.__ne__(self, rhs):
     self :: __main__.Base
     rhs, r0, r1 :: object
-    r2, r3 :: bool
-    r4 :: object
+    r2 :: bool
+    r3 :: int32
+    r4 :: bool
+    r5 :: object
 L0:
     r0 = self.__eq__(rhs)
     r1 = load_address _Py_NotImplementedStruct
     r2 = r0 is r1
     if r2 goto L2 else goto L1 :: bool
 L1:
-    r3 = not r0
-    r4 = box(bool, r3)
-    return r4
+    r3 = PyObject_Not(r0)
+    r4 = truncate r3: int32 to builtins.bool
+    r5 = box(bool, r4)
+    return r5
 L2:
     return r1
 def Derived.__eq__(self, other):
@@ -910,17 +913,20 @@ L0:
 def Derived.__ne__(self, rhs):
     self :: __main__.Derived
     rhs, r0, r1 :: object
-    r2, r3 :: bool
-    r4 :: object
+    r2 :: bool
+    r3 :: int32
+    r4 :: bool
+    r5 :: object
 L0:
     r0 = self.__eq__(rhs)
     r1 = load_address _Py_NotImplementedStruct
     r2 = r0 is r1
     if r2 goto L2 else goto L1 :: bool
 L1:
-    r3 = not r0
-    r4 = box(bool, r3)
-    return r4
+    r3 = PyObject_Not(r0)
+    r4 = truncate r3: int32 to builtins.bool
+    r5 = box(bool, r4)
+    return r5
 L2:
     return r1
 

mypyc/test-data/irbuild-lists.test

@@ -194,3 +194,20 @@ L0:
     r5 = box(short_int, 6)
     r6 = PyList_Append(r2, r5)
     return r2
+
+[case testListIn]
+from typing import List
+def f(x: List[int], y: int) -> bool:
+    return y in x
+[out]
+def f(x, y):
+    x :: list
+    y :: int
+    r0 :: object
+    r1 :: int32
+    r2 :: bool
+L0:
+    r0 = box(int, y)
+    r1 = PySequence_Contains(x, r0)
+    r2 = truncate r1: int32 to builtins.bool
+    return r2

mypyc/test-data/irbuild-optional.test

@@ -92,15 +92,17 @@ def f(x):
     r0 :: object
     r1 :: bool
     r2 :: __main__.A
-    r3 :: bool
+    r3 :: int32
+    r4 :: bool
 L0:
     r0 = builtins.None :: object
     r1 = x is not r0
     if r1 goto L1 else goto L3 :: bool
 L1:
     r2 = cast(__main__.A, x)
-    r3 = bool r2 :: object
-    if r3 goto L2 else goto L3 :: bool
+    r3 = PyObject_IsTrue(r2)
+    r4 = truncate r3: int32 to builtins.bool
+    if r4 goto L2 else goto L3 :: bool
 L2:
     return 2
 L3: