Handle partial existential parameter type specialization. (shader-slang#1568)

* Specialize exsitentials parameters in struct fields.

* Cleanup.

* Handle partial existential parameter type specialization.

Co-authored-by: Yong He <yhe@nvidia.com>

Author: csyonghe

source/slang/slang-ir-insts.h

@@ -1807,7 +1807,7 @@ struct IRBuilder
     IRInOutType*  getInOutType(IRType* valueType);
     IRRefType*  getRefType(IRType* valueType);
     IRPtrTypeBase*  getPtrType(IROp op, IRType* valueType);
-    IRExistentialBoxType* getExistentialBoxType(IRType* concreteType, IRType* interfaceType);
+    IRType* getExistentialBoxType(IRType* concreteType, IRType* interfaceType);
 
     IRArrayTypeBase* getArrayTypeBase(
         IROp    op,

source/slang/slang-ir.cpp

@@ -2336,10 +2336,14 @@ namespace Slang
             operands);
     }
 
-    IRExistentialBoxType* IRBuilder::getExistentialBoxType(IRType* concreteType, IRType* interfaceType)
+    IRType* IRBuilder::getExistentialBoxType(IRType* concreteType, IRType* interfaceType)
     {
+        // Don't wrap an existential box if concreteType is __Dynamic.
+        if (as<IRDynamicType>(concreteType))
+            return interfaceType;
+
         IRInst* operands[] = {concreteType, interfaceType};
-        return (IRExistentialBoxType*)getType(kIROp_ExistentialBoxType, 2, operands);
+        return getType(kIROp_ExistentialBoxType, 2, operands);
     }
 
     IRArrayTypeBase* IRBuilder::getArrayTypeBase(
@@ -2845,6 +2849,8 @@ namespace Slang
                 // We want to emit `makeExistential(load(value), witnessTable)`.
                 //
                 auto deref = emitLoad(value);
+                if (slotArgs[0]->op == kIROp_DynamicType)
+                    return deref;
                 return emitMakeExistential(type, deref, slotArgs[1]);
             }
         }

tests/compute/interface-param-partial-specialize.slang

@@ -0,0 +1,46 @@
+// Tests generating dynamic dispatch code for a function
+// with existential-struct-typed param by specializing it
+// with __Dynamic. This verifies that the handling of
+// "partially" specializing an existential type is correct.
+
+//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -cuda
+//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -cpu
+
+[anyValueSize(8)]
+interface IInterface
+{
+    uint eval();
+}
+
+public struct Impl : IInterface
+{
+    uint val;
+    uint eval()
+    {
+        return val;
+    }
+};
+
+struct Params
+{
+    StructuredBuffer<IInterface> obj;
+};
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=gOutputBuffer
+RWStructuredBuffer<uint> gOutputBuffer;
+
+void compute(uint tid, Params p)
+{
+    gOutputBuffer[tid] = p.obj[0].eval();
+}
+
+//TEST_INPUT: entryPointExistentialType __Dynamic
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID,
+//TEST_INPUT:ubuffer(data=[rtti(Impl) witness(Impl, IInterface) 1 0], stride=4):name=params.obj
+    uniform Params params)
+{
+	uint tid = dispatchThreadID.x;
+	compute(tid, params);
+}

tests/compute/interface-param-partial-specialize.slang.expected.txt

@@ -0,0 +1,4 @@
+1
+1
+1
+1