cuda.core build: parallelize only compilers that use CCompiler.compile

The base CCompiler defines a placeholder _compile(), so testing for that
attribute matched MSVC as well. MSVCCompiler overrides compile() wholesale
and never calls _compile(), so the override produced no objects on Windows
and every Windows build failed at link time. Gate on the compile() method
itself: apply the thread pool only when the compiler still uses
CCompiler.compile(), which is what drives _compile() (the Unix family).

Author: Andy-Jost

cuda_core/setup.py

@@ -5,6 +5,7 @@
 import contextlib
 import os
 from concurrent.futures import ThreadPoolExecutor
+from distutils.ccompiler import CCompiler
 from pathlib import Path
 
 import build_hooks  # our build backend
@@ -88,11 +89,12 @@ def _parallel_source_compilation(self):
         cuda.core._rt (a dozen .cpp files) becomes the critical path. This
         mirrors CCompiler.compile() and fans its per-object _compile() calls out
         to a pool shared by all extensions, so at most `nthreads` compiler
-        processes run at once. MSVC's compiler class has no _compile(); it keeps
-        the stock path.
+        processes run at once. It applies only to compilers that still use
+        CCompiler.compile(), which drives the per-object _compile() hook (the
+        Unix family); MSVC overrides compile() wholesale and keeps the stock path.
         """
         compiler = self.compiler
-        if nthreads <= 1 or not hasattr(compiler, "_compile"):
+        if nthreads <= 1 or type(compiler).compile is not CCompiler.compile:
             yield
             return
         stock_compile = compiler.compile

cuda_core/tests/test_build_hooks.py

@@ -22,7 +22,7 @@
 import sys
 import tempfile
 import threading
-import types
+from distutils.ccompiler import CCompiler
 from pathlib import Path
 from unittest import mock
 
@@ -386,8 +386,13 @@ def test_headers_under_module_directories_only(self, tmp_path, monkeypatch):
 class TestParallelSourceCompilation:
     """setup.py compiles an extension's sources through one shared thread pool."""
 
-    class FakeCompiler:
+    class FakeCompiler(CCompiler):
+        """Uses the stock CCompiler.compile(), like the Unix compilers."""
+
+        executables = {}
+
         def __init__(self, fail_on=None):
+            super().__init__()
             self.compiled = []
             self.fail_on = fail_on
             self.lock = threading.Lock()
@@ -406,6 +411,9 @@ def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
             with self.lock:
                 self.compiled.append((obj, src, ext, tuple(cc_args), tuple(extra_postargs), tuple(pp_opts)))
 
+    class MsvcLikeCompiler(FakeCompiler):
+        """Overrides compile() wholesale, like MSVCCompiler."""
+
         def compile(self, *args, **kwargs):
             return "stock"
 
@@ -427,7 +435,7 @@ def test_every_source_compiles_once_and_the_object_order_is_kept(self, monkeypat
         assert objects == [source + ".o" for source in sources]
         assert sorted(entry[0] for entry in cmd.compiler.compiled) == sorted(objects)
         assert {entry[2:] for entry in cmd.compiler.compiled} == {(".cpp", ("-c", "-Dpp"), ("-O2",), ("-Dpp",))}
-        assert cmd.compiler.compile(sources) == "stock"  # restored on exit
+        assert cmd.compiler.compile.__func__ is CCompiler.compile  # restored on exit
 
     @pytest.mark.agent_authored(model="claude-fable-5-1")
     def test_a_failing_source_fails_the_extension(self, monkeypatch):
@@ -439,8 +447,7 @@ def test_a_failing_source_fails_the_extension(self, monkeypatch):
     def test_serial_builds_and_compilers_without_the_hook_keep_the_stock_path(self, monkeypatch):
         cmd = self._build_ext(monkeypatch, 1, self.FakeCompiler())
         with cmd._parallel_source_compilation():
-            assert cmd.compiler.compile(["a.cpp"]) == "stock"
-        msvc_like = types.SimpleNamespace(compile=self.FakeCompiler().compile)  # no _compile()
-        cmd = self._build_ext(monkeypatch, 4, msvc_like)
+            assert cmd.compiler.compile.__func__ is CCompiler.compile
+        cmd = self._build_ext(monkeypatch, 4, self.MsvcLikeCompiler())
         with cmd._parallel_source_compilation():
             assert cmd.compiler.compile(["a.cpp"]) == "stock"