Add IGlobalSession::getDownstreamCompilerVersion (#11552) (#11556)

## Motivation

There is no public way to ask Slang which version of a downstream
pass-through compiler it will
*actually load and use*. This matters for NVRTC: an application (Falcor)
wants to guard a CUDA
diagnostic path that is pathological on older NVRTC and fine on newer,
and the guard must key off
the NVRTC library *Slang* selected — Slang's discovery order (an
explicit
`setDownstreamCompilerPath`, then the instance directory, then
`CUDA_PATH`, then `PATH`, picking the
newest match) can differ from a version the application discovers on its
own by calling
`nvrtcVersion()`.

Concrete consumer:

```cpp
int major = 0, minor = 0;
if (SLANG_SUCCEEDED(globalSession->getDownstreamCompilerVersion(SLANG_PASS_THROUGH_NVRTC, &major, &minor)))
    useOldNvrtcWorkaround = (major < 12) || (major == 12 && minor < 7);
```

The version is already captured internally:
`NVRTCDownstreamCompiler::init()` calls the loaded
library's `nvrtcVersion(&major, &minor)` and stores it in
`m_desc.version`
(`source/compiler-core/slang-nvrtc-compiler.cpp:196-197`). This change
just exposes that captured
value through a public, ABI-additive method.

## Proposed solution

Append a single method to `IGlobalSession`:

```cpp
virtual SLANG_NO_THROW SlangResult SLANG_MCALL
getDownstreamCompilerVersion(SlangPassThrough passThrough, int* outMajor, int* outMinor) = 0;
```

The implementation routes through
`Session::getOrLoadDownstreamCompiler(passThrough, nullptr)` — the
same memoized lazy-discovery funnel that compilation uses — and reads
the numeric version from
`getDesc().version`. Routing through that funnel is the load-bearing
correctness property: it shares
the memoized compiler cache with `SLANG_PTX` compilation and honors
`setDownstreamCompilerPath` plus
the standard search order, so the reported version is guaranteed to be
the library Slang will
actually compile with.

**Why numeric (`int* outMajor, int* outMinor`) and not a version
string?** A string-blob shape
(`getVersionString`) is unusable for the very compiler this feature
targets: `NVRTCDownstreamCompiler`
does **not** override `getVersionString` (only DXC, glslang, and Tint
do), so it inherits the
`DownstreamCompilerBase` default that returns `SLANG_FAIL` and a null
blob
(`source/compiler-core/slang-downstream-compiler.h:401-406`). The
version is reliably reachable only
through `getDesc().version`. A numeric pair is also directly usable for
the version-comparison guard
that is the actual use case — no string-format contract to freeze and no
client-side parsing. A
public descriptor struct was rejected as an unnecessary permanent ABI
commitment.

> **Maintainer decision point (public ABI shape).** This is a permanent
public-API surface. We
> recommend the numeric `int* outMajor, int* outMinor` shape above for
the reasons given. If you
> prefer a different shape — e.g. a version *string* blob (would
additionally require adding a
> `getVersionString` override to `NVRTCDownstreamCompiler`), or a richer
descriptor — we are happy to
> adjust. Flagging because the choice is hard to change once released.

## Change summary

| File | Change |
|------|--------|
| `include/slang.h` | Append the new pure-virtual to `IGlobalSession`,
immediately before the closing `};` (after `saveBuiltinModule`) —
append-only, ABI-safe. |
| `source/slang/slang-global-session.h` | Declare the `Session`
override. |
| `source/slang/slang-global-session.cpp` | Implement: boundary-validate
the pass-through, load via `getOrLoadDownstreamCompiler`, read
`getDesc().version`. |
| `source/slang-record-replay/proxy/proxy-global-session.h` |
`GlobalSessionProxy` override (record/replay forwarding, records the
version out-params). |
| `source/slang-record-replay/replay-handlers.cpp` | Register the new
method's replay handler so recorded streams containing the call dispatch
on replay. |
| `tools/slang-unit-test/unit-test-vtable-stability.cpp` | Add the new
method to the `IGlobalSession` vtable-layout probe (slot 32) and assert
it. |
| `tools/slang-unit-test/unit-test-downstream-compiler-version.cpp`
(new) | GPU-free unit test for the new API. |

## Concepts and vocabulary

- **`getOrLoadDownstreamCompiler`** — the single, mutex-guarded,
memoized funnel that finds and loads
a downstream compiler for a pass-through, applying the
override/instance-dir/`CUDA_PATH`/`PATH`
search order and caching the result. All compilation goes through it;
routing the query through it
is what guarantees the reported version matches the library used for
codegen.
- **`DownstreamCompilerDesc::version`** — a `SemanticVersion`
(`m_major`/`m_minor`/`m_patch`) on the
desc returned by `IDownstreamCompiler::getDesc()`. For NVRTC it is
populated from `nvrtcVersion`
  at load time; for compilers that report no version it is `(0,0)`.
- **vtable-stability probe** —
`tools/slang-unit-test/unit-test-vtable-stability.cpp` pins the COM
vtable slot index of every `IGlobalSession` method; appending a method
adds the next slot, which
  the test now covers, guarding against accidental mid-vtable insertion.
- **record/replay proxy** — `GlobalSessionProxy` wraps a real
`IGlobalSession` to record API calls
for later replay; every interface method needs a forwarding override
here.

## Process report

- **`include/slang.h` (append the virtual).** The method is appended at
the very end of
`IGlobalSession`, after the previously-last method `saveBuiltinModule`,
with an explicit doc
comment. This is the only ABI-safe placement: inserting mid-interface
would shift every subsequent
vtable slot and break callers compiled against the old header. No enum
or struct is added, so the
  change is `pr: non-breaking`.

- **`source/slang/slang-global-session.h` (declaration).** Declares the
override on the concrete
`Session` class. This is required because `Session` implements
`IGlobalSession`; an appended pure
virtual makes the class abstract until overridden. The declaration order
here is cosmetic — the
vtable slot order is fixed solely by the interface declaration in
`include/slang.h`.

- **`source/slang/slang-global-session.cpp` (implementation).** Mirrors
the existing
`checkPassThroughSupport` → `getOrLoadDownstreamCompiler` precedent for
load and error semantics
(`SLANG_E_NOT_FOUND` when the compiler is not loadable). It then reads
the numeric version directly
from `compiler->getDesc().version` rather than from `getVersionString`.
*Input-shape check:* the data read here — `getDesc().version` — is the
correct, principled source.
It is exactly the field `NVRTCDownstreamCompiler::init()` populates from
the loaded library and the
same field NVRTC uses to gate its own behavior, so there is no upstream
producer to fix; the
string accessor is simply not implemented for NVRTC, which is why we
read the desc. A public
boundary check rejects out-of-range `SlangPassThrough` values up front
(the loader indexes
per-type arrays by the enum value, so an out-of-range value would
otherwise index out of bounds);
`SLANG_PASS_THROUGH_NONE` returns `SLANG_E_NOT_FOUND` because there is
no compiler to report (this
intentionally differs from `checkPassThroughSupport(NONE) == SLANG_OK`).
`outMajor`/`outMinor` are
optional (null tolerated). A loadable-but-versionless compiler yields
`SLANG_OK` with `(0,0)`,
  consistent with "the loaded compiler's reported version."

- **`source/slang-record-replay/proxy/proxy-global-session.h` (proxy
override).** Required because
`GlobalSessionProxy` implements `IGlobalSession`; without the override
the class would not compile.
It records the call and input, then — following the scalar-out-param
pattern already used by
`getTypeConformanceWitnessSequentialID` in the session proxy — uses
`PREPARE_POINTER_OUTPUT` (which
redirects a null arg to a stack temp, making the subsequent record
null-safe) and `RECORD_OUTPUT`
  so the deterministic version values are captured for faithful replay.

- **`source/slang-record-replay/replay-handlers.cpp` (replay
registration).** Every `IGlobalSession`
method that the proxy records has a matching `REPLAY_REGISTER` entry;
without one, a recorded
stream containing the new call would fail to dispatch on replay. The
registration is added next to
  `saveBuiltinModule`, mirroring the interface's append order.

- **`tools/slang-unit-test/unit-test-vtable-stability.cpp` (vtable
guard).** The probe must implement
every `IGlobalSession` method (pure virtuals), so the new method is
added as slot 32 (after
`saveBuiltinModule` = 31) and asserted. This is the regression guard
proving the new method is the
  *last* slot — i.e. truly appended, not inserted.

- **`tools/slang-unit-test/unit-test-downstream-compiler-version.cpp`
(test).** A pure metadata
query, so it runs without a GPU. It first asserts the invalid inputs —
`SLANG_PASS_THROUGH_NONE`
(with both real and null out-params, so null handling runs on every CI
runner) and an out-of-range
`SlangPassThrough(SLANG_PASS_THROUGH_COUNT_OF)` (which exercises the
boundary guard) — all →
`SLANG_E_NOT_FOUND`, before any availability probe so they cannot
perturb the lazy cache. It covers
the documented "loaded-but-versionless ⇒ `SLANG_OK` with `(0,0)`" clause
via
`SLANG_PASS_THROUGH_GLSLANG` (bundled, GPU-free, reports no numeric
version) so a future regression
  conflating that with `SLANG_E_NOT_FOUND` would fail. Then, gated on
`checkPassThroughSupport(SLANG_PASS_THROUGH_NVRTC)` exactly as the
existing CUDA tests do, it
asserts `SLANG_OK` with `major > 0` (and null out-params tolerated) when
NVRTC is available, or
`SLANG_E_NOT_FOUND` when it is not. CI runners with NVRTC exercise the
populated path.

## CLI option `-<compiler>-version` (added per review request)

@jkwak-work asked to surface this new API through a slangc command-line
query option mirroring the
existing `-<compiler>-path`, plus slang-test coverage. That is the final
commit on this branch.

**Behavior.** `-<compiler>-version` is a print-and-continue query flag
with the same
`-<compiler>-...` shape as `-<compiler>-path`: it consumes no value,
prints
`<compiler> version: <major>.<minor>` for the downstream compiler Slang
would actually load for that
pass-through, then lets compilation continue (exactly like `-version`).
It honors `-<compiler>-path`
and the standard search order because it routes through the same
`getDownstreamCompilerVersion`
funnel. When the toolchain cannot be located it prints `<compiler>
version: not found` and still
exits 0, so the `<compiler> version:` prefix is stable across machines.
Examples:

```
slangc -dxc-version                  # -> "dxc version: 1.8"      (or "dxc version: not found")
slangc -glslang-version              # -> "glslang version: 0.0"  (loaded, reports no numeric version)
slangc -nvrtc-version -dxc-version   # prints both, in command-line order; consumes no value
```

**Why this layer.** The parser already owns the symmetric
`-<compiler>-path` registration/handler;
the new option reuses the same `NameValueUtil::getNames(...
getCompilerInfos())` name expansion and
the same `lastIndexOf('-')` name recovery, and the only new sink call is
`diagnoseRaw(Note, ...)`
(verbatim text, no error-count increment, exit stays 0). No new public
surface beyond the appended
`CompilerOptionName::CompilerVersion = 153` enumerator (CLI-only; never
stored on an option set).

| File | Change |
|------|--------|
| `include/slang.h` | Append `CompilerOptionName::CompilerVersion = 153`
before `CountOf` (ABI-additive; CLI-only). |
| `source/slang/slang-options.cpp` | Register `-<compiler>-version`
(mirrors the `-<compiler>-path` block) and add the print-and-continue
handler. |
| `tests/downstream/downstream-compiler-version.slang` (new) |
Comment-only `//TEST:SIMPLE(filecheck=...)` cases for
dxc/fxc/glslang/nvrtc, the hyphenated `spirv-dis` name path, and a
two-flag invocation — matching the stable `<compiler> version:` prefix
so they are deterministic on any runner (GPU-free). |
| `docs/command-line-slangc-reference.md` | Regenerated from `slangc
-help-style markdown -h` to include the new option. |


Closes #11552.

---------

Co-authored-by: nv-slang-bot[bot] <274397474+nv-slang-bot[bot]@users.noreply.github.com>
Co-authored-by: Harsh Aggarwal <haaggarwal@nvidia.com>

Author: nv-slang-bot[bot]

docs/command-line-slangc-reference.md

@@ -699,6 +699,16 @@ Specify path to a downstream [<compiler>](#compiler) executable or library
 
 
 
+<a id="none-version"></a>
+### -&lt;compiler&gt;-version
+
+**-&lt;[compiler](#compiler)&gt;-version**
+
+Print the version of the downstream [&lt;compiler&gt;](#compiler) that Slang would load for that pass-through, then continue. Reports "not found" if the compiler cannot be located. Takes no value. 
+
+
+
+
 <a id="default-downstream-compiler"></a>
 ### -default-downstream-compiler
 

include/slang.h

@@ -1204,6 +1204,12 @@ typedef uint32_t SlangSizeT;
                  //   watchdog timeouts heavy coverage can trigger) at the cost of exact
                  //   counts. Off by default.
 
+        // CLI-only query option `-<compiler>-version`: prints the version of the downstream
+        // <compiler> Slang would actually load for that pass-through (via
+        // IGlobalSession::getDownstreamCompilerVersion). It takes no value and is never stored on
+        // an option set; it only drives the print-and-continue handler in the command-line parser.
+        CompilerVersion = 153,
+
         CountOf,
     };
 
@@ -4192,6 +4198,29 @@ struct IGlobalSession : public ISlangUnknown
         BuiltinModuleName module,
         SlangArchiveType archiveType,
         ISlangBlob** outBlob) = 0;
+
+    /** Get the version of the downstream/pass-through compiler that Slang will actually load and
+    use for `passThrough`, applying the same lazy discovery and library search order used during
+    compilation. This lets a client key its behavior off the exact library Slang selected (for
+    example, the specific NVRTC that will compile CUDA), which can differ from a version the client
+    might discover on its own.
+
+    This is not a cheap accessor: the first call for a given `passThrough` performs discovery and
+    loads the downstream library into the process (then memoizes it for subsequent calls).
+
+    Only some downstream compilers report a numeric version (e.g. NVRTC, DXC, the C/C++ toolchains);
+    others (e.g. the glslang family and Tint) always report `(0,0)`. The version is read uniformly
+    from the loaded compiler's descriptor, so a versionless-but-loaded compiler still returns
+    SLANG_OK with major/minor 0 — which the result alone does not distinguish from a genuine 0.0.
+    @param passThrough The downstream compiler to query (e.g. SLANG_PASS_THROUGH_NVRTC).
+    @param outMajor Receives the major version number. May be null.
+    @param outMinor Receives the minor version number. May be null.
+    @return SLANG_OK if the compiler was located and loaded (see the versionless note above).
+    SLANG_E_NOT_FOUND if the compiler could not be located or loaded, and likewise for
+    SLANG_PASS_THROUGH_NONE or an out-of-range value — the result code alone does not distinguish an
+    invalid argument from a compiler that is simply not installed. */
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    getDownstreamCompilerVersion(SlangPassThrough passThrough, int* outMajor, int* outMinor) = 0;
 };
 
     #define SLANG_UUID_IGlobalSession IGlobalSession::getTypeGuid()

source/slang-record-replay/proxy/proxy-global-session.h

@@ -257,6 +257,24 @@ class GlobalSessionProxy : public ProxyBase<slang::IGlobalSession>
         RECORD_RETURN(result);
     }
 
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getDownstreamCompilerVersion(
+        SlangPassThrough passThrough,
+        int* outMajor,
+        int* outMinor) override
+    {
+        RECORD_CALL();
+        RECORD_INPUT(passThrough);
+        PREPARE_POINTER_OUTPUT(outMajor);
+        PREPARE_POINTER_OUTPUT(outMinor);
+        auto result = getActual<slang::IGlobalSession>()->getDownstreamCompilerVersion(
+            passThrough,
+            outMajor,
+            outMinor);
+        RECORD_OUTPUT(outMajor);
+        RECORD_OUTPUT(outMinor);
+        RECORD_RETURN(result);
+    }
+
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
     compileCoreModule(slang::CompileCoreModuleFlags flags) override
     {

source/slang-record-replay/replay-handlers.cpp

@@ -124,6 +124,7 @@ static void registerAllHandlers()
     REPLAY_REGISTER(GlobalSessionProxy, compileBuiltinModule);
     REPLAY_REGISTER(GlobalSessionProxy, loadBuiltinModule);
     REPLAY_REGISTER(GlobalSessionProxy, saveBuiltinModule);
+    REPLAY_REGISTER(GlobalSessionProxy, getDownstreamCompilerVersion);
 
     // =========================================================================
     // SessionProxy handlers

source/slang/slang-global-session.cpp

@@ -274,6 +274,38 @@ SlangResult Session::checkPassThroughSupport(SlangPassThrough inPassThrough)
     return checkExternalCompilerSupport(this, PassThroughMode(inPassThrough));
 }
 
+SlangResult Session::getDownstreamCompilerVersion(
+    SlangPassThrough inPassThrough,
+    int* outMajor,
+    int* outMinor)
+{
+    // Validate at the public boundary: only a real (non-None), in-range pass-through can name a
+    // loadable compiler. getOrLoadDownstreamCompiler indexes per-type arrays by the enum value, so
+    // reject out-of-range values here rather than indexing out of bounds.
+    if (inPassThrough <= SLANG_PASS_THROUGH_NONE || inPassThrough >= SLANG_PASS_THROUGH_COUNT_OF)
+        return SLANG_E_NOT_FOUND;
+
+    // Route through the same lazy-discovery funnel that compilation uses, so the reported version
+    // is guaranteed to be the library that will actually be used for this pass-through (it shares
+    // the memoized cache and honors setDownstreamCompilerPath + the standard search order).
+    IDownstreamCompiler* compiler =
+        getOrLoadDownstreamCompiler(PassThroughMode(inPassThrough), nullptr);
+    if (!compiler)
+        return SLANG_E_NOT_FOUND;
+
+    // Read the version from the loaded compiler's descriptor: it is the uniform numeric source
+    // across pass-throughs, populated at load (e.g. NVRTC via nvrtcVersion in its init). For some
+    // compilers it is the only place the version is exposed — NVRTC, for one, never implements
+    // getVersionString — while others (glslang, Tint) leave it at (0,0). Hence the desc, not the
+    // version string.
+    const SemanticVersion& version = compiler->getDesc().version;
+    if (outMajor)
+        *outMajor = version.m_major;
+    if (outMinor)
+        *outMinor = version.m_minor;
+    return SLANG_OK;
+}
+
 void Session::writeCoreModuleDoc(String config)
 {
     ASTBuilder* astBuilder = getBuiltinLinkage()->getASTBuilder();

source/slang/slang-global-session.h

@@ -154,6 +154,10 @@ class Session : public RefObject, public slang::IGlobalSession
     checkCompileTargetSupport(SlangCompileTarget target) override;
     SLANG_NO_THROW SlangResult SLANG_MCALL
     checkPassThroughSupport(SlangPassThrough passThrough) override;
+    SLANG_NO_THROW SlangResult SLANG_MCALL getDownstreamCompilerVersion(
+        SlangPassThrough passThrough,
+        int* outMajor,
+        int* outMinor) override;
 
     void writeCoreModuleDoc(String config);
     SLANG_NO_THROW SlangResult SLANG_MCALL

source/slang/slang-options.cpp

@@ -981,6 +981,28 @@ void initCommandOptions(CommandOptions& options)
             "-<compiler>-path");
     }
 
+    {
+        auto namesList = NameValueUtil::getNames(
+            NameValueUtil::NameKind::First,
+            TypeTextUtil::getCompilerInfos());
+        StringBuilder names;
+        for (auto name : namesList)
+        {
+            names << "-" << name << "-version,";
+        }
+        // remove last ,
+        names.reduceLength(names.getLength() - 1);
+
+        options.add(
+            names.getBuffer(),
+            "-<compiler>-version",
+            "Print the version of the downstream <compiler> that Slang would load for that "
+            "pass-through, then continue. Reports \"not found\" if the compiler cannot be "
+            "located. Takes no value.\n",
+            UserValue(OptionKind::CompilerVersion),
+            "-<compiler>-version");
+    }
+
     const Option downstreamOpts[] = {
         {OptionKind::DefaultDownstreamCompiler,
          "-default-downstream-compiler",
@@ -3639,6 +3661,54 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv)
                 }
                 break;
             }
+        case OptionKind::CompilerVersion:
+            {
+                // `-<compiler>-version` is a print-and-continue query option. It has the same
+                // "-<compiler>-..." shape as -<compiler>-path, but instead of consuming a value it
+                // prints the version of the downstream compiler Slang would actually load for that
+                // pass-through, then lets parsing continue (like -version). Recover <compiler> as
+                // the text between the leading '-' and the trailing "-version", exactly as the
+                // CompilerPath case recovers the name before "-path".
+                const Index index = argValue.lastIndexOf('-');
+                if (index >= 0)
+                {
+                    UnownedStringSlice passThroughSlice =
+                        argValue.getUnownedSlice().head(index).tail(1);
+
+                    SlangPassThrough passThrough = SLANG_PASS_THROUGH_NONE;
+                    if (SLANG_FAILED(TypeTextUtil::findPassThrough(passThroughSlice, passThrough)))
+                    {
+                        m_sink->diagnose(Diagnostics::UnknownDownstreamCompiler{
+                            .compiler = passThroughSlice,
+                            .location = arg.loc});
+                        return SLANG_FAIL;
+                    }
+
+                    // getDownstreamCompilerVersion shares the same lazy-discovery funnel used
+                    // during compilation, so the reported version is the library that would
+                    // actually be used for this pass-through (it honors -<compiler>-path and the
+                    // standard search order). It returns SLANG_OK once the compiler is located and
+                    // loaded -- major/minor are then valid, and a loaded-but-versionless compiler
+                    // such as glslang reports 0.0 -- and SLANG_E_NOT_FOUND when it cannot be
+                    // loaded (e.g. the toolchain is not installed).
+                    int major = 0;
+                    int minor = 0;
+                    StringBuilder versionStr;
+                    versionStr << passThroughSlice << " version: ";
+                    if (SLANG_SUCCEEDED(
+                            m_session->getDownstreamCompilerVersion(passThrough, &major, &minor)))
+                    {
+                        versionStr << major << "." << minor;
+                    }
+                    else
+                    {
+                        versionStr << "not found";
+                    }
+                    versionStr << "\n";
+                    m_sink->diagnoseRaw(Severity::Note, versionStr.getUnownedSlice());
+                }
+                break;
+            }
         case OptionKind::InputFilesRemain:
             {
                 // The `--` option causes us to stop trying to parse options,

tests/downstream/downstream-compiler-version.slang

@@ -0,0 +1,26 @@
+// downstream-compiler-version.slang
+//
+// Exercise the `-<compiler>-version` query option (issue #11552 / PR #11556). Each invocation
+// prints the version of the downstream compiler that Slang would actually load for that
+// pass-through (via IGlobalSession::getDownstreamCompilerVersion), then lets compilation of this
+// comment-only file proceed and exit cleanly. The printed line has a stable "<compiler> version:"
+// prefix whether or not the toolchain is installed (it prints "not found" when the compiler
+// cannot be located), so these checks are deterministic across machines and need no GPU.
+
+//TEST:SIMPLE(filecheck=DXC): -dxc-version
+//TEST:SIMPLE(filecheck=FXC): -fxc-version
+//TEST:SIMPLE(filecheck=GLSLANG): -glslang-version
+//TEST:SIMPLE(filecheck=NVRTC): -nvrtc-version
+// spirv-dis exercises the hyphenated-name path: `-spirv-dis-version` must recover "spirv-dis".
+//TEST:SIMPLE(filecheck=SPIRVDIS): -spirv-dis-version
+// Two query flags in one invocation: proves the option consumes no value (it must not swallow the
+// following `-glslang-version`), and that versions print in command-line order.
+//TEST:SIMPLE(filecheck=MULTI): -dxc-version -glslang-version
+
+// DXC: dxc version:
+// FXC: fxc version:
+// GLSLANG: glslang version:
+// NVRTC: nvrtc version:
+// SPIRVDIS: spirv-dis version:
+// MULTI: dxc version:
+// MULTI: glslang version:

tools/slang-unit-test/unit-test-downstream-compiler-version.cpp

@@ -0,0 +1,91 @@
+// unit-test-downstream-compiler-version.cpp
+
+#include "slang-com-ptr.h"
+#include "slang.h"
+#include "unit-test/slang-unit-test.h"
+
+using namespace Slang;
+
+// Test the IGlobalSession::getDownstreamCompilerVersion API (issue #11552). The method reports the
+// version of the downstream compiler Slang will actually load for a given pass-through, using the
+// same lazy discovery that compilation uses. This is purely a metadata query, so it runs without a
+// GPU: when the downstream compiler is loadable we expect a real version; otherwise the method
+// returns SLANG_E_NOT_FOUND, exactly like checkPassThroughSupport.
+SLANG_UNIT_TEST(getDownstreamCompilerVersion)
+{
+    slang::IGlobalSession* globalSession = unitTestContext->slangGlobalSession;
+
+    // SLANG_PASS_THROUGH_NONE is never a loadable compiler. Also verify null out-params are
+    // tolerated on this always-reachable path (the NVRTC null-out check below only runs where
+    // NVRTC is installed).
+    {
+        int major = -1;
+        int minor = -1;
+        SLANG_CHECK(
+            globalSession->getDownstreamCompilerVersion(SLANG_PASS_THROUGH_NONE, &major, &minor) ==
+            SLANG_E_NOT_FOUND);
+        SLANG_CHECK(
+            globalSession->getDownstreamCompilerVersion(
+                SLANG_PASS_THROUGH_NONE,
+                nullptr,
+                nullptr) == SLANG_E_NOT_FOUND);
+    }
+
+    // An out-of-range pass-through value must be rejected at the boundary, not used to index the
+    // per-type compiler arrays.
+    {
+        int major = -1;
+        int minor = -1;
+        SLANG_CHECK(
+            globalSession->getDownstreamCompilerVersion(
+                SlangPassThrough(SLANG_PASS_THROUGH_COUNT_OF),
+                &major,
+                &minor) == SLANG_E_NOT_FOUND);
+    }
+
+    // Gate the NVRTC path on availability the same way the CUDA codegen tests do, so this test
+    // passes both on machines that have NVRTC and those that do not (no GPU is required merely to
+    // load the NVRTC library and read its version).
+    const bool nvrtcAvailable =
+        SLANG_SUCCEEDED(globalSession->checkPassThroughSupport(SLANG_PASS_THROUGH_NVRTC));
+
+    int major = -1;
+    int minor = -1;
+    const SlangResult result =
+        globalSession->getDownstreamCompilerVersion(SLANG_PASS_THROUGH_NVRTC, &major, &minor);
+
+    if (nvrtcAvailable)
+    {
+        // The loaded NVRTC always reports a real version (set from nvrtcVersion at load time),
+        // so the major component is non-zero (e.g. 12 for CUDA 12.x).
+        SLANG_CHECK(result == SLANG_OK);
+        SLANG_CHECK(major > 0);
+
+        // Null out-params must be tolerated.
+        SLANG_CHECK(
+            globalSession->getDownstreamCompilerVersion(
+                SLANG_PASS_THROUGH_NVRTC,
+                nullptr,
+                nullptr) == SLANG_OK);
+    }
+    else
+    {
+        SLANG_CHECK(result == SLANG_E_NOT_FOUND);
+    }
+
+    // Exercise the documented "loaded but versionless" clause: a bundled, GPU-independent compiler
+    // that loads but exposes no numeric version must still succeed with (0,0) — it must NOT be
+    // conflated with SLANG_E_NOT_FOUND. glslang leaves getDesc().version at (0,0) and is loadable
+    // on CI runners without a device.
+    if (SLANG_SUCCEEDED(globalSession->checkPassThroughSupport(SLANG_PASS_THROUGH_GLSLANG)))
+    {
+        int gMajor = -1;
+        int gMinor = -1;
+        SLANG_CHECK(
+            globalSession->getDownstreamCompilerVersion(
+                SLANG_PASS_THROUGH_GLSLANG,
+                &gMajor,
+                &gMinor) == SLANG_OK);
+        SLANG_CHECK(gMajor == 0 && gMinor == 0);
+    }
+}

tools/slang-unit-test/unit-test-vtable-stability.cpp

@@ -665,7 +665,7 @@ SLANG_UNIT_TEST(vtableISlangProfiler)
 }
 
 // ---------------------------------------------------------------------------
-// IGlobalSession : ISlangUnknown  (own slots 3-31)
+// IGlobalSession : ISlangUnknown  (own slots 3-32)
 // ---------------------------------------------------------------------------
 struct IGlobalSessionProbe : IGlobalSession
 {
@@ -841,6 +841,12 @@ struct IGlobalSessionProbe : IGlobalSession
         lastSlot = 31;
         return SLANG_OK;
     }
+    SLANG_NO_THROW SlangResult SLANG_MCALL
+    getDownstreamCompilerVersion(SlangPassThrough, int*, int*) SLANG_OVERRIDE
+    {
+        lastSlot = 32;
+        return SLANG_OK;
+    }
 };
 
 SLANG_UNIT_TEST(vtableIGlobalSession)
@@ -862,6 +868,8 @@ SLANG_UNIT_TEST(vtableIGlobalSession)
     SLANG_CHECK(p.lastSlot == 26); // setSPIRVCoreGrammar
     callSlot(&p, 31);
     SLANG_CHECK(p.lastSlot == 31); // saveBuiltinModule
+    callSlot(&p, 32);
+    SLANG_CHECK(p.lastSlot == 32); // getDownstreamCompilerVersion
 }
 
 // ---------------------------------------------------------------------------