Allow calling a generic function with an existential value (dynamic dispatch) (shader-slang#1508)

* Allow calling a generic function with an existential value (dynamic dispatch).

* Fixes per review comments.

* Clean up implementation by having `openExistential` return `ExtractExistentialType` instead of a DeclRef to the interface with a `ThisTypeSubstitution`.

* More cleanups

Co-authored-by: Tim Foley <tfoleyNV@users.noreply.github.com>
Co-authored-by: Yong He <yhe@nvidia.com>

Author: csyonghe

source/slang/slang-ast-type.cpp

@@ -676,7 +676,7 @@ bool ExtractExistentialType::_equalsImplOverride(Type* type)
 
 HashCode ExtractExistentialType::_getHashCodeOverride()
 {
-    return declRef.getHashCode();
+    return combineHash(declRef.getHashCode(), interfaceDeclRef.getHashCode());
 }
 
 Type* ExtractExistentialType::_createCanonicalTypeOverride()
@@ -688,13 +688,15 @@ Val* ExtractExistentialType::_substituteImplOverride(ASTBuilder* astBuilder, Sub
 {
     int diff = 0;
     auto substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff);
+    auto interfaceSubstDeclRef = interfaceDeclRef.substituteImpl(astBuilder, subst, &diff);
     if (!diff)
         return this;
 
     (*ioDiff)++;
 
     ExtractExistentialType* substValue = astBuilder->create<ExtractExistentialType>();
-    substValue->declRef = declRef;
+    substValue->declRef = substDeclRef;
+    substValue->interfaceDeclRef = interfaceSubstDeclRef;
     return substValue;
 }
 

source/slang/slang-ast-type.h

@@ -611,6 +611,7 @@ class ExtractExistentialType : public Type
     SLANG_CLASS(ExtractExistentialType)
 
     DeclRef<VarDeclBase> declRef;
+    DeclRef<InterfaceDecl> interfaceDeclRef;
 
     // Overrides should be public so base classes can access
     String _toStringOverride();

source/slang/slang-check-conformance.cpp

@@ -268,6 +268,30 @@ namespace Slang
                 }
             }
         }
+        else if (auto extractExistentialType = as<ExtractExistentialType>(subType))
+        {
+            // An ExtractExistentialType from an existential value of type I
+            // is a subtype of I.
+            // We need to check and make sure the interface type of the `ExtractExistentialType`
+            // is equal to `superType`.
+            auto interfaceDeclRef = extractExistentialType->interfaceDeclRef;
+            auto thisTypeSubst = findThisTypeSubstitution(interfaceDeclRef.substitutions.substitutions, interfaceDeclRef.getDecl());
+            SLANG_ASSERT(thisTypeSubst && thisTypeSubst == interfaceDeclRef.substitutions.substitutions);
+            // The interfaceDeclRef in `extractExistentialType` contains a `ThisTypeSubstitution`
+            // to allow member lookup to return correct substituted types. Here we just need
+            // to know if that interface is the same as the superType, so we need to exclude
+            // the `ThisTypeSubstitution` from comparison.
+            interfaceDeclRef.substitutions.substitutions = thisTypeSubst->outer;
+            if (interfaceDeclRef.equals(superTypeDeclRef))
+            {
+                if (outWitness)
+                {
+                    *outWitness = thisTypeSubst->witness;
+                }
+                return true;
+            }
+            return false;
+        }
         else if(auto taggedUnionType = as<TaggedUnionType>(subType))
         {
             // A tagged union type conforms to an interface if all of

source/slang/slang-check-expr.cpp

@@ -116,11 +116,11 @@ namespace Slang
             openedThisType->witness = openedWitness;
 
             DeclRef<InterfaceDecl> substDeclRef = DeclRef<InterfaceDecl>(interfaceDecl, openedThisType);
-            auto substDeclRefType = DeclRefType::create(m_astBuilder, substDeclRef);
+            openedType->interfaceDeclRef = substDeclRef;
 
             ExtractExistentialValueExpr* openedValue = m_astBuilder->create<ExtractExistentialValueExpr>();
             openedValue->declRef = varDeclRef;
-            openedValue->type = QualType(substDeclRefType);
+            openedValue->type = QualType(openedType);
 
             return openedValue;
         });

source/slang/slang-check-overload.cpp

@@ -1517,6 +1517,11 @@ namespace Slang
                 return CreateErrorExpr(expr);
         }
 
+        for (auto& arg : expr->arguments)
+        {
+            arg = maybeOpenExistential(arg);
+        }
+
         context.originalExpr = expr;
         context.funcLoc = funcExpr->loc;
 

source/slang/slang-lookup.cpp

@@ -587,6 +587,10 @@ static void _lookUpMembersInSuperTypeImpl(
 
         _lookUpMembersInSuperTypeDeclImpl(astBuilder, name, leafType, superType, leafIsSuperWitness, declRef, request, ioResult, inBreadcrumbs);
     }
+    if (auto extractExistentialType = as<ExtractExistentialType>(superType))
+    {
+        _lookUpMembersInSuperTypeDeclImpl(astBuilder, name, leafType, superType, leafIsSuperWitness, extractExistentialType->interfaceDeclRef, request, ioResult, inBreadcrumbs);
+    }
 }
 
     /// Perform lookup for `name` in the context of `type`.

tests/compute/dynamic-dispatch-10.slang

@@ -0,0 +1,47 @@
+//TEST(compute):COMPARE_COMPUTE:-cpu -xslang -allow-dynamic-code
+//DISABLE_TEST(compute):COMPARE_COMPUTE:-cuda -xslang -allow-dynamic-code
+
+// Test dynamic dispatch code gen for specializing a generic with
+// an existential value.
+
+[anyValueSize(16)]
+interface IInterface
+{
+	int Compute(int inVal);
+};
+
+int GenericCompute0(IInterface obj, int inVal)
+{
+    return GenericCompute1(obj, obj, inVal);
+}
+
+int GenericCompute1<T:IInterface>(T obj, IInterface obj2, int inVal)
+{
+    return obj.Compute(inVal) + obj2.Compute(inVal);
+}
+
+
+struct Impl : IInterface
+{
+    int base;
+	int Compute(int inVal) { return base + inVal * inVal; }
+};
+
+int test(int inVal)
+{
+    Impl obj;
+    obj.base = 1;
+	return GenericCompute0(obj, inVal);
+}
+
+//TEST_INPUT:ubuffer(data=[0 1 2 3], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer : register(u0);
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+	uint tid = dispatchThreadID.x;
+	int inVal = outputBuffer[tid];
+	int outVal = test(inVal);
+	outputBuffer[tid] = outVal;
+}

tests/compute/dynamic-dispatch-10.slang.expected.txt

@@ -0,0 +1,4 @@
+2
+4
+A
+14