Fix generic function overloads in reflection API (#9052)

Close #8633.

When calling `findFunctionByName<someGeneric<concrete_type>>` to find a
generic function, it will report nullptr if there are overloads for the
generic function.

The reason is that we didn't handle OverloadedExpr2 node in the
reflection API.

The fix is to conservatively convert OverloadedExpr2 to OverloadedExpr
and reuse to existing logic to keep handling the OverloadedExpr.

The alternative solution will be add logic of handling OverloadedExpr2
to every location that only handles OverloadedExpr. But it might be more
complicated.

Author: kaizhangNV

source/slang/slang-linkable.cpp

@@ -813,6 +813,74 @@ Expr* ComponentType::tryResolveOverloadedExpr(Expr* exprIn)
     return visitor.maybeResolveOverloadedExpr(exprIn, LookupMask::Function, nullptr);
 }
 
+// This function tries to simplify an overloaded expr into OverloadedExpr for reflection API usage.
+// There are two kinds of overloaded expr in the AST: OverloadedExpr and OverloadedExpr2.
+//
+// OverloadedExpr stores candidates in LookupResult, where a list of `DeclRef<Decl>` hold
+// the properly-specialized reference to the declaration that was found. And all the candidates
+// must share a same base (if it is coming from a member-reference), and same orignalExpr.
+//
+// While OverloadedExpr2 stores candidates in a list of Expr, which is not necessary to be
+// DeclRefExpr.
+//
+// When the input orignalExpr is already OverloadedExpr, we can directly return it. But when
+// the input orignalExpr is OverloadedExpr2, we need to simplify it by converting it into
+// OverloadedExpr. The conversion routine conservatively performs the conversion when each Expr
+// candidates of OverloadedExpr2 is DeclRefExpr and all the candidates DeclRefExpr share the same
+// orignalExpr. If such condition is not met, it will return nullptr to indicated failed conversion.
+static Expr* maybeSimplifyExprForReflectionAPIUsage(Expr* originalExpr, ASTBuilder* astBuilder)
+{
+    // return directly if it is already OverloadedExpr
+    if (as<OverloadedExpr>(originalExpr))
+        return originalExpr;
+
+    OverloadedExpr2* overloadedExpr2 = as<OverloadedExpr2>(originalExpr);
+    // Don't perform any conversion if it is not OverloadedExpr2
+    if (!overloadedExpr2)
+        return originalExpr;
+
+    if (!overloadedExpr2->candidateExprs.getCount())
+        return nullptr;
+
+    auto overloadedExpr = astBuilder->create<OverloadedExpr>();
+
+    Expr* sharedOriginalExpr = nullptr;
+
+    // Start the conversion
+    for (auto candidate : overloadedExpr2->candidateExprs)
+    {
+        if (auto declRefExpr = as<DeclRefExpr>(candidate))
+        {
+            LookupResultItem item;
+            item.declRef = declRefExpr->declRef;
+            overloadedExpr->lookupResult2.items.add(item);
+
+            if (!sharedOriginalExpr)
+            {
+                sharedOriginalExpr = declRefExpr->originalExpr;
+            }
+            else if (sharedOriginalExpr != declRefExpr->originalExpr)
+            {
+                return nullptr;
+            }
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+
+    if (overloadedExpr->lookupResult2.items.getCount())
+    {
+        overloadedExpr->lookupResult2.item = overloadedExpr->lookupResult2.items[0];
+        overloadedExpr->base = overloadedExpr2->base;
+        overloadedExpr->originalExpr = sharedOriginalExpr;
+        return overloadedExpr;
+    }
+
+    return nullptr;
+}
+
 Expr* ComponentType::findDeclFromString(String const& name, DiagnosticSink* sink)
 {
     // If we've looked up this type name before,
@@ -855,6 +923,7 @@ Expr* ComponentType::findDeclFromString(String const& name, DiagnosticSink* sink
     {
         result = checkedExpr;
     }
+    result = maybeSimplifyExprForReflectionAPIUsage(checkedExpr, astBuilder);
 
     m_decls[name] = result;
     return result;
@@ -946,6 +1015,8 @@ Expr* ComponentType::findDeclFromStringInType(
 
     auto checkedTerm = visitor.CheckTerm(expr);
 
+    checkedTerm = maybeSimplifyExprForReflectionAPIUsage(checkedTerm, astBuilder);
+
     if (auto overloadedExpr = as<OverloadedExpr>(checkedTerm))
     {
         // For functions, since we don't know the argument list yet, we will have to defer

tools/slang-unit-test/unit-test-function-reflection.cpp

@@ -326,3 +326,104 @@ SLANG_UNIT_TEST(findFunctionByNameInType)
         SLANG_CHECK_ABORT(false && "Expected function to be overloaded with multiple signatures");
     }
 }
+
+
+SLANG_UNIT_TEST(findFunctionByNameGenericOverload)
+{
+    // Test shader with extensions that have functions with same name but different signatures
+    const char* userSourceBody = R"(
+
+        void myFunc<T>(T value)
+        {}
+
+        void myFunc<T>(T value, T value1)
+        {}
+
+        struct MyType<U>
+        {
+            void myFunc<T>(T value)
+            {}
+
+            void myFunc<T>(T value, T value1)
+            {}
+        }
+
+        [shader("compute")]
+        void computeMain(uint3 tid: SV_DispatchThreadID)
+        {
+        }
+        )";
+
+    auto moduleName = "moduleH" + String(Process::getId());
+    String userSource = "import " + moduleName + ";\n" + userSourceBody;
+    ComPtr<slang::IGlobalSession> globalSession;
+    SLANG_CHECK(slang_createGlobalSession(SLANG_API_VERSION, globalSession.writeRef()) == SLANG_OK);
+    slang::TargetDesc targetDesc = {};
+    targetDesc.format = SLANG_HLSL;
+    targetDesc.profile = globalSession->findProfile("sm_5_0");
+    slang::SessionDesc sessionDesc = {};
+    sessionDesc.targetCount = 1;
+    sessionDesc.targets = &targetDesc;
+    ComPtr<slang::ISession> session;
+    SLANG_CHECK(globalSession->createSession(sessionDesc, session.writeRef()) == SLANG_OK);
+
+    ComPtr<slang::IBlob> diagnosticBlob;
+    auto module = session->loadModuleFromSourceString(
+        "test_module",
+        "test_module.slang",
+        userSourceBody,
+        diagnosticBlob.writeRef());
+    SLANG_CHECK(module != nullptr);
+
+    int testCount = 2;
+    for (int i = 0; i < testCount; i++)
+    {
+        slang::FunctionReflection* myFunctionType = nullptr;
+        if (i == 0)
+        {
+            // test the global generic function overloads
+            myFunctionType = module->getLayout()->findFunctionByName("myFunc<int>");
+            SLANG_CHECK_ABORT(myFunctionType != nullptr);
+        }
+        else
+        {
+
+            // test the generic function overloads inside a generic struct
+            auto myStructType = module->getLayout()->findTypeByName("MyType<float>");
+            SLANG_CHECK_ABORT(myStructType != nullptr);
+
+            myFunctionType =
+                module->getLayout()->findFunctionByNameInType(myStructType, "myFunc<int>");
+            SLANG_CHECK_ABORT(myFunctionType != nullptr);
+        }
+
+        // The function should be overloaded since there are multiple functions with different
+        // signatures
+        if (myFunctionType->isOverloaded())
+        {
+            // If it's overloaded, verify we can access both variants
+            SLANG_CHECK(myFunctionType->getOverloadCount() >= 2);
+
+            for (int i = 0; i < myFunctionType->getOverloadCount(); i++)
+            {
+                auto overload = myFunctionType->getOverload(i);
+
+                for (int j = 0; j < overload->getParameterCount(); j++)
+                {
+                    auto paramTypeName = overload->getParameterByIndex(j)->getType()->getName();
+                    if (strcmp(paramTypeName, "int") != 0)
+                    {
+                        SLANG_CHECK(false && "Expected different parameter signatures");
+                    }
+                }
+            }
+        }
+        else
+        {
+            // The function should be overloaded since there are multiple functions with different
+            // signatures. If it's not overloaded, the fix didn't work properly.
+            SLANG_CHECK_ABORT(
+                false && "Expected function to be overloaded with multiple signatures");
+        }
+    }
+}