@ugo-studio/jspp 0.2.4 → 0.2.6

package/dist/core/codegen/expression-handlers.js

@@ -1,4 +1,6 @@
 import ts from "typescript";
+import { constants } from "../constants.js";
+import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function visitObjectPropertyName(node, context) {
     if (ts.isNumericLiteral(node)) {
@@ -28,6 +30,13 @@ export function visitObjectPropertyName(node, context) {
 export function visitObjectLiteralExpression(node, context) {
     const obj = node;
     const objVar = this.generateUniqueName("__obj_", this.getDeclaredSymbols(node));
+    if (!obj.properties.some((prop) => ts.isPropertyAssignment(prop) ||
+        ts.isShorthandPropertyAssignment(prop) ||
+        ts.isMethodDeclaration(prop) || ts.isGetAccessor(prop) ||
+        ts.isSetAccessor(prop))) {
+        // Empty object
+        return `jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"))`;
+    }
     let code = `([&]() {\n`;
     code +=
         `${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"));\n`;
@@ -102,8 +111,6 @@ export function visitObjectLiteralExpression(node, context) {
         }
     }
     this.indentationLevel--;
-    // code +=
-    //     `${this.indent()}  ${returnCmd} ${objVar};\n${this.indent()}} )() ))`;
     code += `${this.indent()}  return ${objVar};\n${this.indent()}})()`;
     return code;
 }
@@ -185,7 +192,7 @@ export function visitPropertyAccessExpression(node, context) {
     const propAccess = node;
     if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
         if (!context.superClassVar) {
-            throw new Error("super.prop accessed but no super class variable found in context");
+            throw new CompilerError("super.prop accessed but no super class variable found in context", propAccess.expression, "SyntaxError");
         }
         const propName = propAccess.name.getText();
         return `jspp::AnyValue::resolve_property_for_read((${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}"), ${this.globalThisVar}, "${this.escapeString(propName)}")`;
@@ -253,7 +260,11 @@ export function visitElementAccessExpression(node, context) {
 export function visitBinaryExpression(node, context) {
     const binExpr = node;
     const opToken = binExpr.operatorToken;
-    let op = opToken.getText();
+    const op = opToken.getText();
+    const visitContext = {
+        ...context,
+        supportedNativeLiterals: undefined,
+    };
     const assignmentOperators = [
         ts.SyntaxKind.PlusEqualsToken,
         ts.SyntaxKind.MinusEqualsToken,
@@ -274,8 +285,8 @@ export function visitBinaryExpression(node, context) {
     if (assignmentOperators.includes(opToken.kind)) {
         if (opToken.kind ===
             ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            const leftText = this.visit(binExpr.left, visitContext);
+            const rightText = this.visit(binExpr.right, visitContext);
             let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
@@ -287,8 +298,8 @@ export function visitBinaryExpression(node, context) {
             }
         }
         if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            const leftText = this.visit(binExpr.left, visitContext);
+            const rightText = this.visit(binExpr.right, visitContext);
             let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
@@ -303,8 +314,8 @@ export function visitBinaryExpression(node, context) {
         if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
             opToken.kind === ts.SyntaxKind.BarBarEqualsToken ||
             opToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            const leftText = this.visit(binExpr.left, visitContext);
+            const rightText = this.visit(binExpr.right, visitContext);
             let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
@@ -323,21 +334,21 @@ export function visitBinaryExpression(node, context) {
                 }
             }
         }
-        const leftText = this.visit(binExpr.left, context);
+        const leftText = this.visit(binExpr.left, visitContext);
         let rightText = ts.isNumericLiteral(binExpr.right)
             ? binExpr.right.getText()
-            : this.visit(binExpr.right, context);
+            : this.visit(binExpr.right, visitContext);
         if (ts.isIdentifier(binExpr.right)) {
             const scope = this.getScopeForNode(binExpr.right);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope);
-            rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, typeInfo);
+            rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
         let target = leftText;
         if (ts.isIdentifier(binExpr.left)) {
             const scope = this.getScopeForNode(binExpr.left);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.getText(), scope);
             if (context.derefBeforeAssignment) {
-                target = this.getDerefCode(leftText, leftText, context, typeInfo);
+                target = this.getDerefCode(leftText, leftText, visitContext, typeInfo);
             }
             else if (typeInfo.needsHeapAllocation) {
                 target = `*${leftText}`;
@@ -345,8 +356,9 @@ export function visitBinaryExpression(node, context) {
         }
         return `${target} ${op} ${rightText}`;
     }
+    // Assignment expression `a = 1`
     if (opToken.kind === ts.SyntaxKind.EqualsToken) {
-        let rightText = this.visit(binExpr.right, context);
+        let rightText = this.visit(binExpr.right, visitContext);
         if (ts.isPropertyAccessExpression(binExpr.left)) {
             const propAccess = binExpr.left;
             if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
@@ -360,13 +372,13 @@ export function visitBinaryExpression(node, context) {
                     if (rightTypeInfo &&
                         !rightTypeInfo.isParameter &&
                         !rightTypeInfo.isBuiltin) {
-                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
+                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, rightTypeInfo);
                     }
                 }
                 // Approximate super assignment as setting property on 'this'
                 return `(${this.globalThisVar}).set_own_property("${propName}", ${finalRightText})`;
             }
-            const objExprText = this.visit(propAccess.expression, context);
+            const objExprText = this.visit(propAccess.expression, visitContext);
             const propName = propAccess.name.getText();
             let finalObjExpr = objExprText;
             if (ts.isIdentifier(propAccess.expression)) {
@@ -391,14 +403,14 @@ export function visitBinaryExpression(node, context) {
         }
         else if (ts.isElementAccessExpression(binExpr.left)) {
             const elemAccess = binExpr.left;
-            const objExprText = this.visit(elemAccess.expression, context);
-            let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            const objExprText = this.visit(elemAccess.expression, visitContext);
+            let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...visitContext, isBracketNotationPropertyAccess: true });
             let finalObjExpr = objExprText;
             if (ts.isIdentifier(elemAccess.expression)) {
                 const scope = this.getScopeForNode(elemAccess.expression);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.expression.getText(), scope);
                 if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(elemAccess.expression), context, typeInfo);
+                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(elemAccess.expression), visitContext, typeInfo);
                 }
             }
             if (ts.isIdentifier(elemAccess.argumentExpression)) {
@@ -408,7 +420,7 @@ export function visitBinaryExpression(node, context) {
                 if (argTypeInfo &&
                     !argTypeInfo.isParameter &&
                     !argTypeInfo.isBuiltin) {
-                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), context, argTypeInfo);
+                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), visitContext, argTypeInfo);
                 }
             }
             let finalRightText = rightText;
@@ -419,12 +431,12 @@ export function visitBinaryExpression(node, context) {
                 if (rightTypeInfo &&
                     !rightTypeInfo.isParameter &&
                     !rightTypeInfo.isBuiltin) {
-                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
+                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, rightTypeInfo);
                 }
             }
             return `${finalObjExpr}.set_own_property(${argText}, ${finalRightText})`;
         }
-        const leftText = this.visit(binExpr.left, context);
+        const leftText = this.visit(binExpr.left, visitContext);
         const scope = this.getScopeForNode(binExpr.left);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
         if (!typeInfo && !this.isBuiltinObject(binExpr.left)) {
@@ -437,12 +449,28 @@ export function visitBinaryExpression(node, context) {
             rightText = binExpr.right.getText();
         }
         const target = context.derefBeforeAssignment
-            ? this.getDerefCode(leftText, leftText, context, typeInfo)
+            ? this.getDerefCode(leftText, leftText, visitContext, typeInfo)
             : (typeInfo.needsHeapAllocation ? `*${leftText}` : leftText);
+        // Update scope symbols on variable re-assignment
+        if (ts.isIdentifier(binExpr.left)) {
+            if (!ts.isFunctionDeclaration(binExpr.right)) {
+                if (context.localScopeSymbols.has(binExpr.left.text)) {
+                    context.localScopeSymbols.update(binExpr.left.text, {
+                        func: null,
+                    });
+                }
+                else if (context.globalScopeSymbols.has(binExpr.left.text)) {
+                    context.globalScopeSymbols.update(binExpr.left.text, {
+                        func: null,
+                    });
+                }
+            }
+        }
         return `${target} ${op} ${rightText}`;
     }
-    const leftText = this.visit(binExpr.left, context);
-    const rightText = this.visit(binExpr.right, context);
+    const leftText = this.visit(binExpr.left, visitContext);
+    const rightText = this.visit(binExpr.right, visitContext);
+    // Generate lhs and rhs code
     let finalLeft = leftText;
     if (ts.isIdentifier(binExpr.left)) {
         const scope = this.getScopeForNode(binExpr.left);
@@ -451,7 +479,7 @@ export function visitBinaryExpression(node, context) {
             return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(binExpr.left)})`;
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), context, typeInfo);
+            finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), visitContext, typeInfo);
         }
     }
     let finalRight = rightText;
@@ -463,7 +491,7 @@ export function visitBinaryExpression(node, context) {
             return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(binExpr.right)})`;
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, typeInfo);
+            finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
     }
     if (opToken.kind === ts.SyntaxKind.InKeyword) {
@@ -481,35 +509,63 @@ export function visitBinaryExpression(node, context) {
     if (opToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
         return `jspp::nullish_coalesce(${finalLeft}, ${finalRight})`;
     }
-    // Optimizations to prevent calling make_number multiple times
-    if (ts.isNumericLiteral(binExpr.left)) {
-        finalLeft = binExpr.left.getText();
-    }
-    if (ts.isNumericLiteral(binExpr.right)) {
-        finalRight = binExpr.right.getText();
-    }
+    const isLiteral = (n) => ts.isNumericLiteral(n);
+    const supportsNativeBoolean = context.supportedNativeLiterals?.includes("boolean") || false;
+    // Native values for lhs and rhs
+    const literalLeft = isLiteral(binExpr.left)
+        ? binExpr.left.getText()
+        : finalLeft;
+    const literalRight = isLiteral(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})`;
+        }
+        if (isLiteral(binExpr.left) && isLiteral(binExpr.right)) {
+            return `(${literalLeft} ${op} ${literalRight})`;
+        }
+        else
+            return `(${literalLeft} ${op} ${literalRight}).as_boolean()`;
+    }
+    // Return boxed value
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-        return `jspp::is_strictly_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::is_strictly_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-        return `jspp::is_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::is_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-        return `jspp::not_strictly_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::not_strictly_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        return `jspp::not_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::not_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskToken) {
-        return `jspp::pow(${finalLeft}, ${finalRight})`;
+        return `jspp::pow(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken) {
-        return `jspp::unsigned_right_shift(${finalLeft}, ${finalRight})`;
+        return `jspp::unsigned_right_shift(${literalLeft}, ${literalRight})`;
     }
-    // Optimizations to prevent calling make_number multiple times
-    if (ts.isNumericLiteral(binExpr.left) && ts.isNumericLiteral(binExpr.right)) {
-        return `jspp::AnyValue::make_number(${finalLeft} ${op} ${finalRight})`;
+    // Use literal for at most one side
+    if (isLiteral(binExpr.left)) {
+        finalLeft = binExpr.left.getText();
     }
+    else if (isLiteral(binExpr.right)) {
+        finalRight = binExpr.right.getText();
+    }
+    // For other arithmetic and bitwise operations, use native operations if possible
     if (op === "+" ||
         op === "-" ||
         op === "*" ||
@@ -526,7 +582,12 @@ export function visitBinaryExpression(node, context) {
 }
 export function visitConditionalExpression(node, context) {
     const condExpr = node;
-    const condition = this.visit(condExpr.condition, context);
+    const isBinaryExpression = ts.isBinaryExpression(condExpr.condition) &&
+        constants.booleanOperators.includes(condExpr.condition.operatorToken.kind);
+    const condition = this.visit(condExpr.condition, {
+        ...context,
+        supportedNativeLiterals: isBinaryExpression ? ["boolean"] : undefined,
+    });
     const whenTrueStmt = this.visit(condExpr.whenTrue, {
         ...context,
         isFunctionBody: false,
@@ -535,14 +596,17 @@ export function visitConditionalExpression(node, context) {
         ...context,
         isFunctionBody: false,
     });
-    return `is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
+    if (isBinaryExpression) {
+        return `${condition} ? ${whenTrueStmt} : ${whenFalseStmt}`;
+    }
+    return `jspp::is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
 }
 export function visitCallExpression(node, context) {
     const callExpr = node;
     const callee = callExpr.expression;
     if (callee.kind === ts.SyntaxKind.SuperKeyword) {
         if (!context.superClassVar) {
-            throw new Error("super() called but no super class variable found in context");
+            throw new CompilerError("super() called but no super class variable found in context", callee, "SyntaxError");
         }
         const args = callExpr.arguments.map((arg) => this.visit(arg, context))
             .join(", ");
@@ -573,7 +637,7 @@ export function visitCallExpression(node, context) {
         const propAccess = callee;
         if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
             if (!context.superClassVar) {
-                throw new Error("super.method() called but no super class variable found in context");
+                throw new CompilerError("super.method() called but no super class variable found in context", propAccess.expression, "SyntaxError");
             }
             const propName = propAccess.name.getText();
             return `(${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}").call(${this.globalThisVar}, ${argsSpan}, "${this.escapeString(propName)}")`;
@@ -645,6 +709,21 @@ export function visitCallExpression(node, context) {
             derefCallee = calleeCode;
         }
         else if (typeInfo) {
+            const name = callee.getText();
+            const symbol = context.localScopeSymbols.get(name) ??
+                context.globalScopeSymbols.get(name);
+            // Optimization: Direct lambda call
+            if (symbol && symbol.func?.nativeName) {
+                const callExpr = `${symbol.func.nativeName}(jspp::Constants::UNDEFINED, ${argsSpan})`;
+                if (symbol.func.isGenerator) {
+                    if (symbol.func.isAsync) {
+                        return `jspp::AnyValue::from_async_iterator(${callExpr})`;
+                    }
+                    return `jspp::AnyValue::from_iterator(${callExpr})`;
+                }
+                return callExpr;
+            }
+            // AnyValue function call
             derefCallee = this.getDerefCode(calleeCode, this.getJsVarName(callee), context, typeInfo);
         }
     }
@@ -792,3 +871,15 @@ export function visitDeleteExpression(node, context) {
     }
     return "jspp::Constants::TRUE"; // delete on non-property is true in JS
 }
+export function visitAsExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitTypeAssertionExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitNonNullExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitSatisfiesExpression(node, context) {
+    return this.visit(node.expression, context);
+}

package/dist/core/codegen/function-handlers.js

@@ -1,12 +1,13 @@
 import ts from "typescript";
-import { DeclaredSymbols } from "../../ast/symbols.js";
+import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
+import { CompilerError } from "../error.js";
 import { collectFunctionScopedDeclarations } from "./helpers.js";
 import { CodeGenerator } from "./index.js";
 export function generateLambda(node, context, options) {
-    const isAssignment = options?.isAssignment || false;
     const capture = options?.capture || "[=]";
+    const nativeName = options?.nativeName;
     const declaredSymbols = this.getDeclaredSymbols(node);
-    const argsName = this.generateUniqueName("__args_", declaredSymbols);
+    const argsName = this.generateUniqueName("__args_", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
     const isInsideGeneratorFunction = this.isGeneratorFunction(node);
     const isInsideAsyncFunction = this.isAsyncFunction(node);
     const returnCmd = this.getReturnCommand({
@@ -23,26 +24,25 @@ export function generateLambda(node, context, options) {
     // For generators/async, we manually copy them inside the body.
     const paramThisType = "const jspp::AnyValue&";
     const paramArgsType = "std::span<const jspp::AnyValue>";
+    const selfParamPart = nativeName ? `this auto&& ${nativeName}, ` : "";
+    const mutablePart = nativeName ? "" : "mutable ";
     const thisArgParam = isArrow
         ? "const jspp::AnyValue&" // Arrow functions use captured 'this' or are never generators in this parser context
         : `${paramThisType} ${this.globalThisVar}`;
-    let lambda = `${capture}(${thisArgParam}, ${paramArgsType} ${argsName}) mutable -> ${funcReturnType} `;
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    let lambda = `${capture}(${selfParamPart}${thisArgParam}, ${paramArgsType} ${argsName}) ${mutablePart}-> ${funcReturnType} `;
+    const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
     const visitContext = {
+        currentScopeNode: context.currentScopeNode,
         isMainContext: false,
         isInsideFunction: true,
         isFunctionBody: false,
         lambdaName: undefined,
-        topLevelScopeSymbols,
+        globalScopeSymbols,
         localScopeSymbols: new DeclaredSymbols(),
         superClassVar: context.superClassVar,
         isInsideGeneratorFunction: isInsideGeneratorFunction,
         isInsideAsyncFunction: isInsideAsyncFunction,
     };
-    // Name of 'this' and 'args' to be used in the body.
-    // If generator/async, we use the copied versions.
-    let bodyThisVar = this.globalThisVar;
-    let bodyArgsVar = argsName;
     // Preamble to copy arguments for coroutines
     let preamble = "";
     if (isInsideGeneratorFunction || isInsideAsyncFunction) {
@@ -51,40 +51,9 @@ export function generateLambda(node, context, options) {
         if (!isArrow) {
             preamble +=
                 `${this.indent()}jspp::AnyValue ${thisCopy} = ${this.globalThisVar};\n`;
-            bodyThisVar = thisCopy;
         }
         preamble +=
             `${this.indent()}std::vector<jspp::AnyValue> ${argsCopy}(${argsName}.begin(), ${argsName}.end());\n`;
-        bodyArgsVar = argsCopy;
-        // Update visitContext to use the new 'this' variable if needed?
-        // CodeGenerator.globalThisVar is a member of the class, so we can't easily change it for the recursive visit
-        // without changing the class state or passing it down.
-        // BUT: visitThisKeyword uses `this.globalThisVar`.
-        // We need to temporarily swap `this.globalThisVar` or handle it.
-        // Actually, `this.globalThisVar` is set once in `generate`.
-        // Wait, `visitThisKeyword` uses `this.globalThisVar`.
-        // If we change the variable name for 'this', we must ensure `visitThisKeyword` generates the correct name.
-        // `generateLambda` does NOT create a new CodeGenerator instance, so `this.globalThisVar` is the global one.
-        //
-        // We need to support shadowing `globalThisVar` for the duration of the visit.
-        // The current `CodeGenerator` doesn't seem to support changing `globalThisVar` recursively easily
-        // because it's a property of the class, not `VisitContext`.
-        //
-        // However, `visitFunctionDeclaration` etc don't update `globalThisVar`.
-        // `visitThisKeyword` just returns `this.globalThisVar`.
-        //
-        // If we are inside a function, `this` should refer to the function's `this`.
-        // `this.globalThisVar` is generated in `generate()`: `__this_val__...`.
-        // And `generateLambda` uses `this.globalThisVar` as the parameter name.
-        //
-        // So, if we copy it to `__this_copy`, `visitThisKeyword` will still print `__this_val__...`.
-        // This is BAD for generators because `__this_val__...` is a reference that dies.
-        //
-        // FIX: We must reuse the SAME name for the local copy, and shadow the parameter.
-        // But we can't declare a variable with the same name as the parameter in the same scope.
-        //
-        // We can rename the PARAMETER to something else, and declare the local variable with `this.globalThisVar`.
-        //
     }
     // Adjust parameter names for generator/async to allow shadowing/copying
     let finalThisParamName = isArrow ? "" : this.globalThisVar;
@@ -100,7 +69,7 @@ export function generateLambda(node, context, options) {
         : `${paramThisType} ${finalThisParamName}`;
     // Re-construct lambda header with potentially new param names
     lambda =
-        `${capture}(${thisArgParamFinal}, ${paramArgsType} ${finalArgsParamName}) mutable -> ${funcReturnType} `;
+        `${capture}(${selfParamPart}${thisArgParamFinal}, ${paramArgsType} ${finalArgsParamName}) ${mutablePart}-> ${funcReturnType} `;
     // Regenerate preamble
     preamble = "";
     if (isInsideGeneratorFunction || isInsideAsyncFunction) {
@@ -116,17 +85,27 @@ export function generateLambda(node, context, options) {
     // So subsequent code using `argsName` and `visit` (using `globalThisVar`) works correctly.
     const paramExtractor = (parameters) => {
         let code = "";
-        parameters.forEach((p, i) => {
+        parameters.filter((p) => this.isTypescript && p.name.getText() === "this" ? false : true // Ignore "this" parameters
+        ).forEach((p, i) => {
             const name = p.name.getText();
             const defaultValue = p.initializer
                 ? this.visit(p.initializer, visitContext)
                 : "jspp::Constants::UNDEFINED";
+            // Catch invalid parameters
+            if (name === "this") {
+                throw new CompilerError(`Cannot use '${name}' as a parameter name.`, p, "SyntaxError");
+            }
+            // Add paramerter to local context
+            visitContext.localScopeSymbols.add(name, {
+                type: DeclarationType.let,
+                checks: { initialized: true },
+            });
             const scope = this.getScopeForNode(p);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
             // Handle rest parameters
             if (!!p.dotDotDotToken) {
                 if (parameters.length - 1 !== i) {
-                    throw new SyntaxError("Rest parameter must be last formal parameter.");
+                    throw new CompilerError("Rest parameter must be last formal parameter.", p, "SyntaxError");
                 }
                 if (typeInfo.needsHeapAllocation) {
                     code +=
@@ -178,7 +157,7 @@ export function generateLambda(node, context, options) {
             // Hoist var declarations in the function body
             const varDecls = collectFunctionScopedDeclarations(node.body);
             varDecls.forEach((decl) => {
-                preamble += this.hoistDeclaration(decl, visitContext.localScopeSymbols);
+                preamble += this.hoistDeclaration(decl, visitContext.localScopeSymbols, node.body);
             });
             this.indentationLevel++;
             const paramExtraction = paramExtractor(node.parameters);
@@ -215,34 +194,49 @@ export function generateLambda(node, context, options) {
     else {
         lambda += `{ ${preamble} ${returnCmd} jspp::Constants::UNDEFINED; }\n`;
     }
-    let signature = "";
-    let callable = "";
+    // Return only lambda if required
+    if (options?.generateOnlyLambda) {
+        return lambda.trimEnd();
+    }
+    return this.generateFullLambdaExpression(node, context, lambda, options);
+}
+export function generateFullLambdaExpression(node, context, lambda, options) {
+    const isAssignment = options?.isAssignment || false;
+    const noTypeSignature = options?.noTypeSignature || false;
+    const isInsideGeneratorFunction = this.isGeneratorFunction(node);
+    const isInsideAsyncFunction = this.isAsyncFunction(node);
+    const isArrow = ts.isArrowFunction(node);
+    let callable = lambda;
     let method = "";
     // Handle generator function
     if (isInsideGeneratorFunction) {
         if (isInsideAsyncFunction) {
-            signature =
-                "jspp::JsAsyncIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
-            callable = `std::function<${signature}>(${lambda})`;
+            if (!noTypeSignature) {
+                const signature = "jspp::JsAsyncIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+                callable = `std::function<${signature}>(${lambda})`;
+            }
             method = `jspp::AnyValue::make_async_generator`;
         }
         else {
-            signature =
-                "jspp::JsIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
-            callable = `std::function<${signature}>(${lambda})`;
+            if (!noTypeSignature) {
+                const signature = "jspp::JsIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+                callable = `std::function<${signature}>(${lambda})`;
+            }
             method = `jspp::AnyValue::make_generator`;
         }
     } // Handle async function
     else if (isInsideAsyncFunction) {
-        signature =
-            "jspp::JsPromise(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
-        callable = `std::function<${signature}>(${lambda})`;
+        if (!noTypeSignature) {
+            const signature = "jspp::JsPromise(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+            callable = `std::function<${signature}>(${lambda})`;
+        }
         method = `jspp::AnyValue::make_async_function`;
     } // Handle normal function
     else {
-        signature =
-            `jspp::AnyValue(const jspp::AnyValue&, std::span<const jspp::AnyValue>)`;
-        callable = `std::function<${signature}>(${lambda})`;
+        if (!noTypeSignature) {
+            const signature = `jspp::AnyValue(const jspp::AnyValue&, std::span<const jspp::AnyValue>)`;
+            callable = `std::function<${signature}>(${lambda})`;
+        }
         if (options?.isClass) {
             method = `jspp::AnyValue::make_class`;
         }