Expose exported function signatures for host-side invocation

Author: pchalamet

src/FScript.Runtime/ScriptHost.fs

@@ -4,10 +4,17 @@ open System.IO
 open FScript.Language
 
 module ScriptHost =
+    type FunctionSignature =
+        { Name: string
+          ParameterNames: string list
+          ParameterTypes: Type list
+          ReturnType: Type }
+
     type LoadedScript =
         { TypeDefs: Map<string, Type>
           Env: Env
           ExportedFunctionNames: string list
+          ExportedFunctionSignatures: Map<string, FunctionSignature>
           ExportedValueNames: string list
           LastValue: Value }
 
@@ -25,6 +32,47 @@ module ScriptHost =
             | TypeInfer.TSLetRecGroup(bindings, isExported, _) when isExported -> bindings |> List.map (fun (name, _, _, _) -> name)
             | _ -> [])
 
+    let private flattenFunctionType (t: Type) : Type list * Type =
+        let rec loop (acc: Type list) (current: Type) =
+            match current with
+            | TFun (arg, ret) -> loop (arg :: acc) ret
+            | _ -> List.rev acc, current
+        loop [] t
+
+    let private flattenParameterNames (expr: Expr) : string list =
+        let rec loop (acc: string list) (current: Expr) =
+            match current with
+            | ELambda (param, body, _) -> loop (param.Name :: acc) body
+            | _ -> List.rev acc
+        loop [] expr
+
+    let private collectFunctionSignatures (program: TypeInfer.TypedProgram) : Map<string, FunctionSignature> =
+        let fromLet name expr exprType =
+            let paramNames = flattenParameterNames expr
+            let parameterTypes, returnType = flattenFunctionType exprType
+            if paramNames.IsEmpty || parameterTypes.IsEmpty then
+                None
+            elif paramNames.Length <> parameterTypes.Length then
+                raise (HostCommon.evalError $"Signature mismatch for function '{name}'")
+            else
+                Some (name,
+                      { Name = name
+                        ParameterNames = paramNames
+                        ParameterTypes = parameterTypes
+                        ReturnType = returnType })
+
+        program
+        |> List.collect (function
+            | TypeInfer.TSLet(name, expr, exprType, _, isExported, _) when isExported ->
+                match fromLet name expr exprType with
+                | Some signature -> [ signature ]
+                | None -> []
+            | TypeInfer.TSLetRecGroup(bindings, isExported, _) when isExported ->
+                bindings
+                |> List.choose (fun (name, expr, exprType, _) -> fromLet name expr exprType)
+            | _ -> [])
+        |> Map.ofList
+
     let loadSource (externs: ExternalFunction list) (source: string) : LoadedScript =
         let program = FScript.parse source
         let typed = FScript.inferWithExterns externs program
@@ -41,6 +89,10 @@ module ScriptHost =
                 | Some value -> isCallable value
                 | None -> false)
 
+        let functionSignatures =
+            collectFunctionSignatures typed
+            |> Map.filter (fun name _ -> functionNames |> List.contains name)
+
         let valueNames =
             exportedNames
             |> List.filter (fun name ->
@@ -51,6 +103,7 @@ module ScriptHost =
         { TypeDefs = state.TypeDefs
           Env = state.Env
           ExportedFunctionNames = functionNames
+          ExportedFunctionSignatures = functionSignatures
           ExportedValueNames = valueNames
           LastValue = state.LastValue }