@ugo-studio/jspp 0.3.1 → 0.3.2

package/dist/{core → interpreter/core}/codegen/declaration-handlers.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { RESERVED_VAR_NAMES_FOR_STRICT_MODE } from "../../analysis/scope.js";
+import { RESERVED_VAR_NAMES } from "../../analysis/scope.js";
 import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function visitVariableDeclarationList(node, context) {
@@ -18,8 +18,8 @@ export function visitVariableDeclaration(node, context) {
         return this.generateDestructuring(varDecl.name, rhsCode, context);
     }
     const name = varDecl.name.getText();
-    if (RESERVED_VAR_NAMES_FOR_STRICT_MODE.has(name)) {
-        throw new CompilerError(`Cannot declare a variable named '${name}' in strict mode.`, varDecl.name, "SyntaxError");
+    if (RESERVED_VAR_NAMES.has(name)) {
+        throw new CompilerError(`Cannot declare a variable named '${name}'.`, varDecl.name, "SyntaxError");
     }
     const scope = this.getScopeForNode(varDecl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
@@ -53,7 +53,7 @@ export function visitVariableDeclaration(node, context) {
             (ts.isFunctionExpression(initExpr) && !initExpr.name)) {
             const initContext = {
                 ...context,
-                lambdaName: name, // Use the variable name as function name
+                functionName: name, // Use the variable name as function name
             };
             const nativeName = this.generateUniqueName(`__${name}_native_`, context.localScopeSymbols, context.globalScopeSymbols);
             const scopeNode = ts.isVariableDeclarationList(varDecl.parent)
@@ -92,16 +92,28 @@ export function visitVariableDeclaration(node, context) {
                 return nativeLambdaCode;
             }
         }
-        initializer = " = " + initText;
+        initializer = initText;
     }
     const isLetOrConst = (varDecl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
     const shouldDeref = context.derefBeforeAssignment &&
         (!context.localScopeSymbols.has(name));
-    const assignmentTarget = shouldDeref
+    let assignmentTarget = shouldDeref
         ? this.getDerefCode(name, name, context, typeInfo)
         : (typeInfo?.needsHeapAllocation && !shouldSkipDeref
             ? `*${name}`
             : name);
+    const sym = context.localScopeSymbols.get(name) ||
+        context.globalScopeSymbols.get(name);
+    if (sym?.checks.skippedHoisting) {
+        assignmentTarget = typeInfo?.needsHeapAllocation && !shouldSkipDeref
+            ? `auto ${name}`
+            : `jspp::AnyValue ${name}`;
+        if (initializer) {
+            initializer = typeInfo?.needsHeapAllocation && !shouldSkipDeref
+                ? `std::make_shared<jspp::AnyValue>(${initializer})`
+                : initializer;
+        }
+    }
     if (nativeLambdaCode)
         nativeLambdaCode += `;\n${this.indent()}`;
     if (isLetOrConst) {
@@ -116,19 +128,19 @@ export function visitVariableDeclaration(node, context) {
                 return `${nativeLambdaCode}${assignmentTarget} = jspp::Constants::UNDEFINED`;
             }
         }
-        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget} = ${initializer}`;
     }
     // For 'var', it's a bit more complex.
     if (context.isAssignmentOnly) {
         if (!initializer)
             return "";
-        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget} = ${initializer}`;
     }
     else {
         // This case should not be hit with the new hoisting logic,
         // but is kept for safety.
         const initValue = initializer
-            ? initializer.substring(3)
+            ? initializer
             : "jspp::Constants::UNDEFINED";
         if (typeInfo?.needsHeapAllocation) {
             return `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;

package/dist/{core → interpreter/core}/codegen/destructuring-handlers.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { RESERVED_VAR_NAMES_FOR_STRICT_MODE } from "../../analysis/scope.js";
+import { RESERVED_VAR_NAMES } from "../../analysis/scope.js";
 import { CompilerError } from "../error.js";
 import { visitObjectPropertyName } from "./expression-handlers.js";
 import { CodeGenerator } from "./index.js";
@@ -13,8 +13,8 @@ export function generateDestructuring(lhs, rhsCode, context) {
     const genAssignment = (pattern, valueCode) => {
         if (ts.isIdentifier(pattern)) {
             const name = pattern.text;
-            if (RESERVED_VAR_NAMES_FOR_STRICT_MODE.has(name)) {
-                throw new CompilerError(`Cannot destructure to a variable named '${name}' in strict mode.`, pattern, "SyntaxError");
+            if (RESERVED_VAR_NAMES.has(name)) {
+                throw new CompilerError(`Cannot destructure to a variable named '${name}'.`, pattern, "SyntaxError");
             }
             const scope = this.getScopeForNode(pattern);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);

package/dist/{core → interpreter/core}/codegen/expression-handlers.js

@@ -607,7 +607,8 @@ export function visitBinaryExpression(node, context) {
             finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), visitContext, typeInfo);
         }
         // Number optimizations
-        if (typeInfo && typeInfo.type === "number") {
+        const nodeType = this.typeAnalyzer.inferNodeReturnType(binExpr.left);
+        if (nodeType === "number") {
             finalLeft = `${finalLeft}.as_double()`;
         }
     }
@@ -623,7 +624,8 @@ export function visitBinaryExpression(node, context) {
             finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
         // Number optimizations
-        if (typeInfo && typeInfo.type === "number") {
+        const nodeType = this.typeAnalyzer.inferNodeReturnType(binExpr.right);
+        if (nodeType === "number") {
             finalRight = `${finalRight}.as_double()`;
         }
     }
@@ -642,101 +644,82 @@ export function visitBinaryExpression(node, context) {
     if (opToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
         return `jspp::nullish_coalesce(${finalLeft}, ${finalRight})`;
     }
-    const isLiteral = (n) => ts.isNumericLiteral(n);
-    const supportsNativeBoolean = ts.isIfStatement(node.parent) ||
-        ts.isConditionalExpression(node.parent);
     // Native values for lhs and rhs
-    const literalLeft = isLiteral(binExpr.left)
+    const literalLeft = ts.isNumericLiteral(binExpr.left)
         ? binExpr.left.getText()
         : finalLeft;
-    const literalRight = isLiteral(binExpr.right)
+    const literalRight = ts.isNumericLiteral(binExpr.right)
         ? binExpr.right.getText()
         : finalRight;
-    // Operations that returns boolean should return the native boolean if supported
-    if (constants.booleanOperators.includes(opToken.kind) &&
-        supportsNativeBoolean) {
-        if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-            return `jspp::is_strictly_equal_to_primitive(${literalLeft}, ${literalRight})`;
-        }
-        if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-            return `jspp::is_equal_to_primitive(${literalLeft}, ${literalRight})`;
-        }
-        if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-            return `!jspp::is_strictly_equal_to_primitive(${literalLeft}, ${literalRight})`;
-        }
-        if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-            return `!jspp::is_equal_to_primitive(${literalLeft}, ${literalRight})`;
-        }
-        let funcName = "";
-        if (opToken.kind === ts.SyntaxKind.LessThanToken) {
-            funcName = "jspp::less_than_primitive";
-        }
-        if (opToken.kind === ts.SyntaxKind.LessThanEqualsToken) {
-            funcName = "jspp::less_than_or_equal_primitive";
-        }
-        if (opToken.kind === ts.SyntaxKind.GreaterThanToken) {
-            funcName = "jspp::greater_than_primitive";
-        }
-        if (opToken.kind === ts.SyntaxKind.GreaterThanEqualsToken) {
-            funcName = "jspp::greater_than_or_equal_primitive";
+    let supportsNativeValue = false;
+    const exprReturnType = this.typeAnalyzer.inferNodeReturnType(node);
+    if (exprReturnType === "boolean" &&
+        (ts.isIfStatement(node.parent) ||
+            ts.isConditionalExpression(node.parent))) {
+        supportsNativeValue = true;
+    }
+    else if (exprReturnType === "number" &&
+        context.isInsideNativeLambda &&
+        context.isInsideFunction) {
+        const funcDecl = this
+            .findEnclosingFunctionDeclarationFromReturnStatement(node);
+        if (funcDecl) {
+            const funcReturnType = this.typeAnalyzer.inferFunctionReturnType(funcDecl);
+            if (funcReturnType === "number") {
+                supportsNativeValue = true;
+            }
         }
-        // For C++ primitive literals, standard operators are fine if they map directly,
-        // but we are safe using our functions (which handle doubles correctly).
-        // Actually, for pure numeric literals like "1 < 2", we can leave it as is if we want optimization,
-        // but consistency is safer.
-        // Let's stick to valid C++ syntax for literals if possible to avoid overhead?
-        // jspp::less_than(1, 2) works.
-        return `${funcName}(${literalLeft}, ${literalRight})`;
     }
+    const method = supportsNativeValue ? "_native" : "";
     // Return boxed value
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-        return `jspp::is_strictly_equal_to(${literalLeft}, ${literalRight})`;
+        return `jspp::is_strictly_equal_to${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-        return `jspp::is_equal_to(${literalLeft}, ${literalRight})`;
+        return `jspp::is_equal_to${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-        return `jspp::not_strictly_equal_to(${literalLeft}, ${literalRight})`;
+        return `jspp::not_strictly_equal_to${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        return `jspp::not_equal_to(${literalLeft}, ${literalRight})`;
+        return `jspp::not_equal_to${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskToken) {
-        return `jspp::pow(${literalLeft}, ${literalRight})`;
+        return `jspp::pow${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken) {
-        return `jspp::unsigned_right_shift(${literalLeft}, ${literalRight})`;
+        return `jspp::unsigned_right_shift${method}(${literalLeft}, ${literalRight})`;
     }
     // For other arithmetic and bitwise operations, use native operations if possible
     switch (op) {
         case "+":
-            return `jspp::add(${literalLeft}, ${literalRight})`;
+            return `jspp::add${method}(${literalLeft}, ${literalRight})`;
         case "-":
-            return `jspp::sub(${literalLeft}, ${literalRight})`;
+            return `jspp::sub${method}(${literalLeft}, ${literalRight})`;
         case "*":
-            return `jspp::mul(${literalLeft}, ${literalRight})`;
+            return `jspp::mul${method}(${literalLeft}, ${literalRight})`;
         case "/":
-            return `jspp::div(${literalLeft}, ${literalRight})`;
+            return `jspp::div${method}(${literalLeft}, ${literalRight})`;
         case "%":
-            return `jspp::mod(${literalLeft}, ${literalRight})`;
+            return `jspp::mod${method}(${literalLeft}, ${literalRight})`;
         case "^":
-            return `jspp::bitwise_xor(${literalLeft}, ${literalRight})`;
+            return `jspp::bitwise_xor${method}(${literalLeft}, ${literalRight})`;
         case "&":
-            return `jspp::bitwise_and(${literalLeft}, ${literalRight})`;
+            return `jspp::bitwise_and${method}(${literalLeft}, ${literalRight})`;
         case "|":
-            return `jspp::bitwise_or(${literalLeft}, ${literalRight})`;
+            return `jspp::bitwise_or${method}(${literalLeft}, ${literalRight})`;
         case "<<":
-            return `jspp::left_shift(${literalLeft}, ${literalRight})`;
+            return `jspp::left_shift${method}(${literalLeft}, ${literalRight})`;
         case ">>":
-            return `jspp::right_shift(${literalLeft}, ${literalRight})`;
+            return `jspp::right_shift${method}(${literalLeft}, ${literalRight})`;
         case "<":
-            return `jspp::less_than(${literalLeft}, ${literalRight})`;
+            return `jspp::less_than${method}(${literalLeft}, ${literalRight})`;
         case ">":
-            return `jspp::greater_than(${literalLeft}, ${literalRight})`;
+            return `jspp::greater_than${method}(${literalLeft}, ${literalRight})`;
         case "<=":
-            return `jspp::less_than_or_equal(${literalLeft}, ${literalRight})`;
+            return `jspp::less_than_or_equal${method}(${literalLeft}, ${literalRight})`;
         case ">=":
-            return `jspp::greater_than_or_equal(${literalLeft}, ${literalRight})`;
+            return `jspp::greater_than_or_equal${method}(${literalLeft}, ${literalRight})`;
     }
     return `/* Unhandled Operator: ${finalLeft} ${op} ${finalRight} */`; // Default fallback
 }

package/dist/{core → interpreter/core}/codegen/function-handlers.js

@@ -5,8 +5,18 @@ import { CodeGenerator } from "./index.js";
 export function generateLambdaComponents(node, context, options) {
     const declaredSymbols = this.getDeclaredSymbols(node);
     const argsName = this.generateUniqueName("__args_", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
-    const nativeExcessArgsName = this.generateUniqueName("__excess_args", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
-    const nativeTotalArgsSizeName = this.generateUniqueName("__total_args_size", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
+    // const nativeExcessArgsName = this.generateUniqueName(
+    //     "__excess_args",
+    //     declaredSymbols,
+    //     context.globalScopeSymbols,
+    //     context.localScopeSymbols,
+    // );
+    // const nativeTotalArgsSizeName = this.generateUniqueName(
+    //     "__total_args_size",
+    //     declaredSymbols,
+    //     context.globalScopeSymbols,
+    //     context.localScopeSymbols,
+    // );
     const isInsideGeneratorFunction = this.isGeneratorFunction(node);
     const isInsideAsyncFunction = this.isAsyncFunction(node);
     const isArrow = ts.isArrowFunction(node);
@@ -14,15 +24,27 @@ export function generateLambdaComponents(node, context, options) {
         isInsideGeneratorFunction: isInsideGeneratorFunction,
         isInsideAsyncFunction: isInsideAsyncFunction,
     });
-    const funcReturnType = (isInsideGeneratorFunction && isInsideAsyncFunction)
-        ? "jspp::JsAsyncIterator<jspp::AnyValue>"
-        : (isInsideGeneratorFunction
-            ? "jspp::JsIterator<jspp::AnyValue>"
-            : (isInsideAsyncFunction ? "jspp::JsPromise" : "jspp::AnyValue"));
+    const getFuncReturnType = (isInsideNativeLambda) => {
+        if (isInsideGeneratorFunction && isInsideAsyncFunction) {
+            return "jspp::JsAsyncIterator<jspp::AnyValue>";
+        }
+        else if (isInsideGeneratorFunction) {
+            return "jspp::JsIterator<jspp::AnyValue>";
+        }
+        else if (isInsideAsyncFunction)
+            return "jspp::JsPromise";
+        else {
+            const inferedReturnType = this.typeAnalyzer.inferFunctionReturnType(node);
+            if (isInsideNativeLambda && inferedReturnType === "number") {
+                return "double";
+            }
+            return "jspp::AnyValue";
+        }
+    };
     // Lambda arguments: regular functions use std::span for performance.
     // Generators and async functions use std::vector to ensure they are safely copied into the coroutine frame.
     const paramThisType = "jspp::AnyValue";
-    const paramArgsType = (isInsideGeneratorFunction || isInsideAsyncFunction)
+    const paramArgsType = isInsideGeneratorFunction || isInsideAsyncFunction
         ? "std::vector<jspp::AnyValue>"
         : "std::span<const jspp::AnyValue>";
     const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
@@ -31,7 +53,7 @@ export function generateLambdaComponents(node, context, options) {
         isMainContext: false,
         isInsideFunction: true,
         isFunctionBody: false,
-        lambdaName: undefined,
+        functionName: undefined,
         globalScopeSymbols,
         localScopeSymbols: new DeclaredSymbols(),
         superClassVar: context.superClassVar,
@@ -95,7 +117,8 @@ export function generateLambdaComponents(node, context, options) {
                     `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${signatureName});\n`;
             }
             else {
-                nativeParamsContent += this.generateDestructuring(p.name, signatureName, visitContext) + ";\n";
+                nativeParamsContent += this.generateDestructuring(p.name, signatureName, visitContext) +
+                    ";\n";
             }
         }
     });
@@ -114,8 +137,7 @@ export function generateLambdaComponents(node, context, options) {
                     checks: { initialized: true },
                 });
                 const scope = this.getScopeForNode(p);
-                const typeInfo = this.typeAnalyzer.scopeManager
-                    .lookupFromScope(name, scope);
+                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
                 // Handle rest parameters
                 if (!!p.dotDotDotToken) {
                     const initValue = `jspp::AnyValue::make_array(${argsName}.subspan(${i}))`;
@@ -148,39 +170,43 @@ export function generateLambdaComponents(node, context, options) {
                 const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
                 paramsCode +=
                     `${this.indent()}auto ${tempName} = ${initValue};\n`;
-                paramsCode += this.generateDestructuring(p.name, tempName, visitContext) + ";\n";
+                paramsCode +=
+                    this.generateDestructuring(p.name, tempName, visitContext) +
+                        ";\n";
             }
         });
         return paramsCode;
     };
     // Generate params and function body
     let paramsContent = "";
-    let blockContentWithoutOpeningBrace = "";
+    let getBlockContentWithoutOpeningBrace = () => "";
     // Generate `arguments` variable if it used in the function body
-    if (this.isVariableUsedWithoutDeclaration("arguments", node.body)) {
-        // Add span parameter for holding the excess arguments from the caller of the native lambda
-        nativeFuncArgs +=
-            `, const std::size_t ${nativeTotalArgsSizeName}, std::span<const jspp::AnyValue> ${nativeExcessArgsName} = {}`;
-        // TODO: compile arguments array from parameters
-        // this.indentationLevel++;
-        // nativeParamsContent +=
-        //     `${this.indent()}jspp::AnyValue arguments = jspp::Constants::UNDEFINED;\n`;
-        // nativeParamsContent += `${this.indent()}{\n`;
-        // this.indentationLevel++;
-        // nativeParamsContent +=
-        //     `${this.indent()}std::vector<jspp::AnyValue> ${argsName};\n`;
-        // this.validateFunctionParams(node.parameters).forEach(
-        //     (p, i) => {
-        //     },
-        // );
-        // this.indentationLevel--;
-        // nativeParamsContent += `${this.indent()}}\n`;
-        // this.indentationLevel--;
-        // this.indentationLevel++;
-        // paramsContent =
-        //     `${this.indent()}jspp::AnyValue arguments = jspp::AnyValue::make_array(${argsName});\n`;
-        // this.indentationLevel--;
-    }
+    // TODO: compile arguments array from parameters
+    // if (
+    //     this.isVariableUsedWithoutDeclaration("arguments", node.body as ts.Node)
+    // ) {
+    //     // Add span parameter for holding the excess arguments from the caller of the native lambda
+    //     nativeFuncArgs +=
+    //         `, const std::size_t ${nativeTotalArgsSizeName}, std::span<const jspp::AnyValue> ${nativeExcessArgsName} = {}`;
+    //     // this.indentationLevel++;
+    //     // nativeParamsContent +=
+    //     //     `${this.indent()}jspp::AnyValue arguments = jspp::Constants::UNDEFINED;\n`;
+    //     // nativeParamsContent += `${this.indent()}{\n`;
+    //     // this.indentationLevel++;
+    //     // nativeParamsContent +=
+    //     //     `${this.indent()}std::vector<jspp::AnyValue> ${argsName};\n`;
+    //     // this.validateFunctionParams(node.parameters).forEach(
+    //     //     (p, i) => {
+    //     //     },
+    //     // );
+    //     // this.indentationLevel--;
+    //     // nativeParamsContent += `${this.indent()}}\n`;
+    //     // this.indentationLevel--;
+    //     // this.indentationLevel++;
+    //     // paramsContent =
+    //     //     `${this.indent()}jspp::AnyValue arguments = jspp::AnyValue::make_array(${argsName});\n`;
+    //     // this.indentationLevel--;
+    // }
     if (node.body) {
         if (ts.isBlock(node.body)) {
             // Hoist var declarations in the function body
@@ -202,34 +228,53 @@ export function generateLambdaComponents(node, context, options) {
             paramsContent += generateParamsBuilder();
             this.indentationLevel--;
             // The block visitor already adds braces, so we need to remove the opening brace to inject the preamble and param extraction.
-            blockContentWithoutOpeningBrace = this.visit(node.body, {
-                ...visitContext,
-                isMainContext: false,
-                isInsideFunction: true,
-                isFunctionBody: true,
-                isInsideGeneratorFunction: isInsideGeneratorFunction,
-                isInsideAsyncFunction: isInsideAsyncFunction,
-            }).trimStart().substring(2);
+            const properIndentationLevel = this.indentationLevel;
+            const nodeBody = node.body;
+            getBlockContentWithoutOpeningBrace = (isInsideNativeLambda) => {
+                const currentIndentationLevel = this.indentationLevel;
+                this.indentationLevel = properIndentationLevel;
+                const code = this.visit(nodeBody, {
+                    ...visitContext,
+                    isMainContext: false,
+                    isInsideFunction: true,
+                    isFunctionBody: true,
+                    isInsideGeneratorFunction,
+                    isInsideAsyncFunction,
+                    isInsideNativeLambda,
+                })
+                    .trim()
+                    .substring(2);
+                this.indentationLevel = currentIndentationLevel;
+                return code;
+            };
         }
         else {
             this.indentationLevel++;
             paramsContent += generateParamsBuilder();
-            blockContentWithoutOpeningBrace =
-                `${this.indent()}${returnCommand} ${this.visit(node.body, {
+            const properIndentationLevel = this.indentationLevel;
+            const nodeBody = node.body;
+            getBlockContentWithoutOpeningBrace = (isInsideNativeLambda) => {
+                const currentIndentationLevel = this.indentationLevel;
+                this.indentationLevel = properIndentationLevel;
+                let code = `${this.indent()}${returnCommand} ${this.visit(nodeBody, {
                     ...visitContext,
                     isMainContext: false,
                     isInsideFunction: true,
                     isFunctionBody: false,
-                    isInsideGeneratorFunction: isInsideGeneratorFunction,
-                    isInsideAsyncFunction: isInsideAsyncFunction,
+                    isInsideGeneratorFunction,
+                    isInsideAsyncFunction,
+                    isInsideNativeLambda,
                 })};\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}`;
+                this.indentationLevel = currentIndentationLevel;
+                return code;
+            };
             this.indentationLevel--;
-            blockContentWithoutOpeningBrace += `${this.indent()}}`;
         }
     }
     else {
-        blockContentWithoutOpeningBrace =
-            `${returnCommand} jspp::Constants::UNDEFINED; }\n`;
+        getBlockContentWithoutOpeningBrace = () => `${returnCommand} jspp::Constants::UNDEFINED; }`;
     }
     return {
         node,
@@ -239,37 +284,39 @@ export function generateLambdaComponents(node, context, options) {
         thisArgParam,
         funcArgs,
         nativeFuncArgs,
-        funcReturnType,
+        getFuncReturnType,
         preamble,
         nativePreamble,
         paramsContent,
         nativeParamsContent,
-        blockContentWithoutOpeningBrace,
+        getBlockContentWithoutOpeningBrace,
         isInsideGeneratorFunction,
         isInsideAsyncFunction,
     };
 }
 export function generateNativeLambda(comps) {
-    const { options, thisArgParam, nativeFuncArgs, funcReturnType, nativePreamble, nativeParamsContent, blockContentWithoutOpeningBrace, } = comps;
+    const { options, thisArgParam, nativeFuncArgs, getFuncReturnType, nativePreamble, nativeParamsContent, getBlockContentWithoutOpeningBrace, } = comps;
     const capture = options?.capture || "[=]";
     const nativeName = options?.nativeName;
     const selfParam = nativeName ? `this auto&& ${nativeName}, ` : "";
     const mutableLabel = nativeName ? "" : "mutable ";
+    const funcReturnType = getFuncReturnType(true);
     let lambda = `${capture}(${selfParam}${thisArgParam}${nativeFuncArgs}) ${mutableLabel}-> ${funcReturnType} {\n`;
     lambda += nativePreamble;
     lambda += nativeParamsContent;
-    lambda += blockContentWithoutOpeningBrace;
+    lambda += getBlockContentWithoutOpeningBrace(true);
     return lambda;
 }
 export function generateWrappedLambda(comps) {
-    const { node, context, options, thisArgParam, funcArgs, funcReturnType, preamble, paramsContent, blockContentWithoutOpeningBrace, isInsideGeneratorFunction, isInsideAsyncFunction, } = comps;
+    const { node, context, options, thisArgParam, funcArgs, getFuncReturnType, preamble, paramsContent, getBlockContentWithoutOpeningBrace, isInsideGeneratorFunction, isInsideAsyncFunction, } = comps;
     const capture = options?.capture || "[=]";
     const isAssignment = options?.isAssignment || false;
+    const funcReturnType = getFuncReturnType(false);
     const noTypeSignature = options?.noTypeSignature || false;
     let lambda = `${capture}(${thisArgParam}, ${funcArgs}) mutable -> ${funcReturnType} {\n`;
     lambda += preamble;
     lambda += paramsContent;
-    lambda += blockContentWithoutOpeningBrace;
+    lambda += getBlockContentWithoutOpeningBrace(false);
     let callable = lambda;
     let method = "";
     // Handle generator function
@@ -308,7 +355,7 @@ export function generateWrappedLambda(comps) {
             method = `jspp::AnyValue::make_function`;
         }
     }
-    const funcName = context?.lambdaName || node.name?.getText();
+    const funcName = context?.functionName || node.name?.getText();
     const hasName = !!funcName && funcName.length > 0;
     let args = callable;
     const isArrow = ts.isArrowFunction(node);
@@ -378,7 +425,7 @@ export function visitFunctionExpression(node, context) {
             `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>();\n`;
         const lambda = this.generateWrappedLambda(this.generateLambdaComponents(funcExpr, {
             ...context,
-            lambdaName: funcName,
+            functionName: funcName,
         }, {
             isAssignment: true,
             capture: "[=]",