fixup! feat(core.utils): narrow key inputs by backend

- name_expressions now only hashed for NVRTC (NVVM/PTX ignore them in Program.compile)
- Validate code_type/target_type combination against SUPPORTED_TARGETS matrix

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -173,6 +173,14 @@ def __exit__(self, exc_type, exc_value, traceback) -> None:
 _VALID_CODE_TYPES = frozenset({"c++", "ptx", "nvvm"})
 _VALID_TARGET_TYPES = frozenset({"ptx", "cubin", "ltoir"})
 
+# code_type -> allowed target_type set, mirroring Program.compile's
+# SUPPORTED_TARGETS matrix in _program.pyx.
+_SUPPORTED_TARGETS_BY_CODE_TYPE = {
+    "c++": frozenset({"ptx", "cubin", "ltoir"}),
+    "ptx": frozenset({"cubin", "ptx"}),
+    "nvvm": frozenset({"ptx", "ltoir"}),
+}
+
 
 def _backend_for_code_type(code_type: str) -> str:
     if code_type == "nvvm":
@@ -341,6 +349,13 @@ def make_program_cache_key(
         raise ValueError(f"code_type={code_type!r} is not supported (must be one of {sorted(_VALID_CODE_TYPES)})")
     if target_type not in _VALID_TARGET_TYPES:
         raise ValueError(f"target_type={target_type!r} is not supported (must be one of {sorted(_VALID_TARGET_TYPES)})")
+    supported_for_code = _SUPPORTED_TARGETS_BY_CODE_TYPE[code_type]
+    if target_type not in supported_for_code:
+        raise ValueError(
+            f"target_type={target_type!r} is not valid for code_type={code_type!r}"
+            f" (supported: {sorted(supported_for_code)}). Program.compile() rejects"
+            f" this combination, so caching a key for it is meaningless."
+        )
 
     backend = _backend_for_code_type(code_type)
 
@@ -456,9 +471,13 @@ def _probe(label: str, fn):
     _update("option_count", str(len(option_bytes)).encode("ascii"))
     for opt in option_bytes:
         _update("option", bytes(opt))
-    _update("names_count", str(len(names)).encode("ascii"))
-    for n in names:
-        _update("name", n)
+    # Only NVRTC consumes ``name_expressions``; Program.compile ignores them
+    # on the NVVM and PTX/linker paths, so folding them into the key there
+    # would force spurious cache misses.
+    if backend == "nvrtc":
+        _update("names_count", str(len(names)).encode("ascii"))
+        for n in names:
+            _update("name", n)
 
     # Hash fields that affect compilation output but are not captured by
     # options.as_bytes() (which only emits CLI-style flags). Without these,

cuda_core/tests/test_program_cache.py

@@ -247,13 +247,43 @@ def test_make_program_cache_key_name_expressions_str_bytes_distinct():
         pytest.param({"code_type": "fortran"}, ValueError, "code_type", id="unknown_code_type"),
         pytest.param({"target_type": "exe"}, ValueError, "target_type", id="unknown_target_type"),
         pytest.param({"code": 12345}, TypeError, "code", id="non_str_bytes_code"),
+        # Backend-specific target matrix -- Program.compile rejects these
+        # combinations, so caching a key for them would be a lie.
+        pytest.param(
+            {"code_type": "ptx", "target_type": "ltoir"},
+            ValueError,
+            "not valid for code_type",
+            id="ptx_cannot_ltoir",
+        ),
+        pytest.param(
+            {"code_type": "nvvm", "target_type": "cubin"},
+            ValueError,
+            "not valid for code_type",
+            id="nvvm_cannot_cubin",
+        ),
     ],
 )
 def test_make_program_cache_key_rejects(kwargs, exc_type, match):
     with pytest.raises(exc_type, match=match):
         _make_key(**kwargs)
 
 
+@pytest.mark.parametrize(
+    "code_type, code, target_type",
+    [
+        pytest.param("nvvm", "abc", "ptx", id="nvvm"),
+        pytest.param("ptx", ".version 7.0", "cubin", id="ptx"),
+    ],
+)
+def test_make_program_cache_key_ignores_name_expressions_for_non_nvrtc(code_type, code, target_type):
+    """Program.compile only forwards ``name_expressions`` on the NVRTC path
+    (_program.pyx). Folding them into the key for NVVM/PTX compiles would
+    cause identical compiles to miss the cache for no behavioural reason."""
+    k_none = _make_key(code=code, code_type=code_type, target_type=target_type)
+    k_with = _make_key(code=code, code_type=code_type, target_type=target_type, name_expressions=("foo", "bar"))
+    assert k_none == k_with
+
+
 @pytest.mark.parametrize(
     "option_kw",
     [