fixup! feat(core.utils): use is-not-None gate for driver-linker unsupported fields

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -219,9 +219,12 @@ def _linker_option_fingerprint(options: ProgramOptions) -> list[bytes]:
     return [f"{name}={getattr(options, name, None)!r}".encode() for name in _LINKER_RELEVANT_FIELDS]
 
 
-# LinkerOptions fields that the cuLink (driver) backend rejects outright
-# (_linker.pyx _prepare_driver_options). nvJitLink accepts all of them.
-_DRIVER_LINKER_UNSUPPORTED_FIELDS = ("time", "ptxas_options", "split_compile", "split_compile_extended")
+# ProgramOptions fields that map to LinkerOptions fields the cuLink (driver)
+# backend rejects outright (see _prepare_driver_options in _linker.pyx).
+# ``split_compile_extended`` exists on LinkerOptions but is not exposed via
+# ProgramOptions / _translate_program_options, so it cannot reach the driver
+# linker from the cache path and is omitted here.
+_DRIVER_LINKER_UNSUPPORTED_FIELDS = ("time", "ptxas_options", "split_compile")
 
 
 def _driver_version() -> int:
@@ -424,7 +427,13 @@ def make_program_cache_key(
         except Exception:
             use_driver_linker = None
         if use_driver_linker is True:
-            unsupported = [name for name in _DRIVER_LINKER_UNSUPPORTED_FIELDS if _option_is_set(options, name)]
+            # Mirror ``_prepare_driver_options``'s exact gate: the driver
+            # linker checks ``is not None`` for these fields, so ``time=False``
+            # or ``ptxas_options=[]`` is still a rejection. Do NOT use the
+            # truthiness-based ``_option_is_set`` helper here.
+            unsupported = [
+                name for name in _DRIVER_LINKER_UNSUPPORTED_FIELDS if getattr(options, name, None) is not None
+            ]
             if unsupported:
                 raise ValueError(
                     f"the cuLink driver linker does not support these options: "

cuda_core/tests/test_program_cache.py

@@ -355,15 +355,25 @@ def test_make_program_cache_key_nvvm_probe_changes_key(monkeypatch):
 @pytest.mark.parametrize(
     "option_kw",
     [
-        pytest.param({"time": True}, id="time"),
-        pytest.param({"ptxas_options": "-v"}, id="ptxas_options"),
-        pytest.param({"split_compile": 0}, id="split_compile"),
+        pytest.param({"time": True}, id="time_true"),
+        # ``_prepare_driver_options`` checks ``is not None``, so even the
+        # "falsy-but-set" cases must still be rejected at key time.
+        pytest.param({"time": False}, id="time_false"),
+        pytest.param({"ptxas_options": "-v"}, id="ptxas_options_str"),
+        pytest.param({"ptxas_options": ["-v", "-O2"]}, id="ptxas_options_list"),
+        pytest.param({"ptxas_options": []}, id="ptxas_options_empty_list"),
+        pytest.param({"split_compile": 0}, id="split_compile_zero"),
+        pytest.param({"split_compile": 4}, id="split_compile_nonzero"),
+        # split_compile_extended is a LinkerOptions-only field; ProgramOptions
+        # does not expose it, so it cannot reach the driver linker via
+        # Program.compile and is not part of the cache-time guard.
     ],
 )
 def test_make_program_cache_key_ptx_rejects_driver_linker_unsupported(option_kw, monkeypatch):
     """When the driver (cuLink) linker backend is selected, options that
     ``_prepare_driver_options`` rejects must also be rejected at key time
-    so we never cache a compilation that would fail."""
+    so we never cache a compilation that would fail. Uses ``is not None``
+    to exactly mirror the driver-linker's own gate."""
     from cuda.core import _linker
 
     monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: True)  # driver