bunch of sporadic import fixes, cleanup soon

Author: atmnp

numba_cuda/numba/cuda/core/config.py

@@ -643,7 +643,7 @@ def reload_config():
 
 # use numba.core.config if available, otherwise use numba.cuda.core.config
 try:
-    import numba.core.config as _config  # compat-ignore
+    import numba.core.config as _config
 
     sys.modules[__name__] = _config
 except ImportError:

numba_cuda/numba/cuda/core/entrypoints.py

@@ -17,7 +17,7 @@ def init_all():
     If extensions have already been initialized, this function does nothing.
     """
     if _HAS_NUMBA:
-        from numba.core import entrypoints  # compat-ignore
+        from numba.core import entrypoints
 
         entrypoints.init_all()
 

numba_cuda/numba/cuda/core/inline_closurecall.py

@@ -5,6 +5,7 @@
 import copy
 import ctypes
 import numba.cuda.core.analysis
+from numba.cuda import _HAS_NUMBA
 from numba.cuda import types, config, cgutils
 from numba.cuda.core import ir
 from numba.cuda.core import errors
@@ -235,13 +236,11 @@ def check_reduce_func(func_ir, func_var):
                             analysis"
         )
     if isinstance(reduce_func, (ir.FreeVar, ir.Global)):
-        try:
+        if _HAS_NUMBA:
             from numba.core.registry import CPUDispatcher
 
             if not isinstance(reduce_func.value, CPUDispatcher):
                 raise ValueError("Invalid reduction function")
-        except ImportError:
-            pass
 
         # pull out the python function for inlining
         reduce_func = reduce_func.value.py_func
@@ -1043,17 +1042,6 @@ def codegen(context, builder, sig, args):
             count_const = intp_t(tuplety.count)
             return impl_ret_untracked(context, builder, intp_t, count_const)
 
-        return signature(types.intp, val), codegen
-    elif isinstance(val, types.ListTypeIteratorType):
-
-        def codegen(context, builder, sig, args):
-            (value,) = args
-            intp_t = context.get_value_type(types.intp)
-            from numba.typed.listobject import ListIterInstance
-
-            iterobj = ListIterInstance(context, builder, sig.args[0], value)
-            return impl_ret_untracked(context, builder, intp_t, iterobj.size)
-
         return signature(types.intp, val), codegen
     else:
         msg = (

numba_cuda/numba/cuda/core/ir.py

@@ -1,7 +1,6 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 
-import numba
 from collections import defaultdict
 import copy
 import itertools
@@ -15,6 +14,10 @@
 from functools import total_ordering
 from io import StringIO
 
+from numba.cuda import _HAS_NUMBA
+
+if _HAS_NUMBA:
+    import numba
 from numba.cuda.core import errors
 from numba.cuda.core import config
 from numba.cuda.utils import UNARY_BUILTINS_TO_OPERATORS, OPERATORS_TO_BUILTINS

numba_cuda/numba/cuda/core/ir_utils.py

@@ -10,6 +10,7 @@
 import warnings
 
 import numba.cuda
+from numba.cuda import _HAS_NUMBA
 from numba.cuda import types
 from numba.cuda.core import ir
 from numba.cuda import typing
@@ -829,16 +830,14 @@ def has_no_side_effect(rhs, lives, call_table):
         ):
             return True
 
-        try:
+        if _HAS_NUMBA:
             from numba.core.registry import CPUDispatcher
             from numba.cuda.np.linalg import dot_3_mv_check_args
 
             if isinstance(call_list[0], CPUDispatcher):
                 py_func = call_list[0].py_func
                 if py_func == dot_3_mv_check_args:
                     return True
-        except ImportError:
-            pass
 
         for f in remove_call_handlers:
             if f(rhs, lives, call_list):

numba_cuda/numba/cuda/core/sigutils.py

@@ -4,7 +4,7 @@
 from numba.cuda import types, typing, _HAS_NUMBA
 
 if _HAS_NUMBA:
-    from numba.core.typing import Signature as CoreSignature  # compat-ignore
+    from numba.core.typing import Signature as CoreSignature
 
 
 def is_signature(sig):

numba_cuda/numba/cuda/core/targetconfig.py

@@ -12,6 +12,7 @@
 
 from types import MappingProxyType
 from numba.cuda import utils
+from numba.cuda import _HAS_NUMBA
 
 
 class Option:
@@ -48,9 +49,9 @@ def doc(self):
         return self._doc
 
 
-try:
+if _HAS_NUMBA:
     from numba.core.targetconfig import ConfigStack, _FlagsStack
-except ImportError:
+else:
 
     class _FlagsStack(utils.ThreadLocalStack, stack_name="flags"):
         pass

numba_cuda/numba/cuda/extending.py

@@ -219,12 +219,12 @@ def decorate(overload_func):
         # For generic/CPU targets, also register in numba.core registry
         if target in ("generic", "cpu"):
             try:
-                from numba.core.typing.templates import (  # compat-ignore
-                    make_overload_template as core_make_overload_template,  # compat-ignore
-                    infer as core_infer,  # compat-ignore
-                    infer_global as core_infer_global,  # compat-ignore
-                )  # compat-ignore
-                from numba.core import types as core_types  # compat-ignore
+                from numba.core.typing.templates import (
+                    make_overload_template as core_make_overload_template,
+                    infer as core_infer,
+                    infer_global as core_infer_global,
+                )
+                from numba.core import types as core_types
 
                 core_template = core_make_overload_template(
                     func,
@@ -310,10 +310,10 @@ def decorate(overload_func):
         # For generic/CPU targets, also register in numba.core registry
         if target in ("generic", "cpu"):
             try:
-                from numba.core.typing.templates import (  # compat-ignore
-                    make_overload_attribute_template as core_make_overload_attribute_template,  # compat-ignore
-                    infer_getattr as core_infer_getattr,  # compat-ignore
-                )  # compat-ignore
+                from numba.core.typing.templates import (
+                    make_overload_attribute_template as core_make_overload_attribute_template,
+                    infer_getattr as core_infer_getattr,
+                )
 
                 core_template = core_make_overload_attribute_template(
                     typ, attr, overload_func, **kwargs
@@ -348,10 +348,10 @@ def decorate(overload_func):
         target = kwargs.get("target", "cuda")
         if target in ("generic", "cpu"):
             try:
-                from numba.core.typing.templates import (  # compat-ignore
-                    make_overload_method_template as core_make_overload_method_template,  # compat-ignore
-                    infer_getattr as core_infer_getattr,  # compat-ignore
-                )  # compat-ignore
+                from numba.core.typing.templates import (
+                    make_overload_method_template as core_make_overload_method_template,
+                    infer_getattr as core_infer_getattr,
+                )
 
                 copied_kwargs2 = kwargs.copy()
                 core_template = core_make_overload_method_template(

numba_cuda/numba/cuda/lowering.py

@@ -1,14 +1,14 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 
-import numba
 from collections import namedtuple, defaultdict
 import operator
 import warnings
 from functools import partial
 
 from llvmlite import ir as llvm_ir
 
+from numba.cuda import _HAS_NUMBA
 from numba.cuda.core import ir
 from numba.cuda import debuginfo, cgutils, utils, typing, types
 from numba.cuda.core import (
@@ -1880,7 +1880,14 @@ def _lit_or_omitted(value):
     """Returns a Literal instance if the type of value is supported;
     otherwise, return `Omitted(value)`.
     """
+    excepts = LiteralTypingError
+    if _HAS_NUMBA:
+        from numba.core.errors import (
+            LiteralTypingError as CoreLiteralTypingError,
+        )
+
+        excepts = (LiteralTypingError, CoreLiteralTypingError)
     try:
         return types.literal(value)
-    except (LiteralTypingError, numba.core.errors.LiteralTypingError):
+    except excepts:
         return types.Omitted(value)

numba_cuda/numba/cuda/misc/mergesort.py

@@ -23,30 +23,24 @@
 )
 
 
-def make_mergesort_impl(wrap, lt=None, is_argsort=False):
-    kwargs_lite = dict(no_cpython_wrapper=True, _nrt=False)
-
+def make_mergesort_impl(lt=None, is_argsort=False):
     # The less than
     if lt is None:
 
-        @wrap(**kwargs_lite)
         def lt(a, b):
             return a < b
     else:
-        lt = wrap(**kwargs_lite)(lt)
+        lt = lt
 
     if is_argsort:
 
-        @wrap(**kwargs_lite)
         def lessthan(a, b, vals):
             return lt(vals[a], vals[b])
     else:
 
-        @wrap(**kwargs_lite)
         def lessthan(a, b, vals):
             return lt(a, b)
 
-    @wrap(**kwargs_lite)
     def argmergesort_inner(arr, vals, ws):
         """The actual mergesort function
 
@@ -108,14 +102,12 @@ def argmergesort_inner(arr, vals, ws):
 
     # The top-level entry points
 
-    @wrap(no_cpython_wrapper=True)
     def mergesort(arr):
         "Inplace"
         ws = np.empty(arr.size // 2, dtype=arr.dtype)
         argmergesort_inner(arr, None, ws)
         return arr
 
-    @wrap(no_cpython_wrapper=True)
     def argmergesort(arr):
         "Out-of-place"
         idxs = np.arange(arr.size)
@@ -129,8 +121,4 @@ def argmergesort(arr):
 
 
 def make_jit_mergesort(*args, **kwargs):
-    from numba import njit
-
-    # NOTE: wrap with njit to allow recursion
-    #       because @register_jitable => @overload doesn't support recursion
-    return make_mergesort_impl(njit, *args, **kwargs)
+    return make_mergesort_impl(*args, **kwargs)