Remove references to numba.experimental features (mutable structref, jitclass, first-class function types) (#459)

Author: atmnp

numba_cuda/numba/cuda/lowering.py

@@ -1027,9 +1027,6 @@ def lower_call(self, resty, expr):
         elif isinstance(fnty, types.RecursiveCall):
             res = self._lower_call_RecursiveCall(fnty, expr, signature)
 
-        elif isinstance(fnty, types.FunctionType):
-            res = self._lower_call_FunctionType(fnty, expr, signature)
-
         else:
             res = self._lower_call_normal(fnty, expr, signature)
 
@@ -1227,136 +1224,6 @@ def _lower_call_RecursiveCall(self, fnty, expr, signature):
             )
         return res
 
-    def _lower_call_FunctionType(self, fnty, expr, signature):
-        self.debug_print("# calling first-class function type")
-        sig = types.unliteral(signature)
-        if not fnty.check_signature(signature):
-            # value dependent polymorphism?
-            raise UnsupportedError(
-                f"mismatch of function types:"
-                f" expected {fnty} but got {types.FunctionType(sig)}"
-            )
-        argvals = self.fold_call_args(
-            fnty,
-            sig,
-            expr.args,
-            expr.vararg,
-            expr.kws,
-        )
-        return self.__call_first_class_function_pointer(
-            fnty.ftype,
-            expr.func.name,
-            sig,
-            argvals,
-        )
-
-    def __call_first_class_function_pointer(self, ftype, fname, sig, argvals):
-        """
-        Calls a first-class function pointer.
-
-        This function is responsible for calling a first-class function pointer,
-        which can either be a JIT-compiled function or a Python function. It
-        determines if a JIT address is available, and if so, calls the function
-        using the JIT address. Otherwise, it calls the function using a function
-        pointer obtained from the `__get_first_class_function_pointer` method.
-
-        Args:
-            ftype: The type of the function.
-            fname: The name of the function.
-            sig: The signature of the function.
-            argvals: The argument values to pass to the function.
-
-        Returns:
-            The result of calling the function.
-        """
-        context = self.context
-        builder = self.builder
-        # Determine if jit address is available
-        fstruct = self.loadvar(fname)
-        struct = cgutils.create_struct_proxy(self.typeof(fname))(
-            context, builder, value=fstruct
-        )
-        jit_addr = struct.jit_addr
-        jit_addr.name = f"jit_addr_of_{fname}"
-
-        ctx = context
-        res_slot = cgutils.alloca_once(
-            builder, ctx.get_value_type(sig.return_type)
-        )
-
-        if_jit_addr_is_null = builder.if_else(
-            cgutils.is_null(builder, jit_addr), likely=False
-        )
-        with if_jit_addr_is_null as (then, orelse):
-            with then:
-                func_ptr = self.__get_first_class_function_pointer(
-                    ftype, fname, sig
-                )
-                res = builder.call(func_ptr, argvals)
-                builder.store(res, res_slot)
-
-            with orelse:
-                llty = ctx.call_conv.get_function_type(
-                    sig.return_type, sig.args
-                ).as_pointer()
-                func_ptr = builder.bitcast(jit_addr, llty)
-                # call
-                status, res = ctx.call_conv.call_function(
-                    builder, func_ptr, sig.return_type, sig.args, argvals
-                )
-                with cgutils.if_unlikely(builder, status.is_error):
-                    context.call_conv.return_status_propagate(builder, status)
-                builder.store(res, res_slot)
-        return builder.load(res_slot)
-
-    def __get_first_class_function_pointer(self, ftype, fname, sig):
-        from numba.experimental.function_type import lower_get_wrapper_address
-
-        llty = self.context.get_value_type(ftype)
-        fstruct = self.loadvar(fname)
-        addr = self.builder.extract_value(
-            fstruct, 0, name="addr_of_%s" % (fname)
-        )
-
-        fptr = cgutils.alloca_once(
-            self.builder, llty, name="fptr_of_%s" % (fname)
-        )
-        with self.builder.if_else(
-            cgutils.is_null(self.builder, addr), likely=False
-        ) as (then, orelse):
-            with then:
-                self.init_pyapi()
-                # Acquire the GIL
-                gil_state = self.pyapi.gil_ensure()
-                pyaddr = self.builder.extract_value(
-                    fstruct, 1, name="pyaddr_of_%s" % (fname)
-                )
-                # try to recover the function address, see
-                # test_zero_address BadToGood example in
-                # test_function_type.py
-                addr1 = lower_get_wrapper_address(
-                    self.context,
-                    self.builder,
-                    pyaddr,
-                    sig,
-                    failure_mode="ignore",
-                )
-                with self.builder.if_then(
-                    cgutils.is_null(self.builder, addr1), likely=False
-                ):
-                    self.return_exception(
-                        RuntimeError,
-                        exc_args=(f"{ftype} function address is null",),
-                        loc=self.loc,
-                    )
-                addr2 = self.pyapi.long_as_voidptr(addr1)
-                self.builder.store(self.builder.bitcast(addr2, llty), fptr)
-                self.pyapi.decref(addr1)
-                self.pyapi.gil_release(gil_state)
-            with orelse:
-                self.builder.store(self.builder.bitcast(addr, llty), fptr)
-        return self.builder.load(fptr)
-
     def _lower_call_normal(self, fnty, expr, signature):
         # Normal function resolution
         self.debug_print("# calling normal function: {0}".format(fnty))

numba_cuda/numba/cuda/tests/cudapy/test_ir_utils.py

@@ -2,8 +2,6 @@
 # SPDX-License-Identifier: BSD-2-Clause
 
 from numba.cuda.testing import CUDATestCase
-import numba
-from numba.core.registry import cpu_target
 from numba.cuda.core.compiler import CompilerBase
 from numba.cuda.flags import Flags
 from numba.cuda.core.compiler_machinery import PassManager
@@ -16,10 +14,8 @@
     FixupArgs,
     IRProcessing,
 )
-from numba.experimental import jitclass
 from numba.cuda.core.typed_passes import (
     NopythonTypeInference,
-    type_inference_stage,
     DeadCodeElimination,
 )
 from numba.cuda.testing import skip_on_cudasim
@@ -29,41 +25,11 @@
 GLOBAL_B = 11
 
 
-@jitclass([("val", numba.core.types.List(numba.intp))])
-class Dummy(object):
-    def __init__(self, val):
-        self.val = val
-
-
 class TestIrUtils(CUDATestCase):
     """
     Tests ir handling utility functions like find_callname.
     """
 
-    @skip_on_cudasim("Skipping ir utils tests on CUDA simulator")
-    def test_obj_func_match(self):
-        """Test matching of an object method (other than Array see #3449)"""
-
-        def test_func():
-            d = Dummy([1])
-            d.val.append(2)
-
-        test_ir = compiler.run_frontend(test_func)
-        typingctx = cpu_target.typing_context
-        targetctx = cpu_target.target_context
-        typing_res = type_inference_stage(
-            typingctx, targetctx, test_ir, (), None
-        )
-        matched_call = ir_utils.find_callname(
-            test_ir, test_ir.blocks[0].body[7].value, typing_res.typemap
-        )
-        self.assertTrue(
-            isinstance(matched_call, tuple)
-            and len(matched_call) == 2
-            and matched_call[0] == "append"
-        )
-
-    @skip_on_cudasim("Skipping ir utils tests on CUDA simulator")
     def test_dead_code_elimination(self):
         class Tester(CompilerBase):
             @classmethod

numba_cuda/numba/cuda/tests/nocuda/test_import.py

@@ -40,7 +40,6 @@ def test_no_impl_import(self):
             "numba.np.npyimpl",
             "numba.typed.typeddict",
             "numba.typed.typedlist",
-            "numba.experimental.jitclass.base",
         )
 
         code = "import sys; from numba import cuda; print(list(sys.modules))"

numba_cuda/numba/cuda/utils.py

@@ -32,9 +32,9 @@
     MACHINE_BITS,  # noqa: F401
     DEVELOPER_MODE,
 )  # noqa: F401
-from numba.core import types, config
+from numba.core import config
 
-from collections.abc import Mapping, Sequence, MutableSet, MutableMapping
+from collections.abc import Mapping, MutableSet, MutableMapping
 
 # Python version in (major, minor) tuple
 PYVERSION = sys.version_info[:2]
@@ -575,115 +575,6 @@ def get_nargs_range(pyfunc):
     return min_nargs, max_nargs
 
 
-def unify_function_types(numba_types):
-    """Return a normalized tuple of Numba function types so that
-
-        Tuple(numba_types)
-
-    becomes
-
-        UniTuple(dtype=<unified function type>, count=len(numba_types))
-
-    If the above transformation would be incorrect, return the
-    original input as given. For instance, if the input tuple contains
-    types that are not function or dispatcher type, the transformation
-    is considered incorrect.
-    """
-    dtype = unified_function_type(numba_types)
-    if dtype is None:
-        return numba_types
-    return (dtype,) * len(numba_types)
-
-
-def unified_function_type(numba_types, require_precise=True):
-    """Returns a unified Numba function type if possible.
-
-    Parameters
-    ----------
-    numba_types : Sequence of numba Type instances.
-    require_precise : bool
-      If True, the returned Numba function type must be precise.
-
-    Returns
-    -------
-    typ : {numba.core.types.Type, None}
-      A unified Numba function type. Or ``None`` when the Numba types
-      cannot be unified, e.g. when the ``numba_types`` contains at
-      least two different Numba function type instances.
-
-    If ``numba_types`` contains a Numba dispatcher type, the unified
-    Numba function type will be an imprecise ``UndefinedFunctionType``
-    instance, or None when ``require_precise=True`` is specified.
-
-    Specifying ``require_precise=False`` enables unifying imprecise
-    Numba dispatcher instances when used in tuples or if-then branches
-    when the precise Numba function cannot be determined on the first
-    occurrence that is not a call expression.
-    """
-    from numba.core.errors import NumbaExperimentalFeatureWarning
-
-    if not (
-        isinstance(numba_types, Sequence)
-        and len(numba_types) > 0
-        and isinstance(numba_types[0], (types.Dispatcher, types.FunctionType))
-    ):
-        return
-
-    warnings.warn(
-        "First-class function type feature is experimental",
-        category=NumbaExperimentalFeatureWarning,
-    )
-
-    mnargs, mxargs = None, None
-    dispatchers = set()
-    function = None
-    undefined_function = None
-
-    for t in numba_types:
-        if isinstance(t, types.Dispatcher):
-            mnargs1, mxargs1 = get_nargs_range(t.dispatcher.py_func)
-            if mnargs is None:
-                mnargs, mxargs = mnargs1, mxargs1
-            elif not (mnargs, mxargs) == (mnargs1, mxargs1):
-                return
-            dispatchers.add(t.dispatcher)
-            t = t.dispatcher.get_function_type()
-            if t is None:
-                continue
-        if isinstance(t, types.FunctionType):
-            if mnargs is None:
-                mnargs = mxargs = t.nargs
-            elif not (mnargs == mxargs == t.nargs):
-                return
-            if isinstance(t, types.UndefinedFunctionType):
-                if undefined_function is None:
-                    undefined_function = t
-                else:
-                    # Refuse to unify using function type
-                    return
-                dispatchers.update(t.dispatchers)
-            else:
-                if function is None:
-                    function = t
-                else:
-                    assert function == t
-        else:
-            return
-    if require_precise and (function is None or undefined_function is not None):
-        return
-    if function is not None:
-        if undefined_function is not None:
-            assert function.nargs == undefined_function.nargs
-            function = undefined_function
-    elif undefined_function is not None:
-        undefined_function.dispatchers.update(dispatchers)
-        function = undefined_function
-    else:
-        function = types.UndefinedFunctionType(mnargs, dispatchers)
-
-    return function
-
-
 class _RedirectSubpackage(ModuleType):
     """Redirect a subpackage to a subpackage.