Fix Optional none lowering for DifferentialPair (#9562)

Fixes #9526 

fix Optional none lowering for DifferentialPair
add regression test

Author: NV-xiaoyongs

external/spirv-headers

@@ -3681,7 +3681,7 @@ struct IRBuilder
     IRInst* emitOptionalHasValue(IRInst* optValue);
     IRInst* emitGetOptionalValue(IRInst* optValue);
     IRInst* emitMakeOptionalValue(IRInst* optType, IRInst* value);
-    IRInst* emitMakeOptionalNone(IRInst* optType, IRInst* defaultValue);
+    IRInst* emitMakeOptionalNone(IRInst* optType);
 
     IRInst* emitDifferentialPairGetDifferential(IRType* diffType, IRInst* diffPair);
     IRInst* emitDifferentialValuePairGetDifferential(IRType* diffType, IRInst* diffPair);

external/spirv-tools

@@ -939,7 +939,7 @@ local insts = {
 	{ getOptionalValue = { operands = { { "optionalOperand" } } } },
 	{ optionalHasValue = { operands = { { "optionalOperand" } } } },
 	{ makeOptionalValue = { operands = { { "value" } } } },
-	{ makeOptionalNone = { operands = { { "defaultValue" } } } },
+	{ makeOptionalNone = {} },
 	{ CombinedTextureSamplerGetTexture = { operands = { { "sampler" } } } },
 	{ CombinedTextureSamplerGetSampler = { operands = { { "sampler" } } } },
 	{ call = { operands = { { "callee" } } } },

source/slang/slang-ir-insts.h

@@ -169,8 +169,12 @@ struct OptionalTypeLoweringContext
         auto info = getLoweredOptionalType(builder, inst->getDataType());
         if (info->loweredType != info->valueType)
         {
+            // Synthesize a default-constructed placeholder for the payload.
+            // The payload is semantically irrelevant when hasValue == false,
+            // but we need a well-formed value to satisfy the struct layout.
+            auto defaultVal = builder->emitDefaultConstruct(info->valueType);
             List<IRInst*> operands;
-            operands.add(inst->getDefaultValue());
+            operands.add(defaultVal);
             operands.add(builder->getBoolValue(false));
             auto makeStruct = builder->emitMakeStruct(info->loweredType, operands);
             inst->replaceUsesWith(makeStruct);

source/slang/slang-ir-insts.lua

@@ -3721,11 +3721,9 @@ IRInst* IRBuilder::emitDefaultConstruct(IRType* type, bool fallback)
         return getNullPtrValue(type);
     case kIROp_OptionalType:
         {
-            auto inner =
-                emitDefaultConstruct(as<IROptionalType>(actualType)->getValueType(), fallback);
-            if (!inner)
-                return nullptr;
-            return emitMakeOptionalNone(type, inner);
+            // The Optional-type lowering pass synthesizes the placeholder payload,
+            // so we don't need to construct `inner` here.
+            return emitMakeOptionalNone(type);
         }
     case kIROp_TupleType:
         {
@@ -4247,9 +4245,9 @@ IRInst* IRBuilder::emitMakeOptionalValue(IRInst* optType, IRInst* value)
     return emitIntrinsicInst((IRType*)optType, kIROp_MakeOptionalValue, 1, &value);
 }
 
-IRInst* IRBuilder::emitMakeOptionalNone(IRInst* optType, IRInst* defaultValue)
+IRInst* IRBuilder::emitMakeOptionalNone(IRInst* optType)
 {
-    return emitIntrinsicInst((IRType*)optType, kIROp_MakeOptionalNone, 1, &defaultValue);
+    return emitIntrinsicInst((IRType*)optType, kIROp_MakeOptionalNone, 0, nullptr);
 }
 
 IRInst* IRBuilder::emitMakeVectorFromScalar(IRType* type, IRInst* scalarValue)

source/slang/slang-ir-lower-optional-type.cpp

@@ -5802,8 +5802,9 @@ struct ExprLoweringVisitorBase : public ExprVisitor<Derived, LoweredValInfo>
         else
         {
             auto optType = lowerType(context, expr->type);
-            auto defaultVal = getDefaultVal(as<OptionalType>(expr->type)->getValueType());
-            auto irVal = context->irBuilder->emitMakeOptionalNone(optType, defaultVal.val);
+            // `none` for Optional<T> no longer requires a payload value from the front-end.
+            // The Optional-type lowering pass will synthesize a default-constructed placeholder.
+            auto irVal = context->irBuilder->emitMakeOptionalNone(optType);
             return LoweredValInfo::simple(irVal);
         }
     }
@@ -6080,8 +6081,8 @@ struct ExprLoweringVisitorBase : public ExprVisitor<Derived, LoweredValInfo>
         builder->emitStore(var, optionalVal);
         builder->emitBranch(afterBlock);
         builder->setInsertInto(falseBlock);
-        auto defaultVal = getDefaultVal(as<OptionalType>(expr->type)->getValueType());
-        auto noneVal = builder->emitMakeOptionalNone(optType, defaultVal.val);
+        // See `visitMakeOptionalExpr`: no longer need to pass a defaultVal.
+        auto noneVal = builder->emitMakeOptionalNone(optType);
         builder->emitStore(var, noneVal);
         builder->emitBranch(afterBlock);
         builder->setInsertInto(afterBlock);

source/slang/slang-ir.cpp

@@ -0,0 +1,41 @@
+// Regression test for issue #9526:
+// Compiler crash during specialization when passing `none` to `Optional<DifferentialPair<T>>`.
+//
+// The intent here is compilation-only: the shader is trivial and just ensures the frontend +
+// specialization pipeline can handle passing `none` without materializing/specializing a dummy `T`.
+//
+// Compilation-only regression test: should not crash during specialization.
+// Note: specify `-o` so slang-test doesn't treat SPIR-V text on stdout as a failure.
+//TEST:SIMPLE: -target spirv -o gh-9526.spv
+
+struct MyStruct : IDifferentiable
+{
+    int a;
+    int b;
+}
+
+int processOptionalDiffPair(Optional<DifferentialPair<MyStruct>> s)
+{
+    if (s.hasValue)
+    {
+        int x = s.value.p.a + s.value.p.b;
+        return x;
+    }
+    return 0;
+}
+
+RWStructuredBuffer<int> outBuffer;
+
+[shader("compute")]
+void computeMain()
+{
+    // "Has value" case (idiomatic): assign a `T` into `Optional<T>` to construct an optional-with-value.
+    // Here `T` is `DifferentialPair<MyStruct>`.
+    DifferentialPair<MyStruct> dp = diffPair(MyStruct(1, 2));
+    Optional<DifferentialPair<MyStruct>> optWithValue = dp;
+    outBuffer[0] = processOptionalDiffPair(optWithValue);
+
+    // This used to crash during specialization.
+    outBuffer[1] = processOptionalDiffPair(none);
+}
+