Using Conditional<T, bool> with [SpecializationConstant] causes compile error

[HyPNOTIQ]

Hi, I'm experimenting with using Conditional<T, bool> together with [SpecializationConstant], but I'm not sure if I'm using it correctly. I followed the docs as best as I could, but I'm running into a compilation error and not sure if this is supported or if I'm doing something wrong.

Here’s a code example:

struct VSInput
{
    [[vk::location(0)]] float3 position;
    [[vk::location(1)]] float3 normal;
}

interface IVertex
{
    property float3 position { get; }
    property Optional<float3> normal { get; }
}

struct Vertex<bool hasNormal> : IVertex
{
    private float3 m_position;
    private Conditional<float3, hasNormal> m_normal;

    __init(float3 position, float3 normal)
    {
        m_position = position;
        m_normal = normal;
    }

    property float3 position
    {
        get { return m_position; }
    }
    property Optional<float3> normal
    {
        get { return m_normal; }
    }
}

[SpecializationConstant]
const bool hasNormal = true;

[shader("vertex")]
Vertex<hasNormal> vertMain<bool hasNormal>(const VSInput input)
{
    return Vertex<hasNormal>(input.position, input.normal);
}

When I compile this, I get the following error:

error 99999: Slang compilation aborted due to an exception of class Slang::InternalError: unexpected: needed a known integer value

I'm not sure if Conditional<T, bool> is meant to be used this way, especially with [SpecializationConstant] involved. Just wanted to check if this is a known limitation or if there’s something I should change in how I’m using it.

Thanks!

Environment:

• Slang Version v2025.12.1
• OS Windows 10

[csyonghe]

Specialization constants cannot be used to specialize any generic type or function. There should be a better diagnostic for this.

[HyPNOTIQ]

Hey @csyonghe, thank you for the answer!

It’s still not entirely clear to me what the real use case for that feature is. Based on the example in the documentation, I initially expected it could help simplify the initialization of vertices.

Also, I’d like to provide another code snippet that doesn’t compile—even without using [SpecializationConstant]:

struct VSInput
{
    [[vk::location(0)]] float3 position;
    [[vk::location(1)]] float3 normal;
}

interface IVertex
{
    property float3 position { get; }
    property Optional<float3> normal { get; }
}

struct Vertex<bool hasNormal> : IVertex
{
    private float3 m_position;
    private Conditional<float3, hasNormal> m_normal;

    __init(float3 position, float3 normal)
    {
        m_position = position;
        m_normal = normal;
    }

    property float3 position
    {
        get { return m_position; }
    }
    property Optional<float3> normal
    {
        get { return m_normal; }
    }
}

static bool hasNormal = true;

[shader("vertex")]
Vertex<hasNormal> vertMain<bool hasNormal>(const VSInput input)
{
    return Vertex<hasNormal>(input.position, input.normal);
}

[HyPNOTIQ]

Also, I want to add another code snippet that does compile—even when using [SpecializationConstant].
Just sharing it in case it helps clarify the situation or narrow down the issue:

struct VSInput
{
    [[vk::location(0)]] float3 position;
    [[vk::location(1)]] float3 normal;
}

interface IVertex
{
    property float3 position { get; }
    property Optional<float3> normal { get; }
}

struct Vertex<bool hasNormal> : IVertex
{
    private float3 m_position;
    private Conditional<float3, hasNormal> m_normal;

    __init(float3 position, float3 normal)
    {
        m_position = position;
        m_normal = normal;
    }

    property float3 position
    {
        get { return m_position; }
    }
    property Optional<float3> normal
    {
        get { return m_normal; }
    }
}

[SpecializationConstant]
const bool hasNormal = true;

Vertex<hasNormal> getVertex(const VSInput input)
{
    return Vertex<hasNormal>(input.position, input.position);
}

[shader("vertex")]
float3 vertMain(const VSInput input)
{
    let vertex = getVertex(input);

    return vertex.position;
}

[HyPNOTIQ]

I’ve been experimenting further and wanted to share a workaround that does compile and roughly shows how I expected to use the feature. However, it feels a bit hacky and wordy, and I’m not sure it's actually doing what I want—it just compiles.

struct VSInput
{
    [[vk::location(0)]] float3 position;
    [[vk::location(1)]] float3 normal;
}

interface IVertex
{
    property float3 position { get; }
    property Optional<float3> normal { get; }
}

struct Vertex<bool hasNormal> : IVertex
{
    private float3 m_position;
    private Conditional<float3, hasNormal> m_normal;

    __init(float3 position, float3 normal)
    {
        m_position = position;
        m_normal = normal;
    }

    property float3 position
    {
        get { return m_position; }
    }
    property Optional<float3> normal
    {
        get { return m_normal; }
    }
}

[SpecializationConstant]
const bool hasNormal = true;

Vertex<hasNormal> getVertex(const VSInput input)
{
    return Vertex<hasNormal>(input.position, input.position);
}

struct FSInput
{
    Optional<float3> normal;
}

struct VSOutput
{
    float4 position : SV_Position;
    FSInput fs;
}

[shader("vertex")]
VSOutput main(const VSInput input)
{
    VSOutput output;

    let vertex = getVertex(input);

    output.position = float4(vertex.position, 1);
    output.fs.normal = vertex.normal;

    return output;
}

struct FSOutput
{
    float4 outColor : SV_Target0;
}

[shader("fragment")]
FSOutput main(const FSInput input)
{
    FSOutput output;

    output.outColor = float4(1);

    if (let normal = input.normal)
    {
        // do stuff with normal
    }

    return output;
}