Learn built-in UDF return types by typing alone, defer the compiles - #612

First touch of a built-in UDF binop compiled it for all 11 to 13 sample
dtypes, and threw nearly all of that away. The compiles existed only to
read back a return type per dtype for op.types; a program that then used
one dtype paid for the rest.

Get the return types from numba's typing pipeline alone (run_frontend
plus type_inference_stage, no lowering), apply the existing downcast
heuristic over the full result set, and defer each dtype's lowering,
cfunc wrapper, and GrB_BinaryOp_new to the first op[dtype] access via
_build_deferred/_materialize_deferred on OpBase. op.types is unchanged:
dumped for all five ops before and after and diffed, identical.

Numba exposes no public way to ask for a return type without also
compiling for it, so _infer_ret_types_typing_only reaches into
numba.core. We support numba back to 0.57 and this was verified against
0.66.0 only, so the helper returns None on a failed import or any
surprise from the call and _build falls back to the eager loop. Verified
by forcing _HAS_TYPING_ONLY = False: the suite passes with only
test_builtin_udf_types_precede_compilation failing, which is the intended
signal. A numba that moves these internals turns into a red test rather
than a silent return to the old cost.

Only the built-in UDFs take this path, keyed off the same flag that marks
them cacheable. Typing is more permissive than lowering, so a user
function whose dtype types but fails to lower would be wrongly advertised
in .types; register_new and register_anonymous stay eager and keep
validating lowerability per dtype. Semiring construction iterates
_typed_ops directly, so it materializes a deferred multiplier first.

Measured here, fresh process, warm numba cache, medians of 3, load
average 4 to 5 on a shared machine so these are indicative and the
before-numbers are the noisier half. First-touch floordiv: 474 -> 248 ms.
First-touch of all five: 753 -> 289 ms. The deferred per-dtype build does
not vanish, it moves to first use of that dtype.

This does not speed up a program that ends up using every dtype; it stops
programs that use one or two from paying for all of them. It does not
touch UDT auto-lift, which was already compiled on demand.

_finalize_typed_binaryop keeps error_model="numpy" on the cfunc, as the
call site it was extracted from had it and every other cfunc in the
package sets it. No test here distinguishes it: with it removed from the
cfunc, from the njit, or from both, and with the numba cache cleared,
integer floordiv by zero still returns numpy's answer.

Deferral surfaced one more direct consumer of _typed_ops: the typed
commutes_to properties asked whether the PARTNER op had already compiled
this dtype, so in a fresh process floordiv[INT64].commutes_to answered
None until rfloordiv happened to be built, and the answer depended on
access order. The membership test now consults .types, whose keyset is
identical to _typed_ops once materialized, letting getitem drive the
deferred build. test_deferred_commutes_to pins it in a subprocess, where
access order is controlled.

Added in the 2026-10-20 coverage round

Three behavior fixes, each with before and after in its commit message (main
too). Numba types some ops it has no lowering for, such as > on complex
values, which max uses, and then raises a bare NotImplementedError from
lowering:

• The per-dtype build loops of UnaryOp, BinaryOp, IndexUnaryOp (and so
  SelectOp) and IndexBinaryOp caught only TypingError, so the whole
  registration failed. BinaryOp.register_anonymous(lambda x, y: max(x, y))
  raised NotImplementedError; it now gives an op for BOOL, the ints and the
  floats, without FC32 or FC64.
• With is_udt=True, the same error escaped op["FC64"] and "FC64" in op.
  The first now raises the usual UdfParseError ("does not work with"), and
  in answers False.
• Numba before 0.60 raises a LoweringError from lowering instead, and 0.58
  and 0.59 first warn NumbaPendingDeprecationWarning, which -W error (as in
  our tests) raises in its place. CI draws Numba 0.57 to 0.68, so on those
  versions the registration above still failed. The four loops now share
  _compile_for_dtype, which skips a dtype on TypingError,
  NotImplementedError, or a LoweringError raised from a NotImplementedError,
  and raises any other error. The warning is ignored only while Numba
  captures errors "old_style" (a MAINT note says to drop that once Numba
  0.61 is the minimum), and the UdfParseError of an is_udt op names the
  missing lowering ("No definition for lowering ...") on every version.

_{Stack created with GitHub Stacks CLI • Give Feedback 💬}