fixup! feat(core.utils): special-case include_path/pre_include in _option_is_set

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -304,31 +304,38 @@ def _cuda_core_version() -> str:
 
 
 # ProgramOptions fields gated by plain truthiness in ``_program.pyx`` (the
-# compiler writes the flag only when the value is truthy). For every other
-# field listed in the cache-guard sets, the compiler uses ``is not None``,
-# so even ``False`` / ``""`` must count as set.
+# compiler writes the flag only when the value is truthy).
 _BOOLEAN_OPTION_FIELDS = frozenset({"pch"})
 
+# Fields whose compiler emission requires ``isinstance(value, str)`` or a
+# non-empty sequence; anything else (``False``, ``int``, ``None``, ``[]``)
+# is silently ignored at compile time.
+_STR_OR_SEQUENCE_OPTION_FIELDS = frozenset({"include_path", "pre_include"})
+
 
 def _option_is_set(options: ProgramOptions, name: str) -> bool:
-    """Match how ``_program.pyx`` gates option emission.
-
-    - For boolean flags (``pch``): value must be truthy.
-    - For sequence-shaped fields (``include_path``, ``pre_include``): ``None``
-      or an empty ``list``/``tuple`` counts as absent; any other value
-      (including the empty string, which NVRTC still emits as ``--flag=``)
-      is set.
-    - For path/string-shaped fields (``create_pch``, ``time``,
+    """Match how ``_program.pyx`` gates option emission, per field shape.
+
+    - Boolean flags (``pch``): truthy only.
+    - str-or-sequence fields (``include_path``, ``pre_include``): ``str``
+      (including empty) or a non-empty ``list``/``tuple``; everything else
+      (``False``, ``int``, empty sequence, ``None``) is ignored by the
+      compiler and must not trigger a cache-time guard.
+    - Path/string-shaped fields (``create_pch``, ``time``,
       ``fdevice_time_trace``, ``use_pch``, ``pch_dir``): ``is not None`` --
       the compiler emits ``--flag=<value>`` for any non-None value, so
-      ``False``/``""``/``0`` must still count as set.
+      ``False`` / ``""`` / ``0`` must still count as set.
     """
     value = getattr(options, name, None)
     if value is None:
         return False
     if name in _BOOLEAN_OPTION_FIELDS:
         return bool(value)
-    return not (isinstance(value, (list, tuple)) and len(value) == 0)
+    if name in _STR_OR_SEQUENCE_OPTION_FIELDS:
+        if isinstance(value, str):
+            return True
+        return isinstance(value, (list, tuple)) and len(value) > 0
+    return True
 
 
 def make_program_cache_key(

cuda_core/tests/test_program_cache.py

@@ -437,11 +437,14 @@ def _flaky_replace(src, dst):
         pytest.param({"use_pch": ""}, id="use_pch_empty_string"),
         pytest.param({"pch_dir": ""}, id="pch_dir_empty_string"),
         pytest.param({"pre_include": ""}, id="pre_include_empty_string"),
-        # Same for ``False`` -- NVRTC's gate on these path-shaped fields is
-        # ``is not None``, so even False emits a real flag.
+        # For path-shaped fields (``use_pch``, ``pch_dir``), NVRTC's gate is
+        # ``is not None``, so even False emits a real flag and must be caught.
         pytest.param({"use_pch": False}, id="use_pch_false"),
         pytest.param({"pch_dir": False}, id="pch_dir_false"),
-        pytest.param({"pre_include": False}, id="pre_include_false"),
+        # ``include_path`` / ``pre_include`` are NOT in that group: the
+        # compiler only emits them for str or non-empty sequences, so
+        # ``False`` is silently ignored at compile time -- test the accept
+        # path below, not the reject path.
     ],
 )
 def test_make_program_cache_key_rejects_external_content_without_extra_digest(option_kw):
@@ -458,6 +461,11 @@ def test_make_program_cache_key_rejects_external_content_without_extra_digest(op
         pytest.param({"include_path": []}, id="include_path_empty_list"),
         pytest.param({"include_path": ()}, id="include_path_empty_tuple"),
         pytest.param({"pre_include": []}, id="pre_include_empty_list"),
+        # ``_prepare_nvrtc_options_impl`` only emits include_path / pre_include
+        # for str or non-empty sequence, so False (or any non-str non-sequence)
+        # is silently ignored at compile time and must not trip the guard.
+        pytest.param({"include_path": False}, id="include_path_false"),
+        pytest.param({"pre_include": False}, id="pre_include_false"),
     ],
 )
 def test_make_program_cache_key_accepts_empty_external_content(option_kw):