Overload not properly producing omitted types

Reporting a bug

• I have tried using the latest released version of Numba (most recent is visible in the change log (https://github.com/numba/numba/blob/main/CHANGE_LOG).
• I have included a self contained code sample to reproduce the problem. i.e. it’s possible to run as ‘python bug.py’.

It seems like the compilation path for overloads doesn’t properly do argument folding and therefore doesn’t produce omitted types. Here is a reproducer:

from numba.extending import overload
from numba import njit

def foo(a, b=1):
	pass

@overload(foo)
def foo_overload(a, b=1):
	print(a, b)
	def foo_impl(a, b=1):
		return a + b
        return foo_impl


@njit
def g(a):
	return foo(a)

g(100)

On master this outputs:

int64 1

So b is a python literal 1, not an omitted type.

[njriasan]

This seems to be possible to convert to a literal type if you reuse the argument folding used by dispatchers. Here is a diff that outputs int64 omitted(default=1)

diff --git a/numba/core/typing/templates.py b/numba/core/typing/templates.py
index 222be0c61..6ddd61a0d 100644
--- a/numba/core/typing/templates.py
+++ b/numba/core/typing/templates.py
@@ -790,7 +790,21 @@ class _OverloadFunctionTemplate(AbstractTemplate):
             # problems
             raise TypingError(str(e)) from e
         else:
-            ovf_result = self._overload_func(*args, **kws)
+            def normal_handler(index, param, value):
+                return value
+
+            def default_handler(index, param, default):
+                return types.Omitted(default)
+
+            def stararg_handler(index, param, values):
+                return types.StarArgTuple(values)
+
+            pysig = utils.pysignature(self._overload_func)
+            args = fold_arguments(pysig, args, kws,
+                                normal_handler,
+                                default_handler,
+                                stararg_handler)
+            ovf_result = self._overload_func(*args)
 
         if ovf_result is None:
             # No implementation => fail typing

Of course the python signature should probably be computed only once. Is there any reason this isn’t an omitted type right now? It seems like if there was ever a default value that was unhashable then it wouldn’t be possible to cache the overload.

[stuartarchibald]

@njriasan as noted in the Numba meeting, the follow doesn’t actually solve any of this but might help some use cases:

from numba.extending import overload, types
from numba import njit

def foo(a, b=1):
        pass

@overload(foo, strict=False)
def foo_overload(a, b=types.Omitted(types.literal(1))):
    print(a, b)
    def foo_impl(a, b=1):
            return a + b
    return foo_impl


@njit
def g(a):
        return foo(a)

g(100)