MVP for higher order functions (#2849)

* MVP for higher order functions

* Add shader subgroup partitioned glsl intrinsics

* Implement parsing and checking for tuple types

Currently there is no way to do anything useful with them from the source language however

* neaten

* Correct precedence of function type parsing

* neaten

* higher order function tests

* function types of any arity

* Inference for higher order functions

* Add second test for unsynchronized params

* regenerate vs projects

* dx11 -> dx12 for saturated cooperations tests

* Disable saturated cooperation tests on vulkan

They fail on release builds in CI, not essential for the higher order function work however

* remove saturated-cooperation tests

* Remove unnecessary assert and clarify control flow in AddDeclRefOverloadCandidates

* Add Tuple type name mangling

* Use functype keyword to introduce function types

* Add more inference tests for hof

---------

Co-authored-by: Yong He <yonghe@outlook.com>

1 files changed, 41 insertions, 0 deletions

diff --git a/source/slang/slang-check-overload.cpp b/source/slang/slang-check-overload.cpp
index f2947a55d..5160f3c6f 100644
--- a/source/slang/slang-check-overload.cpp
+++ b/source/slang/slang-check-overload.cpp
@@ -412,6 +412,8 @@ namespace Slang
 
             if (context.mode == OverloadResolveContext::Mode::JustTrying)
             {
+                SLANG_ASSERT(argType);
+
                 ConversionCost cost = kConversionCost_None;
                 if( context.disallowNestedConversions )
                 {
@@ -1138,6 +1140,21 @@ namespace Slang
         AddOverloadCandidate(context, candidate);
     }
 
+    void SemanticsVisitor::AddFuncExprOverloadCandidate(
+        FuncType*        funcType,
+        OverloadResolveContext& context,
+        Expr* expr)
+    {
+        SLANG_ASSERT(expr);
+        OverloadCandidate candidate;
+        candidate.flavor = OverloadCandidate::Flavor::Expr;
+        candidate.funcType = funcType;
+        candidate.resultType = funcType->getResultType();
+        candidate.exprVal = expr;
+
+        AddOverloadCandidate(context, candidate);
+    }
+
     void SemanticsVisitor::AddCtorOverloadCandidate(
         LookupResultItem            typeItem,
         Type*                type,
@@ -1432,9 +1449,23 @@ namespace Slang
             auto type = DeclRefType::create(m_astBuilder, genericTypeParamDeclRef);
             AddTypeOverloadCandidates(type, context);
         }
+        else if( auto localDeclRef = item.declRef.as<ParamDecl>() )
+        {
+            // We could probably be broader than just parameters here
+            // eventually.
+            // Limit it for now though to make the specialization easier
+            ensureDecl(localDeclRef, DeclCheckState::CanUseFuncSignature);
+            const auto type = localDeclRef.getDecl()->getType();
+            // We can only add overload candidates if this is known to be a function
+            if(const auto funType = as<FuncType>(type))
+                AddFuncExprOverloadCandidate(funType, context, context.originalExpr->functionExpr);
+            else
+                return;
+        }
         else
         {
             // TODO(tfoley): any other cases needed here?
+            return;
         }
     }
 
@@ -1671,6 +1702,16 @@ namespace Slang
         {
             if (IsErrorExpr(arg))
                 return CreateErrorExpr(expr);
+
+            // If this argument is itself an overloaded value without a type
+            // then we can't sensibly continue
+            if(!arg->type && (as<OverloadedExpr>(arg) || as<OverloadedExpr2>(arg)))
+            {
+                getSink()->diagnose(
+                    expr->loc,
+                    Diagnostics::overloadedParameterToHigherOrderFunction);
+                return CreateErrorExpr(expr);
+            }
         }
 
         for (auto& arg : expr->arguments)