WHLSLResolveOverloadImpl.cpp [plain text]
#include "config.h"
#include "WHLSLResolveOverloadImpl.h"
#if ENABLE(WEBGPU)
#include "WHLSLFunctionDeclaration.h"
#include "WHLSLFunctionDefinition.h"
#include "WHLSLInferTypes.h"
#include <limits>
namespace WebCore {
namespace WHLSL {
static unsigned conversionCost(AST::FunctionDeclaration& candidate, const Vector<std::reference_wrapper<ResolvingType>>& argumentTypes)
{
unsigned conversionCost = 0;
for (size_t i = 0; i < candidate.parameters().size(); ++i) {
conversionCost += argumentTypes[i].get().visit(WTF::makeVisitor([&](Ref<AST::UnnamedType>&) -> unsigned {
return 0;
}, [&](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> unsigned {
return resolvableTypeReference->resolvableType().conversionCost(*candidate.parameters()[i]->type());
}));
}
return conversionCost;
}
template <typename TypeKind>
static AST::FunctionDeclaration* resolveFunctionOverloadImpl(Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>& possibleFunctions, Vector<std::reference_wrapper<ResolvingType>>& argumentTypes, TypeKind* castReturnType, AST::NameSpace nameSpace)
{
Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1> candidates;
for (auto& possibleFunction : possibleFunctions) {
if (possibleFunction.get().entryPointType())
continue;
if (nameSpace == AST::NameSpace::StandardLibrary) {
if (possibleFunction.get().nameSpace() != AST::NameSpace::StandardLibrary)
continue;
} else {
if (possibleFunction.get().nameSpace() != AST::NameSpace::StandardLibrary && possibleFunction.get().nameSpace() != nameSpace)
continue;
}
if (inferTypesForCall(possibleFunction.get(), argumentTypes, castReturnType))
candidates.append(possibleFunction.get());
}
unsigned minimumConversionCost = std::numeric_limits<unsigned>::max();
for (auto& candidate : candidates)
minimumConversionCost = std::min(minimumConversionCost, conversionCost(candidate.get(), argumentTypes));
Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1> minimumCostCandidates;
for (auto& candidate : candidates) {
if (conversionCost(candidate.get(), argumentTypes) == minimumConversionCost)
minimumCostCandidates.append(candidate);
}
if (minimumCostCandidates.size() == 1)
return &minimumCostCandidates[0].get();
return nullptr;
}
AST::FunctionDeclaration* resolveFunctionOverload(Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>& possibleFunctions, Vector<std::reference_wrapper<ResolvingType>>& argumentTypes, AST::NameSpace nameSpace)
{
return resolveFunctionOverloadImpl(possibleFunctions, argumentTypes, static_cast<AST::NamedType*>(nullptr), nameSpace);
}
AST::FunctionDeclaration* resolveFunctionOverload(Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>& possibleFunctions, Vector<std::reference_wrapper<ResolvingType>>& argumentTypes, AST::NamedType* castReturnType, AST::NameSpace nameSpace)
{
return resolveFunctionOverloadImpl(possibleFunctions, argumentTypes, castReturnType, nameSpace);
}
AST::FunctionDeclaration* resolveFunctionOverload(Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>& possibleFunctions, Vector<std::reference_wrapper<ResolvingType>>& argumentTypes, AST::UnnamedType* castReturnType, AST::NameSpace nameSpace)
{
return resolveFunctionOverloadImpl(possibleFunctions, argumentTypes, castReturnType, nameSpace);
}
AST::NamedType* resolveTypeOverloadImpl(Vector<std::reference_wrapper<AST::NamedType>, 1>& possibleTypes, AST::TypeArguments& typeArguments)
{
AST::NamedType* result = nullptr;
for (auto& possibleType : possibleTypes) {
if (inferTypesForTypeArguments(possibleType, typeArguments)) {
if (result)
return nullptr;
result = &static_cast<AST::NamedType&>(possibleType);
}
}
return result;
}
}
}
#endif // ENABLE(WEBGPU)