Method processFunctionExpression

src/emitter.ts:717–811

(node: ts.FunctionExpression | ts.ArrowFunction | ts.FunctionDeclaration)

    }

    private processFunctionExpression(node: ts.FunctionExpression | ts.ArrowFunction | ts.FunctionDeclaration): void {
        if (!node.body
            || ((<any>node).body.statements
                && (<any>node).body.statements.length === 0
                && ((<any>node).body.statements).isMissingList)) {
            // function without body;
            return;
        }

        const noReturn = !this.hasReturn(node);
        const noParams = node.parameters.length === 0 && !this.hasArguments(node);
        const noCapture = !this.requireCapture(node);

        const isFunctionDeclaration = node.kind === ts.SyntaxKind.FunctionDeclaration;
        const isFunctionExpression = node.kind === ts.SyntaxKind.FunctionExpression;
        const isFunction = isFunctionDeclaration || isFunctionExpression;
        const isArrowFunction = node.kind === ts.SyntaxKind.ArrowFunction;
        const writeAsLambdaCFunction = isArrowFunction || isFunction;
        const isAnyCastRequired = node.parent.kind === ts.SyntaxKind.CallExpression || node.parent.kind === ts.SyntaxKind.ParenthesizedExpression;

        if (writeAsLambdaCFunction) {
            if (isFunctionDeclaration) {
                // named function
                this.processExpression(node.name);
                this.writer.writeString(' = ');
            } else if (isFunctionExpression && isAnyCastRequired) {
                this.writer.writeString('any(');
            }

            // lambda
            const noReturnPart = noReturn ? '' : '_R';
            const noParamsPart = noParams ? '' : '_PARAMS';
            const noCapturePart = noCapture ? '' : 'C';
            if (isArrowFunction) {
                const byReference = (<any>node).__lambda_by_reference ? '&' : '=';
                this.writer.writeString(`LMB${noReturnPart}${noParamsPart}(${byReference})`);
            } else {
                this.writer.writeString(`FN${noCapturePart}${noReturnPart}${noParamsPart}()`);
            }
        }

        if (writeAsLambdaCFunction && !noReturn) {
            this.writer.writeStringNewLine(' -> any');
        } else {
            this.writer.writeStringNewLine();
        }

        this.writer.BeginBlock();

        // read params
        if (!noParams) {
            this.writer.writeStringNewLine('HEADER');
        }

        node.parameters.forEach(element => {
            if (element.name.kind !== ts.SyntaxKind.Identifier) {
                throw new Error('Not implemented');
            }