@bikky/replication 1.0.2 → 1.0.4

package/Expressions/Compiler/Grammar/ControlFlow.d.ts

@@ -0,0 +1,38 @@
+import { NodeType } from "../Parser/Enums.js";
+import { GrammarInterfaces } from "../Parser/Interfaces.js";
+import { BlockNode, ExpressionNode, StatementNode } from "./General.js";
+import EAST_Complex_Node = GrammarInterfaces.EAST_Complex_Node;
+import Node = GrammarInterfaces.Node;
+export declare const CONTROL_FLOW_STATEMENTS: NodeType[];
+type ControlFlowLoopNodes = BreakNode | ContinueNode;
+export declare function IsLoopNode(node: Node): node is ForNode | WhileNode;
+export declare function IsControlFlowNode(node: Node): node is ContinueNode | BreakNode;
+export interface ContinueNode extends GrammarInterfaces.EAST_Complex_Node {
+    type: NodeType.CONTINUE;
+    values: undefined;
+}
+export declare function IsContinueNode(node: Node): node is ContinueNode;
+export interface BreakNode extends EAST_Complex_Node {
+    type: NodeType.BREAK;
+    values: undefined;
+}
+export declare function IsBreakNode(node: Node): node is BreakNode;
+export interface WhileNode extends EAST_Complex_Node {
+    type: NodeType.WHILE_LOOP;
+    values: {
+        test: ExpressionNode;
+        body: BlockNode<ControlFlowLoopNodes> | StatementNode;
+    };
+}
+export declare function IsWhileNode(node: Node): node is WhileNode;
+export interface ForNode extends GrammarInterfaces.EAST_Complex_Node {
+    type: NodeType.FOR_LOOP;
+    values: {
+        initialiser: ExpressionNode;
+        test: ExpressionNode;
+        incrementer: ExpressionNode;
+        body: BlockNode<ControlFlowLoopNodes> | StatementNode;
+    };
+}
+export declare function IsForNode(node: Node): node is ForNode;
+export {};

package/Expressions/Compiler/Grammar/ControlFlow.js

@@ -0,0 +1,178 @@
+import { NodeType, TokenType } from "../Parser/Enums.js";
+import { GrammarInterfaces } from "../Parser/Interfaces.js";
+import { GrammarRegistry } from "../GrammarRegistry.js";
+import { Versions } from "../../../Constants/Versions.js";
+var SpecialType = GrammarInterfaces.SpecialType;
+var ExpressionSyntaxError = GrammarRegistry.ExpressionSyntaxError;
+import { ChainBoolean } from "../../TypeRegistry/Primitive.js";
+import { CreateChildScope } from "../../TypeRegistry/Types.js";
+export const CONTROL_FLOW_STATEMENTS = [NodeType.FOR_LOOP, NodeType.WHILE_LOOP, NodeType.DOWHILE_LOOP, NodeType.IF];
+const CONTROL_FLOW_LOOP = [NodeType.BREAK, NodeType.CONTINUE];
+//-------------------------------------------------LOOPS-----------------------------------------------
+export function IsLoopNode(node) {
+    return node.type === NodeType.FOR_LOOP || node.type === NodeType.WHILE_LOOP || node.type === NodeType.DOWHILE_LOOP;
+}
+export function IsControlFlowNode(node) {
+    return node.type === NodeType.CONTINUE || node.type === NodeType.BREAK || node.type === NodeType.RETURN;
+}
+export function IsContinueNode(node) {
+    return node.type === NodeType.CONTINUE;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.CONTINUE, [[
+        { type: TokenType.KEYWORD, value: "continue" },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]], {
+    runtimeExecute(scope, currentNode, outputType) {
+        return {
+            interrupt: "continue",
+            type: null,
+            value: null
+        };
+    },
+    compileTimeTraversal(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Continue statements cannot return values", currentNode);
+        }
+        return null;
+    }
+});
+export function IsBreakNode(node) {
+    return node.type === NodeType.BREAK;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.BREAK, [[
+        { type: TokenType.KEYWORD, value: "break" },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]], {
+    runtimeExecute(scope, currentNode, outputType) {
+        return {
+            interrupt: "break",
+            type: null,
+            value: null
+        };
+    },
+    compileTimeTraversal(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Break statements cannot return values", currentNode);
+        }
+        return null;
+    }
+});
+export function IsWhileNode(node) {
+    return node.type === NodeType.WHILE_LOOP;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.WHILE_LOOP, [[
+        { type: TokenType.KEYWORD, value: "while" },
+        { type: TokenType.OPERATOR, value: "(" },
+        { type: NodeType.EXPRESSION, name: "test" },
+        { type: TokenType.OPERATOR, value: ")" },
+        {
+            type: [NodeType.BLOCK, NodeType.STATEMENT],
+            input: [...CONTROL_FLOW_LOOP, GrammarInterfaces.SpecialType.INPUT_TYPES],
+            name: "body"
+        }
+    ]], {
+    runtimeExecute(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Loops cannot return values", currentNode);
+        }
+        // Create a new scope for the loop
+        let loopScope = CreateChildScope(scope);
+        while (true) {
+            // Evaluate the test condition
+            let testResult = currentNode.values.test.execute.runtimeExecute(loopScope, currentNode.values.test, [ChainBoolean]);
+            if (!testResult.value) {
+                break;
+            }
+            // Execute the body
+            let bodyResult = currentNode.values.body.execute.runtimeExecute(loopScope, currentNode.values.body, null);
+            // Handle control flow statements
+            if (bodyResult.interrupt === "break") {
+                break;
+            }
+            if (bodyResult.interrupt === "return") {
+                return bodyResult;
+            }
+        }
+        return {
+            type: null,
+            value: null
+        };
+    },
+    compileTimeTraversal(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Loops cannot return values", currentNode);
+        }
+        // Create a new scope for the loop body
+        let bodyScope = CreateChildScope(scope);
+        // Ensure the test condition is a boolean
+        currentNode.values.test.execute.compileTimeTraversal(bodyScope, currentNode.values.test, [ChainBoolean]);
+        // Traverse the body
+        currentNode.values.body.execute.compileTimeTraversal(bodyScope, currentNode.values.body, null);
+        return null;
+    }
+});
+export function IsForNode(node) {
+    return node.type === NodeType.FOR_LOOP;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.FOR_LOOP, [[
+        { type: TokenType.KEYWORD, value: "for" },
+        { type: TokenType.OPERATOR, value: "(" },
+        { type: NodeType.EXPRESSION, name: "initialiser" },
+        { type: TokenType.OPERATOR, value: ";" },
+        { type: NodeType.EXPRESSION, name: "test" },
+        { type: TokenType.OPERATOR, value: ";" },
+        { type: NodeType.EXPRESSION, name: "incrementer" },
+        { type: TokenType.OPERATOR, value: ")" },
+        {
+            type: [NodeType.BLOCK, NodeType.STATEMENT],
+            input: [...CONTROL_FLOW_LOOP, SpecialType.INPUT_TYPES],
+            name: "body"
+        }
+    ]], {
+    runtimeExecute(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Loops cannot return values", currentNode);
+        }
+        // Create a new scope for the loop
+        let loopScope = CreateChildScope(scope);
+        currentNode.values.initialiser.execute.runtimeExecute(loopScope, currentNode.values.initialiser, null);
+        while (true) {
+            // Evaluate the test condition
+            let testResult = currentNode.values.test.execute.runtimeExecute(loopScope, currentNode.values.test, [ChainBoolean]);
+            if (!testResult.value) {
+                break;
+            }
+            // Execute the body
+            let bodyResult = currentNode.values.body.execute.runtimeExecute(loopScope, currentNode.values.body, null);
+            // Handle control flow statements
+            if (bodyResult.interrupt === "break") {
+                break;
+            }
+            if (bodyResult.interrupt === "return") {
+                return bodyResult;
+            }
+            currentNode.values.incrementer.execute.runtimeExecute(loopScope, currentNode.values.incrementer, null);
+        }
+        return {
+            type: null,
+            value: null
+        };
+    },
+    compileTimeTraversal(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Loops cannot return values", currentNode);
+        }
+        // Create a new scope for the loop body
+        let bodyScope = CreateChildScope(scope);
+        // Traverse the initialiser
+        currentNode.values.initialiser.execute.compileTimeTraversal(bodyScope, currentNode.values.initialiser, null);
+        // Traverse the incrementer
+        currentNode.values.incrementer.execute.compileTimeTraversal(bodyScope, currentNode.values.incrementer, null);
+        // Ensure the test condition is a boolean
+        currentNode.values.test.execute.compileTimeTraversal(bodyScope, currentNode.values.test, [ChainBoolean]);
+        // Traverse the body
+        currentNode.values.body.execute.compileTimeTraversal(bodyScope, currentNode.values.body, null);
+        return null;
+    }
+});
+//# sourceMappingURL=ControlFlow.js.map

package/Expressions/Compiler/Grammar/ControlFlow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ControlFlow.js","sourceRoot":"","sources":["ControlFlow.ts"],"names":[],"mappings":"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"}

package/Expressions/Compiler/Grammar/Declarations.d.ts

@@ -0,0 +1,22 @@
+import { NodeType } from "../Parser/Enums.js";
+import { GrammarInterfaces } from "../Parser/Interfaces.js";
+import { ExpressionNode } from "./General.js";
+import Node = GrammarInterfaces.Node;
+import EAST_Token = GrammarInterfaces.EAST_Token;
+import { TypeDefinitionNode, TypeUnionNode } from "./Types.js";
+export interface DeclarationEntryNode extends GrammarInterfaces.EAST_Complex_Node {
+    type: NodeType.DECLARATION_ENTRY;
+    values: {
+        name: EAST_Token;
+        type: TypeDefinitionNode | TypeUnionNode;
+        initialiser?: ExpressionNode;
+    };
+}
+export declare function IsDeclarationEntryNode(node: Node): node is DeclarationEntryNode;
+export interface DeclarationNode extends GrammarInterfaces.EAST_Complex_Node {
+    type: NodeType.DECLARATION;
+    values: {
+        declarations: DeclarationEntryNode[];
+    };
+}
+export declare function IsDeclarationNode(node: Node): node is DeclarationNode;

package/Expressions/Compiler/Grammar/Declarations.js

@@ -0,0 +1,84 @@
+import { NodeType, TokenType } from "../Parser/Enums.js";
+import { GrammarRegistry } from "../GrammarRegistry.js";
+import { Versions } from "../../../Constants/Versions.js";
+var ExpressionSyntaxError = GrammarRegistry.ExpressionSyntaxError;
+export function IsDeclarationEntryNode(node) {
+    return node.type === NodeType.DECLARATION_ENTRY;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.DECLARATION_ENTRY, [[
+        { type: TokenType.IDENTIFIER, name: "name" },
+        { type: TokenType.OPERATOR, value: ":" },
+        { type: [NodeType.TYPE_UNION, NodeType.TYPE_DEFINITION], name: "type" }, //TODO: Make this optional - only if type can be inferred from initialiser?
+        { type: TokenType.OPERATOR, value: "=", optional: true },
+        { type: NodeType.EXPRESSION, name: "initialiser", optional: "previous" }
+    ]], {
+    runtimeExecute(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Declarations do not return values", currentNode);
+        }
+        const type = currentNode.values.type.execute.runtimeExecute(scope, currentNode.values.type, outputType);
+        if (!type?.type) {
+            throw new ExpressionSyntaxError("Declaration type must not be never", currentNode);
+        }
+        if (currentNode.values.initialiser) {
+            const result = currentNode.values.initialiser.execute.runtimeExecute(scope, currentNode.values.initialiser, [type.type]);
+            return {
+                type: type.type,
+                value: result.value
+            };
+        }
+        return {
+            type: type.type,
+            value: undefined
+        };
+    },
+    compileTimeTraversal(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Declarations do not return values", currentNode);
+        }
+        const type = currentNode.values.type.execute.compileTimeTraversal(scope, currentNode.values.type, outputType);
+        if (!type?.type) {
+            throw new ExpressionSyntaxError("Declaration type must not be never", currentNode);
+        }
+        if (currentNode.values.initialiser) {
+            currentNode.values.initialiser.execute.compileTimeTraversal(scope, currentNode.values.initialiser, type.type);
+        }
+        return type;
+    }
+});
+export function IsDeclarationNode(node) {
+    return node.type === NodeType.DECLARATION;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.DECLARATION, [[
+        { type: TokenType.KEYWORD, values: ["const", "var"], name: "qualifiers", repeat: [1, Number.POSITIVE_INFINITY] },
+        {
+            type: NodeType.DECLARATION_ENTRY,
+            name: "declarations",
+            repeat: [1, Number.POSITIVE_INFINITY],
+            repeatSeparator: { type: TokenType.OPERATOR, value: "," }
+        },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]], {
+    runtimeExecute(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Declarations do not return values", currentNode);
+        }
+        for (const decl of currentNode.values.declarations) {
+            decl.execute.runtimeExecute(scope, decl, null);
+        }
+        return {
+            type: null,
+            value: null
+        };
+    },
+    compileTimeTraversal(scope, currentNode, outputType) {
+        if (outputType !== null) {
+            throw new ExpressionSyntaxError("Declarations do not return values", currentNode);
+        }
+        for (const decl of currentNode.values.declarations) {
+            decl.execute.compileTimeTraversal(scope, decl, null);
+        }
+        return null;
+    }
+});
+//# sourceMappingURL=Declarations.js.map

package/Expressions/Compiler/Grammar/Declarations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Declarations.js","sourceRoot":"","sources":["Declarations.ts"],"names":[],"mappings":"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"}

package/Expressions/Compiler/Grammar/Function.d.ts

@@ -0,0 +1,30 @@
+import { GrammarInterfaces } from "../Parser/Interfaces.js";
+import { NodeType } from "../Parser/Enums.js";
+import EAST_Token = GrammarInterfaces.EAST_Token;
+import Node = GrammarInterfaces.Node;
+import { BlockNode, ExpressionNode, ParenthetisedExpressionNode } from "./General.js";
+import { DeclarationEntryNode } from "./Declarations.js";
+import { TypeDefinitionNode } from "./Types.js";
+export interface FunctionDeclarationNode extends GrammarInterfaces.EAST_Complex_Node {
+    type: NodeType.FUNCTION_DECLARATION;
+    values: {
+        name: EAST_Token;
+        parameters: DeclarationEntryNode[];
+        returnType?: TypeDefinitionNode;
+        body: BlockNode<ReturnNode>;
+    };
+}
+export declare function IsFunctionDeclarationNode(node: Node): node is FunctionDeclarationNode;
+export interface FunctionCallNode extends GrammarInterfaces.EAST_Complex_Node {
+    type: NodeType.FUNCTION_CALL;
+    values: {
+        name: EAST_Token | ParenthetisedExpressionNode;
+        arguments: ExpressionNode[];
+    };
+}
+export declare function IsFunctionCallNode(node: Node): node is FunctionCallNode;
+export interface ReturnNode extends GrammarInterfaces.EAST_Complex_Node {
+    type: NodeType.RETURN;
+    values: ExpressionNode["values"];
+}
+export declare function IsReturnNode(node: Node): node is ReturnNode;

package/Expressions/Compiler/Grammar/Function.js

@@ -0,0 +1,292 @@
+import { GrammarInterfaces } from "../Parser/Interfaces.js";
+import { CollectionType, NodeType, TokenType } from "../Parser/Enums.js";
+import { GrammarRegistry } from "../GrammarRegistry.js";
+import { Versions } from "../../../Constants/Versions.js";
+import { CreateChildScope } from "../../TypeRegistry/Types.js";
+var ExpressionSyntaxError = GrammarRegistry.ExpressionSyntaxError;
+import { describeObject } from "../../../Constants/SerialisationTypes.js";
+var isAssignableCompile = GrammarInterfaces.isAssignableCompile;
+import { ErrorStack } from "../../../Constants/Errors.js";
+import { isToken } from "./Tokens.js";
+export function IsFunctionDeclarationNode(node) {
+    return node.type === NodeType.FUNCTION_DECLARATION;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.FUNCTION_DECLARATION, [[
+        { type: TokenType.IDENTIFIER, value: "function" },
+        { type: TokenType.IDENTIFIER, name: "name" },
+        { type: TokenType.OPERATOR, value: "(" },
+        {
+            type: NodeType.DECLARATION_ENTRY,
+            name: "parameters",
+            repeat: [0, Number.POSITIVE_INFINITY],
+            repeatSeparator: { type: TokenType.OPERATOR, value: "," }
+        },
+        { type: TokenType.OPERATOR, value: ")" },
+        { type: [NodeType.TYPE_UNION, NodeType.TYPE_DEFINITION], name: "returnType", optional: true },
+        { type: NodeType.BLOCK, input: [NodeType.RETURN], name: "body" }
+    ]], {
+    runtimeExecute(scope, node, outputType) {
+        if (Array.isArray(outputType)) {
+            throw new ExpressionSyntaxError(`A function cannot be assigned this variable`, node);
+        }
+        let type = (node.execute.compileTimeTraversal(scope, node, outputType)?.type)[0];
+        let foo = (callingNode, ...args) => {
+            let contentScope = CreateChildScope(scope);
+            for (let i = 0; i < node.values.parameters.length; i++) {
+                let param = node.values.parameters[i];
+                let paramValue = args[i].value ?? param.execute.runtimeExecute(contentScope, param, type.parameters[i].type).value;
+                let paramType = type.parameters[i].type.find((e) => e.kind == "value" && e.isAssignableLive(scope.version, paramValue));
+                if (!paramType) {
+                    throw new ExpressionSyntaxError(`Invalid parameter type for function.`
+                        + ` ${describeObject(param)} is not assignable to `
+                        + `${type.parameters[i].type.map((e) => describeObject(e)).join(" | ")}`, callingNode);
+                }
+                contentScope.local[type.parameters[i].assignmentName] = {
+                    value: paramValue,
+                    type: [paramType]
+                };
+            }
+            let returnType = node.values.body.execute.runtimeExecute(contentScope, node.values.body, outputType);
+            if (!Array.isArray(returnType.type) && returnType.type) {
+                throw new ExpressionSyntaxError(`Cannot yet return functions from functions`, node);
+            }
+            let result = node.values.body.execute.runtimeExecute(contentScope, node.values.body, returnType.type);
+            return {
+                type: returnType.type,
+                value: result.value
+            };
+        };
+        foo.type = type;
+        scope.local[node.values.name.data] = {
+            value: foo,
+            type: [type],
+        };
+        return {
+            value: foo,
+            type: null
+        };
+    },
+    compileTimeTraversal(scope, node, expectedTypes) {
+        let contentScope = CreateChildScope(scope);
+        // Validate parameters
+        let finalParamTypes = [];
+        for (let i = 0; i < node.values.parameters.length; i++) {
+            let param = node.values.parameters[i];
+            let paramType = param.execute.compileTimeTraversal(contentScope, param, null);
+            if (!paramType || !paramType.type) {
+                throw new ExpressionSyntaxError(`Function parameters failed to resolve.`, node);
+            }
+            if (!paramType.assignmentName) {
+                throw new ExpressionSyntaxError(`Function parameter's name must be defined.`, node);
+            }
+            finalParamTypes.push({
+                outputType: paramType.type,
+                assignmentName: paramType.assignmentName,
+            });
+        }
+        // Validate return type
+        let returnTypes = node.values.returnType?.execute?.compileTimeTraversal(scope, node.values.returnType, null);
+        // Add the function to the scope
+        let functionType = {
+            kind: "function",
+            parameters: finalParamTypes.map((param) => ({
+                type: param.outputType,
+                assignmentName: param.assignmentName,
+            })),
+            returnType: returnTypes?.type ?? null,
+        };
+        if (expectedTypes) {
+            let stack = new ErrorStack({ Version: scope.version, SourceFile: node.file.sourceLocation });
+            if (!isAssignableCompile(scope.version, expectedTypes, [functionType], node, stack)) {
+                throw new ExpressionSyntaxError(`Function return type does not match the expected type.` + stack.toString(`EXP_GF_FOO_01`), node);
+            }
+        }
+        scope.local[node.values.name.data] = {
+            type: [functionType],
+        };
+        // Traverse the function body
+        node.values.body.execute.compileTimeTraversal(contentScope, node.values.body, returnTypes?.type ?? null);
+        return {
+            type: [functionType],
+            assignmentName: node.values.name.data
+        };
+    }
+});
+export function IsFunctionCallNode(node) {
+    return node.type === NodeType.FUNCTION_CALL;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.FUNCTION_CALL, [[
+        {
+            // Function name - Builtin, identifier
+            // or a parenthetised expression that returns a function as a value.
+            type: [TokenType.BUILTIN, NodeType.PARENTHETISED_EXPRESSION, TokenType.IDENTIFIER],
+            name: "name"
+        },
+        { type: TokenType.OPERATOR, value: "(" },
+        {
+            type: NodeType.EXPRESSION,
+            name: "arguments",
+            repeat: [0, Number.POSITIVE_INFINITY],
+            repeatSeparator: { type: TokenType.OPERATOR, value: "," }
+        },
+        { type: TokenType.OPERATOR, value: ")" }
+    ]], {
+    runtimeExecute(scope, node, outputType) {
+        const funcName = isToken(node.values.name) ? node.values.name.data
+            : node.values.name.execute.runtimeExecute(scope, node.values.name, null).value;
+        const funcValue = scope.local[funcName] ?? scope.global[funcName];
+        if (!funcValue.type) {
+            throw new Error(`Function does not have typing information set`);
+        }
+        //Use first matching type.
+        let funcType = undefined;
+        for (let type of funcValue.type) {
+            if (type.kind === "function" && funcValue.value.type == type) {
+                funcType = type;
+                break;
+            }
+        }
+        if (!funcType) {
+            throw new ExpressionSyntaxError(`Function's value does not match expected function's type.`, node);
+        }
+        const inputArgNodes = node.values.arguments;
+        // Check parameter count
+        if (funcType.parameters.length !== inputArgNodes.length) {
+            throw new ExpressionSyntaxError(`Function expected ${funcType.parameters.length} argument(s), but got ${inputArgNodes.length}`, node);
+        }
+        let inputArgValues = [];
+        for (let i = 0; i < inputArgNodes.length; i++) {
+            const arg = inputArgNodes[i];
+            let argResult = arg.execute.runtimeExecute(scope, arg, null);
+            let argResultType = argResult.castType ?? (argResult.type ? [argResult.type] : null);
+            let stack = new ErrorStack({ Version: scope.version, SourceFile: node.file.sourceLocation });
+            if (!isAssignableCompile(scope.version, funcType.parameters[i].type, argResultType, arg, stack)) {
+                throw new ExpressionSyntaxError(`Argument ${i + 1} type mismatch: ${describeObject(argResult.value)} is not assignable to any of [${funcType.parameters[i].type.map(e => e.kind == "function" ? "function" : e.debugName).join(", ")}]` + stack.toString(`EXP_GF_FC_02`), node);
+            }
+            inputArgValues.push(argResult.value);
+        }
+        // Call the function
+        const result = funcValue.value(node, ...inputArgValues);
+        let stack = new ErrorStack({ Version: scope.version, SourceFile: node.file.sourceLocation });
+        if (!isAssignableCompile(scope.version, outputType, result, node, stack)) {
+            throw new ExpressionSyntaxError(`Function return type mismatch: ${describeObject(result.value)} is not assignable to any of [${outputType?.map(e => e.kind == "function" ? "function" : e.debugName).join(", ")}]` + stack.toString(`EXP_GF_FC_03`), node);
+        }
+        return {
+            value: result.value,
+            type: result.type
+        };
+    },
+    compileTimeTraversal(scope, node, expectedType) {
+        const nameVal = node.values.name;
+        const argNodes = node.values.arguments;
+        let possibleFuncTypes = [];
+        if (isToken(nameVal)) {
+            // (1) It's a function name token
+            const funcName = nameVal.data;
+            const funcEntry = scope.local[funcName] ?? scope.global[funcName];
+            if (!funcEntry) {
+                throw new ExpressionSyntaxError(`Function '${funcName}' not found in scope`, node);
+            }
+            if (!funcEntry.type) {
+                throw new ExpressionSyntaxError(`Function '${funcName}' has no type info`, node);
+            }
+            // We gather only the function types; if we find a non-function, we throw an error
+            funcEntry.type.forEach(t => {
+                if (t.kind === "function") {
+                    possibleFuncTypes.push(t);
+                }
+                else {
+                    throw new ExpressionSyntaxError(`Type mismatch: '${funcName}' is not a function type`, node);
+                }
+            });
+            if (possibleFuncTypes.length === 0) {
+                throw new ExpressionSyntaxError(`'${funcName}' is not a valid function`, node);
+            }
+        }
+        else {
+            // (2) It's an expression => interpret as an inline function declaration
+            const funcTypeInfo = nameVal.execute.compileTimeTraversal(scope, nameVal, null);
+            const inlineTypes = funcTypeInfo?.type ?? [];
+            if (inlineTypes.length === 0) {
+                throw new ExpressionSyntaxError(`Inline function expression has no type`, node);
+            }
+            // If we find any type that is not a function, we throw
+            inlineTypes.forEach(t => {
+                if (t.kind !== "function") {
+                    throw new ExpressionSyntaxError(`Inline expression is not a function`, node);
+                }
+                else {
+                    possibleFuncTypes.push(t);
+                }
+            });
+            if (possibleFuncTypes.length === 0) {
+                throw new ExpressionSyntaxError(`Inline function expression is invalid`, node);
+            }
+        }
+        // Next, we match arguments to a candidate function signature
+        const argCount = argNodes.length;
+        let matchedType = null;
+        let errorStack = new ErrorStack({ Version: scope.version, SourceFile: node.file.sourceLocation });
+        //Candidate loop
+        for (const candidate of possibleFuncTypes) {
+            // Check param count
+            if (candidate.parameters.length !== argCount) {
+                continue; // not a match
+            }
+            // Verify each argument
+            let success = true;
+            for (let i = 0; i < argCount; i++) {
+                const argOutput = argNodes[i].execute.compileTimeTraversal(scope, argNodes[i], null);
+                // This function checks if any of argOutput.type is assignable to candidate.parameters[i].type
+                const argAssignable = isAssignableCompile(scope.version, candidate.parameters[i].type, argOutput?.type ?? null, node, errorStack);
+                if (!argAssignable) {
+                    success = false;
+                    break; // argument mismatch => candidate fails
+                }
+            }
+            if (!success) {
+                continue;
+            }
+            // If arguments matched, check return type vs expected
+            if (expectedType && !isAssignableCompile(scope.version, expectedType, candidate.returnType, node, errorStack)) {
+                continue; // This candidate doesn't match the expected return type
+            }
+            // We have a match
+            matchedType = candidate;
+            break;
+        }
+        if (!matchedType) {
+            throw new ExpressionSyntaxError(`No matching function signature found for call (${argCount} args)\n` + errorStack.toString("EXP_GF_FC_05"), node);
+        }
+        // Return the matched function's return type
+        return {
+            type: matchedType.returnType,
+            style: CollectionType.Single
+        };
+    }
+});
+export function IsReturnNode(node) {
+    return node.type === NodeType.RETURN;
+}
+GrammarRegistry.AddRule(Versions.v1_0_0, NodeType.RETURN, [[
+        { type: TokenType.KEYWORD, value: "return" },
+        { type: NodeType.EXPRESSION, unroll: true },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]], {
+    runtimeExecute(scope, node, outputType) {
+        let result = node.values.expression.execute.runtimeExecute(scope, node.values.expression, null);
+        return {
+            type: result.type,
+            value: result.value,
+            interrupt: "return"
+        };
+    },
+    compileTimeTraversal(scope, node, expectedTypes) {
+        let result = node.values.expression.execute.compileTimeTraversal(scope, node.values.expression, expectedTypes);
+        return {
+            interrupt: "return",
+            type: result?.type ?? null,
+        };
+    }
+});
+//# sourceMappingURL=Function.js.map