Dynamic dispatch for generic interface requirements.

-Lower interfaces into actual `IRInterfaceType` insts.
-Lower `DeclRef<AssocTypeDecl>` into `IRAssociatedType`
-Generate proper IRType for generic functions.
-Add a test case exercising dynamic dispatching a generic static function through an associated type.
-Bug fixes for the test case.

Author: csyonghe

source/slang/slang-emit-c-like.cpp

@@ -236,9 +236,9 @@ List<IRWitnessTableEntry*> CLikeSourceEmitter::getSortedWitnessTableEntries(IRWi
     // Get a sorted list of entries using RequirementKeys defined in `interfaceType`.
     for (UInt i = 0; i < interfaceType->getOperandCount(); i++)
     {
-        auto reqKey = cast<IRStructKey>(interfaceType->getOperand(i));
+        auto reqEntry = cast<IRInterfaceRequirementEntry>(interfaceType->getOperand(i));
         IRWitnessTableEntry* entry = nullptr;
-        if (witnessTableEntryDictionary.TryGetValue(reqKey, entry))
+        if (witnessTableEntryDictionary.TryGetValue(reqEntry->getRequirementKey(), entry))
         {
             sortedWitnessTableEntries.add(entry);
         }
@@ -1962,6 +1962,10 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
         are hashed with 'getStringHash' */
         break;
 
+    case kIROp_undefined:
+        m_writer->emit(getName(inst));
+        break;
+
     case kIROp_IntLit:
     case kIROp_FloatLit:
     case kIROp_BoolLit:
@@ -3554,6 +3558,11 @@ void CLikeSourceEmitter::emitGlobalInst(IRInst* inst)
         are hashed with 'getStringHash' */
         break;
 
+    case kIROp_InterfaceRequirementEntry:
+        // Don't emit anything for interface requirement at global level.
+        // They are handled in `emitInterface`.
+        break;
+
     case kIROp_Func:
         emitFunc((IRFunc*) inst);
         break;
@@ -3610,6 +3619,10 @@ void CLikeSourceEmitter::ensureInstOperandsRec(ComputeEmitActionsContext* ctx, I
     ensureInstOperand(ctx, inst->getFullType());
 
     UInt operandCount = inst->operandCount;
+    auto requiredLevel = EmitAction::Definition;
+    if (inst->op == kIROp_InterfaceType)
+        requiredLevel = EmitAction::ForwardDeclaration;
+
     for(UInt ii = 0; ii < operandCount; ++ii)
     {
         // TODO: there are some special cases we can add here,
@@ -3620,8 +3633,8 @@ void CLikeSourceEmitter::ensureInstOperandsRec(ComputeEmitActionsContext* ctx, I
         // only need the type they point to to be forward-declared.
         // Similarly, a `call` instruction only needs the callee
         // to be forward-declared, etc.
-
-        ensureInstOperand(ctx, inst->getOperand(ii));
+       
+        ensureInstOperand(ctx, inst->getOperand(ii), requiredLevel);
     }
 
     for(auto child : inst->getDecorationsAndChildren())

source/slang/slang-emit-cpp.cpp

@@ -390,12 +390,27 @@ static UnownedStringSlice _getResourceTypePrefix(IROp op)
     }
 }
 
+static bool isVoidPtrType(IRType* type)
+{
+    auto ptrType = as<IRPtrType>(type);
+    if (!ptrType) return false;
+    return ptrType->getValueType()->op == kIROp_VoidType;
+}
+
 SlangResult CPPSourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, StringBuilder& out)
 {
     switch (type->op)
     {
         case kIROp_PtrType:
         {
+            if (isVoidPtrType(type))
+            {
+                // A `void*` type will always emit as `void*`.
+                // `void*` types are generated as a result of generics lowering
+                // for dynamic dispatch.
+                out << "void*";
+                return SLANG_OK;
+            }
             auto ptrType = static_cast<IRPtrType*>(type);
             SLANG_RETURN_ON_FAIL(calcTypeName(ptrType->getValueType(), target, out));
             // TODO(JS): It seems although it says it is a pointer, it can actually be output as a reference
@@ -494,7 +509,7 @@ SlangResult CPPSourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, S
             // struct of function pointers corresponding to the interface type.
             auto witnessTableType = static_cast<IRWitnessTableType*>(type);
             auto baseType = cast<IRType>(witnessTableType->getOperand(0));
-            emitType(baseType);
+            SLANG_RETURN_ON_FAIL(calcTypeName(baseType, target, out));
             out << "*";
             return SLANG_OK;
         }
@@ -1591,8 +1606,7 @@ void CPPSourceEmitter::emitWitnessTable(IRWitnessTable* witnessTable)
 {
     auto interfaceType = cast<IRInterfaceType>(witnessTable->getOperand(0));
     auto witnessTableItems = witnessTable->getChildren();
-    List<IRWitnessTableEntry*> sortedWitnessTableEntries = getSortedWitnessTableEntries(witnessTable);
-    _maybeEmitWitnessTableTypeDefinition(interfaceType, sortedWitnessTableEntries);
+    _maybeEmitWitnessTableTypeDefinition(interfaceType);
 
     // Define a global variable for the witness table.
     m_writer->emit("extern ");
@@ -1747,51 +1761,52 @@ void CPPSourceEmitter::emitInterface(IRInterfaceType* interfaceType)
     /// acoording to the order defined by `interfaceType`.
     ///
 void CPPSourceEmitter::_maybeEmitWitnessTableTypeDefinition(
-    IRInterfaceType* interfaceType,
-    const List<IRWitnessTableEntry*>& sortedWitnessTableEntries)
+    IRInterfaceType* interfaceType)
 {
     m_writer->emit("struct ");
     emitSimpleType(interfaceType);
     m_writer->emit("\n{\n");
     m_writer->indent();
-    for (Index i = 0; i < sortedWitnessTableEntries.getCount(); i++)
+    for (UInt i = 0; i < interfaceType->getOperandCount(); i++)
     {
-        auto entry = sortedWitnessTableEntries[i];
-        if (auto funcVal = as<IRFunc>(entry->satisfyingVal.get()))
+        auto entry = as<IRInterfaceRequirementEntry>(interfaceType->getOperand(i));
+        if (auto funcVal = as<IRFuncType>(entry->getRequirementVal()))
         {
             emitType(funcVal->getResultType());
             m_writer->emit(" (KernelContext::*");
             m_writer->emit(getName(entry->requirementKey.get()));
             m_writer->emit(")");
             m_writer->emit("(");
             bool isFirstParam = true;
-            for (auto param : funcVal->getParams())
+            for (UInt p = 0; p < funcVal->getParamCount(); p++)
             {
+                auto paramType = funcVal->getParamType(p);
+                // Ingore TypeType-typed parameters for now.
+                if (as<IRTypeType>(paramType))
+                    continue;
+
                 if (!isFirstParam)
                     m_writer->emit(", ");
                 else
                     isFirstParam = false;
-                if (param->findDecoration<IRThisPointerDecoration>())
+                auto thisDecor = funcVal->findDecoration<IRThisPointerDecoration>();
+                if (thisDecor && cast<IRIntLit>(thisDecor->getOperand(0))->value.intVal == (IRIntegerValue)p)
                 {
-                    m_writer->emit("void* ");
-                    m_writer->emit(getName(param));
+                    m_writer->emit("void* param");
+                    m_writer->emit(p);
                     continue;
                 }
-                emitSimpleFuncParamImpl(param);
+                emitParamType(paramType, String("param") + String(p));
             }
             m_writer->emit(");\n");
         }
-        else if (auto witnessTableVal = as<IRWitnessTable>(entry->getSatisfyingVal()))
+        else if (auto constraintInterfaceType = as<IRInterfaceType>(entry->getRequirementVal()))
         {
-            emitType(as<IRType>(witnessTableVal->getOperand(0)));
+            emitType(constraintInterfaceType);
             m_writer->emit("* ");
             m_writer->emit(getName(entry->requirementKey.get()));
             m_writer->emit(";\n");
         }
-        else
-        {
-            // TODO: handle other witness table entry types.
-        }
     }
     m_writer->dedent();
     m_writer->emit("};\n");
@@ -1990,23 +2005,14 @@ void CPPSourceEmitter::emitSimpleValueImpl(IRInst* inst)
     }
 }
 
-static bool isVoidPtrType(IRType* type)
-{
-    auto ptrType = as<IRPtrType>(type);
-    if (!ptrType) return false;
-    return ptrType->getValueType()->op == kIROp_VoidType;
-}
-
 void CPPSourceEmitter::emitSimpleFuncParamImpl(IRParam* param)
 {
     // Polymorphic types are already translated to void* type in
     // lower-generics pass. However, the current emitting logic will
     // emit "void&" instead of "void*" for pointer types.
     // In the future, we will handle pointer types more properly,
     // and this override logic will not be necessary.
-    // For now we special-case this scenario.
-    if (param->findDecoration<IRPolymorphicDecoration>() &&
-        isVoidPtrType(param->getDataType()))
+    if (isVoidPtrType(param->getDataType()))
     {
         m_writer->emit("void* ");
         m_writer->emit(getName(param));

source/slang/slang-emit-cpp.h

@@ -89,7 +89,7 @@ class CPPSourceEmitter: public CLikeSourceEmitter
     virtual SlangResult calcScalarFuncName(HLSLIntrinsic::Op op, IRBasicType* type, StringBuilder& outBuilder);
 
         // Emits a struct of function pointers defined in `interfaceType`.
-    void _maybeEmitWitnessTableTypeDefinition(IRInterfaceType* interfaceType, const List<IRWitnessTableEntry*>& sortedWitnessTableEntries);
+    void _maybeEmitWitnessTableTypeDefinition(IRInterfaceType* interfaceType);
     void _maybeEmitSpecializedOperationDefinition(const HLSLIntrinsic* specOp);
 
     void _emitForwardDeclarations(const List<EmitAction>& actions);

source/slang/slang-ir-inst-defs.h

@@ -164,7 +164,8 @@ INST(Nop, nop, 0, 0)
 // `field` instructions.
 //
 INST(StructType, struct, 0, PARENT)
-INST(InterfaceType, interface, 0, PARENT)
+INST(InterfaceType, interface, 0, 0)
+INST(AssociatedType, associated_type, 0, 0)
 
 // A TypeType-typed IRValue represents a IRType.
 // It is used to represent a type parameter/argument in a generics.
@@ -223,6 +224,7 @@ INST(Call, call, 1, 0)
 
 
 INST(WitnessTableEntry, witness_table_entry, 2, 0)
+INST(InterfaceRequirementEntry, interface_req_entry, 2, 0)
 
 INST(Param, param, 0, 0)
 INST(StructField, field, 2, 0)
@@ -507,14 +509,12 @@ INST(HighLevelDeclDecoration,               highLevelDecl,          1, 0)
 
     INST(BindExistentialSlotsDecoration, bindExistentialSlots, 0, 0)
 
-        /// A `[polymorphic]` decoration marks a function parameter that should translate to an abstract type
-        /// e.g. (void*) that are casted to actual type before use. For example, a parameter of generic type
-        /// is marked `[polymorphic]`, so that the code gen logic can emit it as a `void*` parameter,
-        /// allowing the function to be used at sites that are agnostic of the actual object type.
-    INST(PolymorphicDecoration, polymorphic, 0, 0)
 
         /// A `[this_ptr]` decoration marks a function parameter that serves as `this` pointer.
-    INST(ThisPointerDecoration, this_ptr, 0, 0)
+        /// `[this_ptr]` decoration is also used to mark an `IRFunc` as a non-static function.
+        /// The argument is an integer value that represents the index of the `this` parameter,
+        /// which is always 0.
+    INST(ThisPointerDecoration, this_ptr, 1, 0)
 
 
         /// A `[format(f)]` decoration specifies that the format of an image should be `f`

source/slang/slang-ir-insts.h

@@ -165,8 +165,6 @@ IR_SIMPLE_DECORATION(VulkanCallablePayloadDecoration)
 /// vulkan hit attributes, and should have a location assigned
 /// to it.
 IR_SIMPLE_DECORATION(VulkanHitAttributesDecoration)
-
-IR_SIMPLE_DECORATION(PolymorphicDecoration)
 IR_SIMPLE_DECORATION(ThisPointerDecoration)
 
 
@@ -410,9 +408,13 @@ struct IRLookupWitnessMethod : IRInst
 {
     IRUse witnessTable;
     IRUse requirementKey;
+    IRUse interfaceType;
 
     IRInst* getWitnessTable() { return witnessTable.get(); }
     IRInst* getRequirementKey() { return requirementKey.get(); }
+    IRInst* getInterfaceType() { return interfaceType.get(); }
+
+    IR_LEAF_ISA(lookup_interface_method)
 };
 
 struct IRLookupWitnessTable : IRInst
@@ -1675,7 +1677,8 @@ struct IRBuilder
     IRInst* emitLookupInterfaceMethodInst(
         IRType* type,
         IRInst* witnessTableVal,
-        IRInst* interfaceMethodVal);
+        IRInst* interfaceMethodVal,
+        IRType* interfaceType);
 
     IRInst* emitCallInst(
         IRType*         type,
@@ -1809,9 +1812,16 @@ struct IRBuilder
         IRInst*        requirementKey,
         IRInst*        satisfyingVal);
 
+    IRInterfaceRequirementEntry* createInterfaceRequirementEntry(
+        IRInst* requirementKey,
+        IRInst* requirementVal);
+
     // Create an initially empty `struct` type.
     IRStructType*   createStructType();
 
+    // Create an IRType representing an `associatedtype` decl.
+    IRAssociatedType* createAssociatedType();
+
     // Create an empty `interface` type.
     IRInterfaceType* createInterfaceType(UInt operandCount, IRInst* const* operands);
 
@@ -2160,14 +2170,9 @@ struct IRBuilder
         addDecoration(value, kIROp_LoopControlDecoration, getIntValue(getIntType(), IRIntegerValue(mode)));
     }
 
-    void addPolymorphicDecoration(IRInst* value)
-    {
-        addDecoration(value, kIROp_PolymorphicDecoration);
-    }
-
-    void addThisPointerDecoration(IRInst* value)
+    void addThisPointerDecoration(IRInst* value, int paramIndex)
     {
-        addDecoration(value, kIROp_ThisPointerDecoration);
+        addDecoration(value, kIROp_ThisPointerDecoration, getIntValue(getIntType(), paramIndex));
     }
 
     void addSemanticDecoration(IRInst* value, UnownedStringSlice const& text, int index = 0)

source/slang/slang-ir-link.cpp

@@ -228,6 +228,7 @@ IRInst* IRSpecContext::maybeCloneValue(IRInst* originalValue)
     case kIROp_StructKey:
     case kIROp_GlobalGenericParam:
     case kIROp_WitnessTable:
+    case kIROp_InterfaceType:
     case kIROp_TaggedUnionType:
         return cloneGlobalValue(this, originalValue);
 
@@ -607,8 +608,7 @@ IRInterfaceType* cloneInterfaceTypeImpl(
     auto clonedInterface = builder->createInterfaceType(originalInterface->getOperandCount(), nullptr);
     for (UInt i = 0; i < originalInterface->getOperandCount(); i++)
     {
-        auto clonedKey = findClonedValue(context, originalInterface->getOperand(i));
-        SLANG_ASSERT(clonedKey);
+        auto clonedKey = cloneValue(context, originalInterface->getOperand(i));
         clonedInterface->setOperand(i, clonedKey);
     }
     cloneSimpleGlobalValueImpl(context, originalInterface, originalValues, clonedInterface);
@@ -628,6 +628,7 @@ void cloneGlobalValueWithCodeCommon(
 
     cloneDecorations(context, clonedValue, originalValue);
     cloneExtraDecorations(context, clonedValue, originalValues);
+    clonedValue->setFullType((IRType*)cloneValue(context, originalValue->getFullType()));
 
     // We will walk through the blocks of the function, and clone each of them.
     //