@ugo-studio/jspp 0.1.4 → 0.1.6

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

@@ -1,5 +1,7 @@
 import ts from "typescript";
+import { DeclaredSymbols } from "../../ast/symbols";
 import { CodeGenerator } from "./";
+import { collectFunctionScopedDeclarations } from "./helpers";
 export function generateLambda(node, context, options) {
     const isAssignment = options?.isAssignment || false;
     const capture = options?.capture || "[=]";
@@ -11,76 +13,175 @@ export function generateLambda(node, context, options) {
         isInsideGeneratorFunction: isInsideGeneratorFunction,
         isInsideAsyncFunction: isInsideAsyncFunction,
     });
-    const funcReturnType = isInsideGeneratorFunction
-        ? "jspp::JsIterator<jspp::AnyValue>"
-        : (isInsideAsyncFunction ? "jspp::JsPromise" : "jspp::AnyValue");
+    const funcReturnType = (isInsideGeneratorFunction && isInsideAsyncFunction)
+        ? "jspp::JsAsyncIterator<jspp::AnyValue>"
+        : (isInsideGeneratorFunction
+            ? "jspp::JsIterator<jspp::AnyValue>"
+            : (isInsideAsyncFunction ? "jspp::JsPromise" : "jspp::AnyValue"));
     const isArrow = ts.isArrowFunction(node);
-    // For generators and async functions, we MUST copy arguments because the coroutine suspends immediately
-    // and references to temporary arguments would dangle.
-    const paramThisType = (isInsideGeneratorFunction || isInsideAsyncFunction)
-        ? "jspp::AnyValue"
-        : "const jspp::AnyValue&";
-    const paramArgsType = (isInsideGeneratorFunction || isInsideAsyncFunction)
-        ? "std::vector<jspp::AnyValue>"
-        : "const std::vector<jspp::AnyValue>&";
+    // Lambda arguments are ALWAYS const references/spans to avoid copy overhead for normal functions.
+    // For generators/async, we manually copy them inside the body.
+    const paramThisType = "const jspp::AnyValue&";
+    const paramArgsType = "std::span<const jspp::AnyValue>";
     const thisArgParam = isArrow
-        ? "const jspp::AnyValue&" // Arrow functions are never generators in this parser
+        ? "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.currentScopeSymbols);
+    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
     const visitContext = {
         isMainContext: false,
         isInsideFunction: true,
         isFunctionBody: false,
         lambdaName: undefined,
         topLevelScopeSymbols,
-        currentScopeSymbols: new Map(),
+        localScopeSymbols: new DeclaredSymbols(),
         superClassVar: context.superClassVar,
+        isInsideGeneratorFunction: isInsideGeneratorFunction,
+        isInsideAsyncFunction: isInsideAsyncFunction,
     };
-    if (node.body) {
-        if (ts.isBlock(node.body)) {
-            let paramExtraction = "";
-            this.indentationLevel++;
-            node.parameters.forEach((p, i) => {
-                const name = p.name.getText();
-                const defaultValue = p.initializer
-                    ? this.visit(p.initializer, visitContext)
-                    : "jspp::AnyValue::make_undefined()";
-                if (!!p.dotDotDotToken) {
-                    if (node.parameters.length - 1 !== i) {
-                        throw new SyntaxError("Rest parameter must be last formal parameter.");
-                    }
-                    const tempName = `temp_${name}`;
-                    paramExtraction +=
-                        `${this.indent()}auto ${name} = jspp::AnyValue::make_undefined();\n`;
-                    paramExtraction += `${this.indent()}{\n`;
-                    this.indentationLevel++;
-                    paramExtraction +=
-                        `${this.indent()}std::vector<std::optional<jspp::AnyValue>> ${tempName};\n`;
-                    paramExtraction +=
-                        `${this.indent()}if (${argsName}.size() > ${i}) {\n`;
-                    this.indentationLevel++;
-                    paramExtraction +=
-                        `${this.indent()}${tempName}.reserve(${argsName}.size() - ${i});\n`;
-                    this.indentationLevel--;
-                    paramExtraction += `${this.indent()}}\n`;
-                    paramExtraction +=
-                        `${this.indent()}for (size_t i = ${i}; i < ${argsName}.size(); i++) {\n`;
-                    this.indentationLevel++;
-                    paramExtraction +=
-                        `${this.indent()}${tempName}.push_back(${argsName}[i]);\n`;
-                    this.indentationLevel--;
-                    paramExtraction += `${this.indent()}}\n`;
-                    paramExtraction +=
-                        `${this.indent()}${name} = jspp::AnyValue::make_array(std::move(${tempName}));\n`;
-                    this.indentationLevel--;
-                    paramExtraction += `${this.indent()}}\n`;
+    // 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) {
+        const thisCopy = this.generateUniqueName("__this_copy", declaredSymbols);
+        const argsCopy = this.generateUniqueName("__args_copy", declaredSymbols);
+        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;
+    let finalArgsParamName = argsName;
+    if (isInsideGeneratorFunction || isInsideAsyncFunction) {
+        if (!isArrow) {
+            finalThisParamName = this.generateUniqueName("__this_ref", declaredSymbols);
+        }
+        finalArgsParamName = this.generateUniqueName("__args_ref", declaredSymbols);
+    }
+    const thisArgParamFinal = isArrow
+        ? "const jspp::AnyValue&"
+        : `${paramThisType} ${finalThisParamName}`;
+    // Re-construct lambda header with potentially new param names
+    lambda =
+        `${capture}(${thisArgParamFinal}, ${paramArgsType} ${finalArgsParamName}) mutable -> ${funcReturnType} `;
+    // Regenerate preamble
+    preamble = "";
+    if (isInsideGeneratorFunction || isInsideAsyncFunction) {
+        if (!isArrow) {
+            preamble +=
+                `${this.indent()}jspp::AnyValue ${this.globalThisVar} = ${finalThisParamName};\n`;
+        }
+        preamble +=
+            `${this.indent()}std::vector<jspp::AnyValue> ${argsName}(${finalArgsParamName}.begin(), ${finalArgsParamName}.end());\n`;
+    }
+    // Now 'argsName' refers to the vector (if copied) or the span (if not).
+    // And 'this.globalThisVar' refers to the copy (if copied) or the param (if not).
+    // So subsequent code using `argsName` and `visit` (using `globalThisVar`) works correctly.
+    const paramExtractor = (parameters) => {
+        let code = "";
+        parameters.forEach((p, i) => {
+            const name = p.name.getText();
+            const defaultValue = p.initializer
+                ? this.visit(p.initializer, visitContext)
+                : "jspp::Constants::UNDEFINED";
+            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.");
+                }
+                if (typeInfo.needsHeapAllocation) {
+                    code +=
+                        `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 }
                 else {
-                    paramExtraction +=
-                        `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
+                    code +=
+                        `${this.indent()}jspp::AnyValue ${name} = jspp::Constants::UNDEFINED;\n`;
                 }
+                // Extract rest parameters
+                const tempName = `temp_${name}`;
+                code += `${this.indent()}{\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}std::vector<std::optional<jspp::AnyValue>> ${tempName};\n`;
+                code += `${this.indent()}if (${argsName}.size() > ${i}) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}${tempName}.reserve(${argsName}.size() - ${i});\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                code +=
+                    `${this.indent()}for (size_t j = ${i}; j < ${argsName}.size(); j++) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}${tempName}.push_back(${argsName}[j]);\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                code += `${this.indent()}${typeInfo.needsHeapAllocation ? "*" : ""}${name} = jspp::AnyValue::make_array(std::move(${tempName}));\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                return;
+            }
+            // Normal parameter
+            const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
+            if (typeInfo && typeInfo.needsHeapAllocation) {
+                code +=
+                    `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
+            }
+        });
+        return code;
+    };
+    if (node.body) {
+        if (ts.isBlock(node.body)) {
+            // Hoist var declarations in the function body
+            const varDecls = collectFunctionScopedDeclarations(node.body);
+            varDecls.forEach((decl) => {
+                preamble += this.hoistDeclaration(decl, visitContext.localScopeSymbols);
             });
+            this.indentationLevel++;
+            const paramExtraction = paramExtractor(node.parameters);
             this.indentationLevel--;
             const blockContent = this.visit(node.body, {
                 ...visitContext,
@@ -90,20 +191,15 @@ export function generateLambda(node, context, options) {
                 isInsideGeneratorFunction: isInsideGeneratorFunction,
                 isInsideAsyncFunction: isInsideAsyncFunction,
             });
-            // The block visitor already adds braces, so we need to inject the param extraction.
-            lambda += "{\n" + paramExtraction + blockContent.substring(2);
+            // The block visitor already adds braces, so we need to inject the preamble and param extraction.
+            lambda += "{\n" + preamble + paramExtraction +
+                blockContent.trimStart().substring(2);
         }
         else {
             lambda += "{\n";
             this.indentationLevel++;
-            node.parameters.forEach((p, i) => {
-                const name = p.name.getText();
-                const defaultValue = p.initializer
-                    ? this.visit(p.initializer, visitContext)
-                    : "jspp::AnyValue::make_undefined()";
-                lambda +=
-                    `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
-            });
+            lambda += preamble;
+            lambda += paramExtractor(node.parameters);
             lambda += `${this.indent()}${returnCmd} ${this.visit(node.body, {
                 ...visitContext,
                 isMainContext: false,
@@ -111,34 +207,41 @@ export function generateLambda(node, context, options) {
                 isFunctionBody: false,
                 isInsideGeneratorFunction: isInsideGeneratorFunction,
                 isInsideAsyncFunction: isInsideAsyncFunction,
-            })};
-`;
+            })};\n`;
             this.indentationLevel--;
             lambda += `${this.indent()}}`;
         }
     }
     else {
-        lambda += `{ ${returnCmd} jspp::AnyValue::make_undefined(); }\n`;
+        lambda += `{ ${preamble} ${returnCmd} jspp::Constants::UNDEFINED; }\n`;
     }
     let signature = "";
     let callable = "";
     let method = "";
     // Handle generator function
     if (isInsideGeneratorFunction) {
-        signature =
-            "jspp::JsIterator<jspp::AnyValue>(const jspp::AnyValue&, const std::vector<jspp::AnyValue>&)";
-        callable = `std::function<${signature}>(${lambda})`;
-        method = `jspp::AnyValue::make_generator`;
+        if (isInsideAsyncFunction) {
+            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})`;
+            method = `jspp::AnyValue::make_generator`;
+        }
     } // Handle async function
     else if (isInsideAsyncFunction) {
         signature =
-            "jspp::JsPromise(const jspp::AnyValue&, const std::vector<jspp::AnyValue>&)";
+            "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&, const std::vector<jspp::AnyValue>&)`;
+            `jspp::AnyValue(const jspp::AnyValue&, std::span<const jspp::AnyValue>)`;
         callable = `std::function<${signature}>(${lambda})`;
         if (options?.isClass) {
             method = `jspp::AnyValue::make_class`;
@@ -147,9 +250,33 @@ export function generateLambda(node, context, options) {
             method = `jspp::AnyValue::make_function`;
         }
     }
-    const funcName = node.name?.getText();
-    const fullExpression = `${method}(${callable}, "${context?.lambdaName || funcName || ""}")`;
-    if (ts.isFunctionDeclaration(node) && !isAssignment && funcName) {
+    const funcName = context?.lambdaName || node.name?.getText();
+    const hasName = !!funcName && funcName.length > 0;
+    let args = callable;
+    const isMethod = ts.isMethodDeclaration(node);
+    const isAccessor = ts.isGetAccessor(node) || ts.isSetAccessor(node);
+    const isConstructor = !isArrow && !isMethod && !isAccessor;
+    // make_function(callable, name, is_constructor)
+    if (method === `jspp::AnyValue::make_function`) {
+        if (hasName) {
+            args += `, "${funcName}"`;
+        }
+        else if (!isConstructor) {
+            args += `, std::nullopt`;
+        }
+        if (!isConstructor) {
+            args += `, false`;
+        }
+    }
+    else {
+        // make_class, make_generator, make_async_function
+        if (hasName) {
+            args += `, "${funcName}"`;
+        }
+    }
+    const fullExpression = `${method}(${args})`;
+    if (ts.isFunctionDeclaration(node) && !isAssignment && node.name) {
+        const funcName = node.name?.getText();
         return `${this.indent()}auto ${funcName} = ${fullExpression};\n`;
     }
     return fullExpression;

package/dist/core/codegen/helpers.js

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope";
-import { DeclaredSymbolType } from "../../ast/types";
+import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols";
 import { CodeGenerator } from "./";
 export function isBuiltinObject(node) {
     return BUILTIN_OBJECTS.values().some((obj) => obj.name === node.text);
@@ -33,23 +33,21 @@ export function getDeclaredSymbols(node) {
     visitor(node);
     return symbols;
 }
-export function generateUniqueName(prefix, namesToAvoid) {
-    let name = `${prefix}${this.exceptionCounter}`;
-    while (namesToAvoid.has(name)) {
-        this.exceptionCounter++;
-        name = `${prefix}${this.exceptionCounter}`;
+export function generateUniqueName(prefix, ...namesToAvoid) {
+    let name = `${prefix}${this.uniqueNameCounter}`;
+    while (namesToAvoid.some((names) => names.has(name))) {
+        this.uniqueNameCounter++;
+        name = `${prefix}${this.uniqueNameCounter}`;
     }
-    this.exceptionCounter++;
+    this.uniqueNameCounter++;
     return name;
 }
-export function generateUniqueExceptionName(nameToAvoid) {
-    let exceptionName = `__caught_exception_${this.exceptionCounter}`;
-    while (exceptionName === nameToAvoid) {
-        this.exceptionCounter++;
-        exceptionName = `__caught_exception_${this.exceptionCounter}`;
+export function generateUniqueExceptionName(exceptionNameToAvoid, ...otherNamesToAvoid) {
+    let prefix = `__caught_exception_`;
+    if (exceptionNameToAvoid) {
+        prefix += exceptionNameToAvoid;
     }
-    this.exceptionCounter++;
-    return exceptionName;
+    return this.generateUniqueName(prefix, ...otherNamesToAvoid);
 }
 export function getScopeForNode(node) {
     let current = node;
@@ -80,19 +78,49 @@ export function escapeString(str) {
 export function getJsVarName(node) {
     return `"${node.text}"`;
 }
-export function getDerefCode(nodeText, varName, typeInfo) {
+export function getDerefCode(nodeText, varName, context, typeInfo) {
     // Make sure varName is incased in quotes
     if (!varName.startsWith('"'))
         varName = '"' + varName;
     if (!varName.endsWith('"'))
         varName = varName + '"';
-    if (typeInfo && typeInfo.needsHeapAllocation) {
-        return `jspp::Access::deref_ptr(${nodeText}, ${varName})`;
+    const symbolName = varName.slice(1).slice(0, -1);
+    const symbol = context.localScopeSymbols.get(symbolName) ??
+        context.topLevelScopeSymbols.get(symbolName);
+    const checkedIfUninitialized = symbol?.checkedIfUninitialized ||
+        false;
+    // Mark the symbol as checked
+    this.markSymbolAsChecked(symbolName, context.topLevelScopeSymbols, context.localScopeSymbols);
+    // Apply deref code
+    if (checkedIfUninitialized) {
+        if (typeInfo && typeInfo.needsHeapAllocation) {
+            return `(*${nodeText})`;
+        }
+        return `${nodeText}`;
+    }
+    else {
+        if (typeInfo && typeInfo.needsHeapAllocation) {
+            return `jspp::Access::deref_ptr(${nodeText}, ${varName})`;
+        }
+        return `jspp::Access::deref_stack(${nodeText}, ${varName})`;
+    }
+}
+export function markSymbolAsChecked(name, topLevel, local) {
+    if (topLevel.has(name)) {
+        topLevel.update(name, {
+            checkedIfUninitialized: true,
+        });
+    }
+    else if (local.has(name)) {
+        local.update(name, {
+            checkedIfUninitialized: true,
+        });
     }
-    return `jspp::Access::deref_stack(${nodeText}, ${varName})`;
 }
 export function getReturnCommand(context) {
-    return (context.isInsideGeneratorFunction || context.isInsideAsyncFunction) ? "co_return" : "return";
+    return (context.isInsideGeneratorFunction || context.isInsideAsyncFunction)
+        ? "co_return"
+        : "return";
 }
 export function hoistDeclaration(decl, hoistedSymbols) {
     const name = decl.name?.getText();
@@ -101,13 +129,16 @@ export function hoistDeclaration(decl, hoistedSymbols) {
     }
     const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
         0;
+    // if (name === "letVal") console.log("hoistDeclaration: letVal isLetOrConst=", isLetOrConst, " flags=", decl.parent.flags);
     const symbolType = isLetOrConst
         ? DeclaredSymbolType.letOrConst
         : (ts.isFunctionDeclaration(decl)
             ? DeclaredSymbolType.function
-            : (ts.isClassDeclaration(decl) ? DeclaredSymbolType.letOrConst : DeclaredSymbolType.var));
+            : (ts.isClassDeclaration(decl)
+                ? DeclaredSymbolType.letOrConst
+                : DeclaredSymbolType.var));
     if (hoistedSymbols.has(name)) {
-        const existingType = hoistedSymbols.get(name);
+        const existingType = hoistedSymbols.get(name)?.type;
         // Don't allow multiple declaration of `letOrConst` or `function` or `class` variables
         if (existingType === DeclaredSymbolType.letOrConst ||
             existingType === DeclaredSymbolType.function ||
@@ -117,12 +148,15 @@ export function hoistDeclaration(decl, hoistedSymbols) {
         // `var` variables can be declared multiple times
         return "";
     }
-    hoistedSymbols.set(name, symbolType);
+    hoistedSymbols.set(name, {
+        type: symbolType,
+        checkedIfUninitialized: false,
+    });
     const scope = this.getScopeForNode(decl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
     const initializer = isLetOrConst || ts.isClassDeclaration(decl)
-        ? "jspp::AnyValue::make_uninitialized()"
-        : "jspp::AnyValue::make_undefined()";
+        ? "jspp::Constants::UNINITIALIZED"
+        : "jspp::Constants::UNDEFINED";
     if (typeInfo.needsHeapAllocation) {
         return `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
     }
@@ -142,10 +176,73 @@ export function isAsyncFunction(node) {
         ts.isFunctionExpression(node) ||
         ts.isMethodDeclaration(node) ||
         ts.isArrowFunction(node)) &&
-        (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async) !== 0);
+        (ts.getCombinedModifierFlags(node) &
+            ts.ModifierFlags.Async) !== 0);
 }
 export function prepareScopeSymbolsForVisit(topLevel, local) {
-    const newTopLevel = new Map(topLevel);
-    local.forEach((v, k) => newTopLevel.set(k, v));
-    return newTopLevel;
+    // Join the top and local scopes
+    return new DeclaredSymbols(topLevel, local);
+}
+export function collectFunctionScopedDeclarations(node) {
+    const decls = [];
+    function visit(n) {
+        if (ts.isVariableStatement(n)) {
+            const isLetOrConst = (n.declarationList.flags &
+                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+            if (!isLetOrConst) {
+                decls.push(...n.declarationList.declarations);
+            }
+        }
+        else if (ts.isForStatement(n)) {
+            if (n.initializer && ts.isVariableDeclarationList(n.initializer)) {
+                const isLetOrConst = (n.initializer.flags &
+                    (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                if (!isLetOrConst) {
+                    decls.push(...n.initializer.declarations);
+                }
+            }
+        }
+        else if (ts.isForInStatement(n)) {
+            if (ts.isVariableDeclarationList(n.initializer)) {
+                const isLetOrConst = (n.initializer.flags &
+                    (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                if (!isLetOrConst) {
+                    decls.push(...n.initializer.declarations);
+                }
+            }
+        }
+        else if (ts.isForOfStatement(n)) {
+            if (ts.isVariableDeclarationList(n.initializer)) {
+                const isLetOrConst = (n.initializer.flags &
+                    (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                if (!isLetOrConst) {
+                    decls.push(...n.initializer.declarations);
+                }
+            }
+        }
+        // Stop recursion at function boundaries (but not the root node if it is a function)
+        if (n !== node &&
+            (ts.isFunctionDeclaration(n) || ts.isFunctionExpression(n) ||
+                ts.isArrowFunction(n) || ts.isMethodDeclaration(n) ||
+                ts.isGetAccessor(n) || ts.isSetAccessor(n) ||
+                ts.isClassDeclaration(n))) {
+            return;
+        }
+        ts.forEachChild(n, visit);
+    }
+    ts.forEachChild(node, visit);
+    return decls;
+}
+export function collectBlockScopedDeclarations(statements) {
+    const decls = [];
+    for (const stmt of statements) {
+        if (ts.isVariableStatement(stmt)) {
+            const isLetOrConst = (stmt.declarationList.flags &
+                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+            if (isLetOrConst) {
+                decls.push(...stmt.declarationList.declarations);
+            }
+        }
+    }
+    return decls;
 }

package/dist/core/codegen/index.js

@@ -1,13 +1,13 @@
-import { TypeAnalyzer } from "../../analysis/typeAnalyzer";
+import { DeclaredSymbols } from "../../ast/symbols";
 import { generateLambda } from "./function-handlers";
-import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isGeneratorFunction, prepareScopeSymbolsForVisit, } from "./helpers";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isGeneratorFunction, markSymbolAsChecked, prepareScopeSymbolsForVisit, } from "./helpers";
 import { visit } from "./visitor";
-const CONTAINER_FUNCTION_NAME = "__container__";
+const MODULE_NAME = "__main_function__";
 export class CodeGenerator {
     indentationLevel = 0;
     typeAnalyzer;
     globalThisVar;
-    exceptionCounter = 0;
+    uniqueNameCounter = 0;
     // visitor
     visit = visit;
     // helpers
@@ -25,6 +25,7 @@ export class CodeGenerator {
     isGeneratorFunction = isGeneratorFunction;
     isAsyncFunction = isAsyncFunction;
     prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
+    markSymbolAsChecked = markSymbolAsChecked;
     // function handlers
     generateLambda = generateLambda;
     /**
@@ -34,7 +35,7 @@ export class CodeGenerator {
         this.typeAnalyzer = analyzer;
         this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
         const declarations = `#include "index.hpp"\n\n`;
-        let containerCode = `jspp::AnyValue ${CONTAINER_FUNCTION_NAME}() {\n`;
+        let containerCode = `jspp::JsPromise ${MODULE_NAME}() {\n`;
         this.indentationLevel++;
         containerCode +=
             `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
@@ -42,24 +43,31 @@ export class CodeGenerator {
             isMainContext: true,
             isInsideFunction: true,
             isFunctionBody: true,
-            topLevelScopeSymbols: new Map(),
-            currentScopeSymbols: new Map(),
+            isInsideAsyncFunction: true,
+            topLevelScopeSymbols: new DeclaredSymbols(),
+            localScopeSymbols: new DeclaredSymbols(),
         });
         this.indentationLevel--;
-        containerCode += "  return jspp::AnyValue::make_undefined();\n";
+        containerCode += "  co_return jspp::Constants::UNDEFINED;\n";
         containerCode += "}\n\n";
-        let mainCode = "int main() {\n";
-        // std::ios::sync_with_stdio(false); // Removed to fix console output buffering
-        // std::cin.tie(nullptr);            // Removed to fix console output buffering
+        let mainCode = "int main(int argc, char** argv) {\n";
         mainCode += `  try {\n`;
-        mainCode += `    ${CONTAINER_FUNCTION_NAME}();\n`;
+        mainCode += `    jspp::setup_process_argv(argc, argv);\n`;
+        mainCode += `    auto p = ${MODULE_NAME}();\n`;
+        mainCode += `    p.then(nullptr, [](const jspp::AnyValue& err) {\n`;
+        mainCode +=
+            `        auto error = std::make_shared<jspp::AnyValue>(err);\n`;
+        mainCode +=
+            `        console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+        mainCode += `        std::exit(1);\n`;
+        mainCode += `    });\n`;
         mainCode += `    jspp::Scheduler::instance().run();\n`;
         mainCode += `  } catch (const std::exception& ex) {\n`;
         mainCode +=
-            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n{\n";
+            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n    {\n";
         mainCode +=
-            `    ([&](){ auto __obj = console; return __obj.get_own_property("error").as_function("console.error")->call(__obj, {*error}); })();\n`;
-        mainCode += `    return 1;\n}\n`;
+            `      console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+        mainCode += `      return 1;\n    }\n`;
         mainCode += `  }\n`;
         mainCode += "  return 0;\n}";
         return declarations + containerCode + mainCode;