@ugo-studio/jspp 0.2.4 → 0.2.5

package/dist/analysis/typeAnalyzer.js

@@ -205,6 +205,15 @@ export class TypeAnalyzer {
                         this.functionTypeInfo.set(node, funcType);
                         this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
+                        // Catch invalid parameters
+                        node.parameters.forEach((p) => {
+                            if (p.getText() == "this") {
+                                const sourceFile = node.getSourceFile();
+                                const { line, character } = sourceFile
+                                    .getLineAndCharacterOfPosition(p.getStart());
+                                throw new SyntaxError(`Cannot use 'this' as a parameter name.\n\n${" ".repeat(6)}at ${sourceFile.fileName}:${line + 1}:${character + 1}\n`);
+                            }
+                        });
                         // Define parameters in the new scope
                         node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
                             type: "auto",
@@ -238,6 +247,15 @@ export class TypeAnalyzer {
                         if (node.name) {
                             this.scopeManager.define(node.name.getText(), funcType);
                         }
+                        // Catch invalid parameters
+                        node.parameters.forEach((p) => {
+                            if (p.getText() == "this") {
+                                const sourceFile = node.getSourceFile();
+                                const { line, character } = sourceFile
+                                    .getLineAndCharacterOfPosition(p.getStart());
+                                throw new SyntaxError(`Cannot use 'this' as a parameter name.\n\n${" ".repeat(6)}at ${sourceFile.fileName}:${line + 1}:${character + 1}\n`);
+                            }
+                        });
                         // Define parameters in the new scope
                         node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
                             type: "auto",
@@ -270,6 +288,15 @@ export class TypeAnalyzer {
                             this.scopeManager.define(funcName, funcType);
                             this.functionTypeInfo.set(node, funcType);
                         }
+                        // Catch invalid parameters
+                        node.parameters.forEach((p) => {
+                            if (p.getText() == "this") {
+                                const sourceFile = node.getSourceFile();
+                                const { line, character } = sourceFile
+                                    .getLineAndCharacterOfPosition(p.getStart());
+                                throw new SyntaxError(`Cannot use 'this' as a parameter name.\n\n${" ".repeat(6)}at ${sourceFile.fileName}:${line + 1}:${character + 1}\n`);
+                            }
+                        });
                         this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
                         // Define parameters in the new scope
@@ -385,6 +412,11 @@ export class TypeAnalyzer {
                                 type = "function";
                                 needsHeap = true;
                             }
+                            else if (ts.isIdentifier(node.initializer)) {
+                                const typeInfo = this.scopeManager.lookup(node.initializer.text);
+                                needsHeap = typeInfo?.needsHeapAllocation ??
+                                    false;
+                            }
                         }
                         const typeInfo = {
                             type,

package/dist/ast/symbols.js

@@ -1,32 +1,74 @@
-export var DeclaredSymbolType;
-(function (DeclaredSymbolType) {
-    DeclaredSymbolType["letOrConst"] = "letOrConst";
-    DeclaredSymbolType["function"] = "function";
-    DeclaredSymbolType["var"] = "var";
-})(DeclaredSymbolType || (DeclaredSymbolType = {}));
+export var DeclarationType;
+(function (DeclarationType) {
+    DeclarationType["var"] = "var";
+    DeclarationType["let"] = "let";
+    DeclarationType["const"] = "const";
+    DeclarationType["function"] = "function";
+    DeclarationType["class"] = "class";
+})(DeclarationType || (DeclarationType = {}));
+export class DeclaredSymbol {
+    type;
+    checked;
+    func;
+    constructor(type) {
+        this.type = type;
+        this.checked = {
+            initialized: false,
+        };
+        this.func = null;
+    }
+    get isMutable() {
+        return this.type === DeclarationType.let ||
+            this.type === DeclarationType.var;
+    }
+    updateChecked(update) {
+        this.checked = {
+            ...this.checked,
+            ...update,
+        };
+    }
+    updateFunc(update) {
+        this.func = update
+            ? {
+                ...this.func,
+                ...update,
+            }
+            : null;
+    }
+}
 export class DeclaredSymbols {
     symbols;
     constructor(...m) {
         this.symbols = new Map();
         m.forEach((ds) => ds.symbols.forEach((v, k) => this.symbols.set(k, v)));
     }
+    get names() {
+        return new Set(this.symbols.keys());
+    }
     has(name) {
         return this.symbols.has(name);
     }
     get(name) {
         return this.symbols.get(name);
     }
-    set(name, value) {
-        return this.symbols.set(name, value);
+    add(name, value) {
+        const sym = new DeclaredSymbol(value.type);
+        if (value.checked !== undefined)
+            sym.updateChecked(value.checked);
+        if (value.func !== undefined)
+            sym.updateFunc(value.func);
+        return this.symbols.set(name, sym);
     }
     update(name, update) {
-        const oldValue = this.get(name);
-        if (oldValue) {
-            const newValue = { ...oldValue, ...update };
-            return this.symbols.set(name, newValue);
+        const sym = this.get(name);
+        if (sym) {
+            if (update.type !== undefined)
+                sym.type = update.type;
+            if (update.checked !== undefined)
+                sym.updateChecked(update.checked);
+            if (update.func !== undefined)
+                sym.updateFunc(update.func);
+            return this.symbols.set(name, sym);
         }
     }
-    toSet() {
-        return new Set(this.symbols.keys());
-    }
 }

package/dist/cli.js

@@ -41,7 +41,7 @@ async function main() {
         const jsCode = await fs.readFile(jsFilePath, "utf-8");
         spinner.update("Transpiling to C++...");
         const interpreter = new Interpreter();
-        const { cppCode, preludePath } = interpreter.interpret(jsCode);
+        const { cppCode, preludePath } = interpreter.interpret(jsCode, jsFilePath);
         // Ensure directory for cpp file exists (should exist as it's source dir, but for safety if we change logic)
         await fs.mkdir(path.dirname(cppFilePath), { recursive: true });
         await fs.writeFile(cppFilePath, cppCode);

package/dist/core/codegen/control-flow-handlers.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols.js";
+import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
 import { CodeGenerator } from "./index.js";
 export function visitForStatement(node, context) {
     const forStmt = node;
@@ -11,9 +11,14 @@ export function visitForStatement(node, context) {
     this.indentationLevel++; // Enter a new scope for the for loop
     // Handle initializer
     let initializerCode = "";
-    let conditionContext = {
+    const conditionContext = {
         ...context,
-        topLevelScopeSymbols: this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols),
+        globalScopeSymbols: this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols),
+    };
+    const statementContext = {
+        ...context,
+        currentLabel: undefined,
+        isFunctionBody: false,
     };
     if (forStmt.initializer) {
         if (ts.isVariableDeclarationList(forStmt.initializer)) {
@@ -32,9 +37,18 @@ export function visitForStatement(node, context) {
                     const typeInfo = this.typeAnalyzer.scopeManager
                         .lookupFromScope(name, scope);
                     conditionContext.localScopeSymbols = new DeclaredSymbols();
-                    conditionContext.localScopeSymbols.set(name, {
-                        type: DeclaredSymbolType.letOrConst,
-                        checkedIfUninitialized: true,
+                    const declType = (varDeclList.flags &
+                        (ts.NodeFlags.Let)) !==
+                        0
+                        ? DeclarationType.let
+                        : DeclarationType.const;
+                    conditionContext.localScopeSymbols.add(name, {
+                        type: declType,
+                        checked: { initialized: true },
+                    });
+                    statementContext.localScopeSymbols.add(name, {
+                        type: declType,
+                        checked: { initialized: true },
                     });
                     if (typeInfo.needsHeapAllocation) {
                         initializerCode =
@@ -59,18 +73,15 @@ export function visitForStatement(node, context) {
     }
     code += `${this.indent()}for (${initializerCode}; `;
     if (forStmt.condition) {
-        code += `is_truthy(${this.visit(forStmt.condition, conditionContext)})`;
+        code += `jspp::is_truthy(${this.visit(forStmt.condition, conditionContext)})`;
     }
     code += "; ";
     if (forStmt.incrementor) {
         code += this.visit(forStmt.incrementor, context);
     }
     code += ") ";
-    const statementCode = this.visit(forStmt.statement, {
-        ...context,
-        currentLabel: undefined,
-        isFunctionBody: false,
-    }).trim();
+    const statementCode = this.visit(forStmt.statement, statementContext)
+        .trim();
     if (ts.isBlock(node.statement)) {
         let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
         if (context.currentLabel) {
@@ -240,7 +251,7 @@ export function visitForOfStatement(node, context) {
             `${this.indent()}auto ${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
     }
     code +=
-        `${this.indent()}while (!is_truthy(${nextRes}.get_own_property("done"))) {\n`;
+        `${this.indent()}while (!jspp::is_truthy(${nextRes}.get_own_property("done"))) {\n`;
     this.indentationLevel++;
     code +=
         `${this.indent()}${assignmentTarget} = ${nextRes}.get_own_property("value");\n`;
@@ -277,7 +288,7 @@ export function visitWhileStatement(node, context) {
     const conditionText = condition.kind === ts.SyntaxKind.TrueKeyword ||
         condition.kind === ts.SyntaxKind.FalseKeyword
         ? condition.getText()
-        : `is_truthy(${this.visit(condition, context)})`;
+        : `jspp::is_truthy(${this.visit(condition, context)})`;
     let code = "";
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}: {\n`;
@@ -317,7 +328,7 @@ export function visitWhileStatement(node, context) {
 }
 export function visitDoStatement(node, context) {
     const condition = node.expression;
-    const conditionText = `is_truthy(${this.visit(condition, context)})`;
+    const conditionText = `jspp::is_truthy(${this.visit(condition, context)})`;
     let code = "";
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}: {\n`;
@@ -358,6 +369,7 @@ export function visitDoStatement(node, context) {
 }
 export function visitSwitchStatement(node, context) {
     const switchStmt = node;
+    context.currentScopeNode = node; // Update scope node
     let code = "";
     const declaredSymbols = this.getDeclaredSymbols(switchStmt.caseBlock);
     const switchBreakLabel = this.generateUniqueName("__switch_break_", declaredSymbols);
@@ -374,25 +386,75 @@ export function visitSwitchStatement(node, context) {
     code +=
         `${this.indent()}const jspp::AnyValue ${switchValueVar} = ${expressionCode};\n`;
     code += `${this.indent()}bool ${fallthroughVar} = false;\n`;
-    // Hoist variable declarations
-    const hoistedSymbols = new DeclaredSymbols();
+    // Collect declarations from all clauses
+    const funcDecls = [];
+    const classDecls = [];
+    const blockScopedDecls = [];
     for (const clause of switchStmt.caseBlock.clauses) {
-        if (ts.isCaseClause(clause) || ts.isDefaultClause(clause)) {
-            for (const stmt of clause.statements) {
-                if (ts.isVariableStatement(stmt)) {
-                    const varDecls = stmt.declarationList.declarations;
-                    for (const decl of varDecls) {
-                        code += this.hoistDeclaration(decl, hoistedSymbols);
-                    }
-                }
-                else if (ts.isFunctionDeclaration(stmt)) {
-                    code += this.hoistDeclaration(stmt, hoistedSymbols);
+        for (const stmt of clause.statements) {
+            if (ts.isFunctionDeclaration(stmt)) {
+                funcDecls.push(stmt);
+            }
+            else if (ts.isClassDeclaration(stmt)) {
+                classDecls.push(stmt);
+            }
+            else if (ts.isVariableStatement(stmt)) {
+                const isLetOrConst = (stmt.declarationList.flags &
+                    (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                if (isLetOrConst) {
+                    blockScopedDecls.push(...stmt.declarationList.declarations);
                 }
             }
         }
     }
-    // Prepare scope symbols for the switch block
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    const hoistedSymbols = new DeclaredSymbols();
+    // 1. Hoist function declarations
+    funcDecls.forEach((func) => {
+        code += this.hoistDeclaration(func, hoistedSymbols, node);
+    });
+    // 2. Hoist class declarations
+    classDecls.forEach((cls) => {
+        code += this.hoistDeclaration(cls, hoistedSymbols, node);
+    });
+    // 3. Hoist variable declarations (let/const only)
+    blockScopedDecls.forEach((decl) => {
+        code += this.hoistDeclaration(decl, hoistedSymbols, node);
+    });
+    // Compile symbols for other statements
+    const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
+    const localScopeSymbols = new DeclaredSymbols(hoistedSymbols);
+    // 4. Assign hoisted functions (Optimization)
+    const contextForFunctions = {
+        ...context,
+        localScopeSymbols: new DeclaredSymbols(context.localScopeSymbols, hoistedSymbols),
+    };
+    funcDecls.forEach((stmt) => {
+        const funcName = stmt.name?.getText();
+        if (!funcName)
+            return;
+        const symbol = hoistedSymbols.get(funcName);
+        if (!symbol)
+            return;
+        // Mark initialized
+        this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
+        this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Generate native name
+        const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        hoistedSymbols.update(funcName, { func: { nativeName } });
+        // Generate lambda
+        const lambda = this.generateLambda(stmt, contextForFunctions, {
+            isAssignment: true,
+            generateOnlyLambda: true,
+            nativeName,
+        });
+        code += `${this.indent()}auto ${nativeName} = ${lambda};\n`;
+        // Generate AnyValue wrapper
+        if (this.isFunctionUsedAsValue(stmt, node) ||
+            this.isFunctionUsedBeforeDeclaration(funcName, node)) {
+            const fullExpression = this.generateFullLambdaExpression(stmt, contextForFunctions, nativeName, { isAssignment: true, noTypeSignature: true });
+            code += `${this.indent()}*${funcName} = ${fullExpression};\n`;
+        }
+    });
     let firstIf = true;
     for (const clause of switchStmt.caseBlock.clauses) {
         if (ts.isCaseClause(clause)) {
@@ -416,15 +478,23 @@ export function visitSwitchStatement(node, context) {
             code += `${this.indent()}${fallthroughVar} = true;\n`;
             for (const stmt of clause.statements) {
                 if (ts.isFunctionDeclaration(stmt)) {
-                    const funcName = stmt.name?.getText();
-                    if (funcName) {
-                        const contextForFunction = {
-                            ...context,
-                            topLevelScopeSymbols,
-                            localScopeSymbols: hoistedSymbols,
-                        };
-                        const lambda = this.generateLambda(stmt, contextForFunction, { isAssignment: true });
-                        code += `${this.indent()}*${funcName} = ${lambda};\n`;
+                    // Already handled
+                }
+                else if (ts.isVariableStatement(stmt)) {
+                    const isLetOrConst = (stmt.declarationList.flags &
+                        (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+                        0;
+                    const contextForVisit = {
+                        ...context,
+                        switchBreakLabel,
+                        currentLabel: undefined,
+                        globalScopeSymbols,
+                        localScopeSymbols,
+                        isAssignmentOnly: !isLetOrConst,
+                    };
+                    const assignments = this.visit(stmt.declarationList, contextForVisit);
+                    if (assignments) {
+                        code += `${this.indent()}${assignments};\n`;
                     }
                 }
                 else {
@@ -432,10 +502,8 @@ export function visitSwitchStatement(node, context) {
                         ...context,
                         switchBreakLabel,
                         currentLabel: undefined, // Clear currentLabel for nested visits
-                        topLevelScopeSymbols,
-                        localScopeSymbols: hoistedSymbols,
-                        derefBeforeAssignment: true,
-                        isAssignmentOnly: ts.isVariableStatement(stmt),
+                        globalScopeSymbols,
+                        localScopeSymbols,
                     });
                 }
             }
@@ -455,15 +523,35 @@ export function visitSwitchStatement(node, context) {
             }
             this.indentationLevel++;
             for (const stmt of clause.statements) {
-                code += this.visit(stmt, {
-                    ...context,
-                    switchBreakLabel,
-                    currentLabel: undefined, // Clear currentLabel for nested visits
-                    topLevelScopeSymbols,
-                    localScopeSymbols: hoistedSymbols,
-                    derefBeforeAssignment: true,
-                    isAssignmentOnly: ts.isVariableStatement(stmt),
-                });
+                if (ts.isFunctionDeclaration(stmt)) {
+                    // Already handled
+                }
+                else if (ts.isVariableStatement(stmt)) {
+                    const isLetOrConst = (stmt.declarationList.flags &
+                        (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+                        0;
+                    const contextForVisit = {
+                        ...context,
+                        switchBreakLabel,
+                        currentLabel: undefined,
+                        globalScopeSymbols,
+                        localScopeSymbols,
+                        isAssignmentOnly: !isLetOrConst,
+                    };
+                    const assignments = this.visit(stmt.declarationList, contextForVisit);
+                    if (assignments) {
+                        code += `${this.indent()}${assignments};\n`;
+                    }
+                }
+                else {
+                    code += this.visit(stmt, {
+                        ...context,
+                        switchBreakLabel,
+                        currentLabel: undefined, // Clear currentLabel for nested visits
+                        globalScopeSymbols,
+                        localScopeSymbols,
+                    });
+                }
             }
             this.indentationLevel--;
             code += `${this.indent()}}\n`;

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

@@ -12,27 +12,50 @@ export function visitVariableDeclaration(node, context) {
     const scope = this.getScopeForNode(varDecl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
     // Mark the symbol as checked
-    this.markSymbolAsChecked(name, context.topLevelScopeSymbols, context.localScopeSymbols);
+    this.markSymbolAsInitialized(name, context.globalScopeSymbols, context.localScopeSymbols);
+    let nativeLambdaCode = "";
     let initializer = "";
+    let shouldSkipDeref = false;
     if (varDecl.initializer) {
         const initExpr = varDecl.initializer;
-        const initContext = {
-            ...context,
-            lambdaName: ts.isArrowFunction(initExpr) ? name : undefined, // Pass the variable name for arrow functions
-        };
         let initText = ts.isNumericLiteral(initExpr)
             ? initExpr.getText()
-            : this.visit(initExpr, initContext);
+            : this.visit(initExpr, context);
         if (ts.isIdentifier(initExpr)) {
             const initScope = this.getScopeForNode(initExpr);
             const initTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, initScope);
             const varName = this.getJsVarName(initExpr);
+            // Check if both target and initializer are heap allocated
+            if (typeInfo.needsHeapAllocation &&
+                initTypeInfo?.needsHeapAllocation) {
+                shouldSkipDeref = true;
+            }
             if (initTypeInfo &&
                 !initTypeInfo.isParameter &&
-                !initTypeInfo.isBuiltin) {
-                initText = this.getDerefCode(initText, varName, initContext, initTypeInfo);
+                !initTypeInfo.isBuiltin &&
+                !shouldSkipDeref) {
+                initText = this.getDerefCode(initText, varName, context, initTypeInfo);
             }
         }
+        else if (ts.isArrowFunction(initExpr)) {
+            const initContext = {
+                ...context,
+                lambdaName: name, // Use the variable name as function name
+            };
+            // Generate and update self name
+            const nativeName = this.generateUniqueName(`__${name}_native_`, context.localScopeSymbols, context.globalScopeSymbols);
+            context.localScopeSymbols.update(name, { func: { nativeName } });
+            // Generate lambda
+            const lambda = this.generateLambda(initExpr, initContext, {
+                isAssignment: true,
+                generateOnlyLambda: true,
+                nativeName,
+            });
+            nativeLambdaCode =
+                `auto ${nativeName} = ${lambda};\n${this.indent()}`;
+            // Generate AnyValue wrapper
+            initText = this.generateFullLambdaExpression(initExpr, initContext, nativeName, { isAssignment: true, noTypeSignature: true });
+        }
         initializer = " = " + initText;
     }
     const isLetOrConst = (varDecl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
@@ -40,19 +63,21 @@ export function visitVariableDeclaration(node, context) {
         (!context.localScopeSymbols.has(name));
     const assignmentTarget = shouldDeref
         ? this.getDerefCode(name, name, context, typeInfo)
-        : (typeInfo.needsHeapAllocation ? `*${name}` : name);
+        : (typeInfo.needsHeapAllocation && !shouldSkipDeref
+            ? `*${name}`
+            : name);
     if (isLetOrConst) {
         // If there's no initializer, it should be assigned undefined.
         if (!initializer) {
-            return `${assignmentTarget} = jspp::Constants::UNDEFINED`;
+            return `${nativeLambdaCode}${assignmentTarget} = jspp::Constants::UNDEFINED`;
         }
-        return `${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
     }
     // For 'var', it's a bit more complex.
     if (context.isAssignmentOnly) {
         if (!initializer)
             return "";
-        return `${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
     }
     else {
         // This case should not be hit with the new hoisting logic,

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

@@ -28,6 +28,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 +109,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;
 }
@@ -439,6 +444,21 @@ export function visitBinaryExpression(node, context) {
         const target = context.derefBeforeAssignment
             ? this.getDerefCode(leftText, leftText, context, 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);
@@ -535,7 +555,7 @@ export function visitConditionalExpression(node, context) {
         ...context,
         isFunctionBody: false,
     });
-    return `is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
+    return `jspp::is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
 }
 export function visitCallExpression(node, context) {
     const callExpr = node;
@@ -645,6 +665,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);
         }
     }