@ugo-studio/jspp 0.1.5 → 0.1.7

package/LICENSE

@@ -1,21 +1,25 @@
-MIT License
-
-Copyright (c) 2025 Emmanuel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the “Software”), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+# License
+
+JSPP is licensed under the [MIT License](#mit-license).
+
+## MIT License
+
+Copyright (c) 2025 Emmanuel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # JSPP (JavaScript++)
 
-[![Build Status](https://img.shields.io/badge/build-passing-brightgreen)](https://github.com/ugo-studio/jspp)
+[![CI](https://github.com/ugo-studio/jspp/actions/workflows/ci.yml/badge.svg)](https://github.com/ugo-studio/jspp/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 **JSPP is a modern, experimental transpiler that converts JavaScript code into high-performance, standard C++23.**
@@ -33,24 +33,10 @@ JSPP reserves certain keywords to avoid conflicts with the generated C++ code an
 
 - `std`: Reserved to prevent conflicts with the C++ standard library namespace.
 - `jspp`: Reserved for internal use by the JSPP transpiler.
-- `co_yield`: Reserved to prevent conflicts with the c++ generator functions.
-- `co_return`: Reserved to prevent conflicts with the c++ generator functions.
+- `co_yield`,`co_return`,`co_await`: Reserved to prevent conflicts with the c++ couroutine keywords.
 
 Using these keywords as variable names will result in a `SyntaxError`.
 
-## How It Works
-
-The transpilation process is a classic three-stage pipeline:
-
-1.  **Parsing:** The incoming JavaScript code is parsed into an Abstract Syntax Tree (AST) using the powerful TypeScript compiler API. This gives us a structured, traversable representation of the code.
-
-2.  **Analysis:** The `TypeAnalyzer` traverses the AST. While it doesn't perform traditional static type checking, it plays a crucial role in understanding the code's structure. It identifies scopes (global, function, block) and detects when variables are "captured" by closures.
-
-3.  **Code Generation:** The `CodeGenerator` performs a final traversal of the AST. It translates each node into its C++ equivalent.
-    - All variables are declared as `std::shared_ptr<AnyValue>` (where `AnyValue` uses a [Tagged Union](https://en.wikipedia.org/wiki/Tagged_union) method for managing dynamic types like JavaScript). This approach elegantly mimics JavaScript's dynamic types and reference-based memory model.
-    - Closures are implemented as C++ lambdas that capture `shared_ptr`s by value, ensuring variable lifetimes are correctly extended beyond their original scope.
-    - The entire script is wrapped into a single `main` function, with hoisting logic carefully replicated to ensure correct execution order.
-
 ## Installation
 
 To use JSPP as a command-line tool, install it globally via npm:

package/dist/ast/symbols.js

@@ -26,4 +26,7 @@ export class DeclaredSymbols {
             return this.symbols.set(name, newValue);
         }
     }
+    toSet() {
+        return new Set(this.symbols.keys());
+    }
 }

package/dist/cli.js

@@ -27,8 +27,11 @@ async function main() {
     console.log(`${COLORS.bold}JSPP Compiler${COLORS.reset} ${COLORS.dim}v${pkg.version}${COLORS.reset}`);
     console.log(`Mode: ${isRelease ? COLORS.green : COLORS.yellow}${mode.toUpperCase()}${COLORS.reset}\n`);
     const flags = isRelease
-        ? ["-O3", "-DNDEBUG", "-Wa,-mbig-obj"]
-        : ["-O0", "-Wa,-mbig-obj"];
+        ? ["-O3", "-DNDEBUG"]
+        : ["-O0"];
+    if (process.platform === "win32") {
+        flags.push("-Wa,-mbig-obj");
+    }
     const pchDir = path.resolve(process.cwd(), "prelude-build", mode);
     const spinner = new Spinner("Initializing...");
     try {
@@ -42,7 +45,7 @@ async function main() {
         // 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);
-        spinner.succeed(`Generated ${COLORS.dim}${path.basename(cppFilePath)}${COLORS.reset}`);
+        spinner.succeed(`Generated cpp`);
         // 2. Precompiled Header Check
         spinner.text = "Checking precompiled headers...";
         spinner.start();
@@ -76,7 +79,7 @@ async function main() {
             spinner.succeed("Precompiled headers updated");
         }
         else {
-            spinner.succeed("Precompiled headers up-to-date");
+            spinner.succeed("Precompiled headers");
         }
         // 3. Compilation Phase
         spinner.text = `Compiling binary...`;

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

@@ -70,7 +70,7 @@ export function visitForStatement(node, context) {
         ...context,
         currentLabel: undefined,
         isFunctionBody: false,
-    });
+    }).trim();
     if (ts.isBlock(node.statement)) {
         let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
         if (context.currentLabel) {
@@ -218,14 +218,27 @@ export function visitForOfStatement(node, context) {
     const iterator = this.generateUniqueName("__iter", declaredSymbols);
     const nextFunc = this.generateUniqueName("__next_func", declaredSymbols);
     const nextRes = this.generateUniqueName("__next_res", declaredSymbols);
+    const isAwait = forOf.awaitModifier !== undefined;
     const varName = this.getJsVarName(forOf.expression);
     code += `${this.indent()}auto ${iterableRef} = ${derefIterable};\n`;
-    code +=
-        `${this.indent()}auto ${iterator} = jspp::Access::get_object_value_iterator(${iterableRef}, ${varName});\n`;
+    if (isAwait) {
+        code +=
+            `${this.indent()}auto ${iterator} = jspp::Access::get_async_object_value_iterator(${iterableRef}, ${varName});\n`;
+    }
+    else {
+        code +=
+            `${this.indent()}auto ${iterator} = jspp::Access::get_object_value_iterator(${iterableRef}, ${varName});\n`;
+    }
     code +=
         `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("next");\n`;
-    code +=
-        `${this.indent()}auto ${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    if (isAwait) {
+        code +=
+            `${this.indent()}auto ${nextRes} = co_await ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    }
+    else {
+        code +=
+            `${this.indent()}auto ${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    }
     code +=
         `${this.indent()}while (!is_truthy(${nextRes}.get_own_property("done"))) {\n`;
     this.indentationLevel++;
@@ -239,8 +252,14 @@ export function visitForOfStatement(node, context) {
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}_continue:;\n`;
     }
-    code +=
-        `${this.indent()}${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    if (isAwait) {
+        code +=
+            `${this.indent()}${nextRes} = co_await ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    }
+    else {
+        code +=
+            `${this.indent()}${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    }
     this.indentationLevel--;
     code += `${this.indent()}}\n`;
     this.indentationLevel--; // Exit the scope for the for-of loop
@@ -269,7 +288,7 @@ export function visitWhileStatement(node, context) {
         ...context,
         currentLabel: undefined,
         isFunctionBody: false,
-    });
+    }).trim();
     if (ts.isBlock(node.statement)) {
         let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
         if (context.currentLabel) {
@@ -309,7 +328,7 @@ export function visitDoStatement(node, context) {
         ...context,
         currentLabel: undefined,
         isFunctionBody: false,
-    });
+    }).trim();
     if (ts.isBlock(node.statement)) {
         let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
         if (context.currentLabel) {

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

@@ -28,8 +28,9 @@ export function visitObjectPropertyName(node, context) {
 export function visitObjectLiteralExpression(node, context) {
     const obj = node;
     const objVar = this.generateUniqueName("__obj_", this.getDeclaredSymbols(node));
-    let code = `([&]() {
-${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"));\n`;
+    let code = `([&]() {\n`;
+    code +=
+        `${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"));\n`;
     this.indentationLevel++;
     for (const prop of obj.properties) {
         if (ts.isPropertyAssignment(prop)) {
@@ -101,6 +102,8 @@ ${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object_with_proto({}, ::
         }
     }
     this.indentationLevel--;
+    // code +=
+    //     `${this.indent()}  ${returnCmd} ${objVar};\n${this.indent()}} )() ))`;
     code += `${this.indent()}  return ${objVar};\n${this.indent()}})()`;
     return code;
 }
@@ -593,7 +596,7 @@ export function visitCallExpression(node, context) {
         if (callExpr.questionDotToken) {
             return `jspp::Access::optional_call(${derefObj}.get_own_property("${propName}"), ${derefObj}, ${argsSpan}, "${this.escapeString(propName)}")`;
         }
-        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property("${propName}").call(__obj, ${argsSpan}, "${this.escapeString(propName)}"); })()`;
+        return `${derefObj}.call_own_property("${propName}", ${argsSpan})`;
     }
     // Handle obj[method]() -> pass obj as 'this'
     if (ts.isElementAccessExpression(callee)) {
@@ -628,7 +631,7 @@ export function visitCallExpression(node, context) {
         if (callExpr.questionDotToken) {
             return `jspp::Access::optional_call(${derefObj}.get_own_property(${argText}), ${derefObj}, ${argsSpan})`;
         }
-        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property(${argText}).call(__obj, ${argsSpan}); })()`;
+        return `${derefObj}.call_own_property(${argText}, ${argsSpan})`;
     }
     const calleeCode = this.visit(callee, context);
     let derefCallee = calleeCode;

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

@@ -13,9 +13,11 @@ 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);
     // Lambda arguments are ALWAYS const references/spans to avoid copy overhead for normal functions.
     // For generators/async, we manually copy them inside the body.
@@ -34,8 +36,10 @@ export function generateLambda(node, context, options) {
         topLevelScopeSymbols,
         localScopeSymbols: new DeclaredSymbols(),
         superClassVar: context.superClassVar,
+        isInsideGeneratorFunction: isInsideGeneratorFunction,
+        isInsideAsyncFunction: isInsideAsyncFunction,
     };
-    // Name of 'this' and 'args' to be used in the body. 
+    // 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;
@@ -45,40 +49,42 @@ export function generateLambda(node, context, options) {
         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`;
+            preamble +=
+                `${this.indent()}jspp::AnyValue ${thisCopy} = ${this.globalThisVar};\n`;
             bodyThisVar = thisCopy;
         }
-        preamble += `${this.indent()}std::vector<jspp::AnyValue> ${argsCopy}(${argsName}.begin(), ${argsName}.end());\n`;
+        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 
+        // 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`. 
+        // 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 
+        // 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;
@@ -93,16 +99,19 @@ export function generateLambda(node, context, options) {
         ? "const jspp::AnyValue&"
         : `${paramThisType} ${finalThisParamName}`;
     // Re-construct lambda header with potentially new param names
-    lambda = `${capture}(${thisArgParamFinal}, ${paramArgsType} ${finalArgsParamName}) mutable -> ${funcReturnType} `;
+    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()}jspp::AnyValue ${this.globalThisVar} = ${finalThisParamName};\n`;
         }
-        preamble += `${this.indent()}std::vector<jspp::AnyValue> ${argsName}(${finalArgsParamName}.begin(), ${finalArgsParamName}.end());\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). 
+    // 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) => {
@@ -168,7 +177,7 @@ export function generateLambda(node, context, options) {
         if (ts.isBlock(node.body)) {
             // Hoist var declarations in the function body
             const varDecls = collectFunctionScopedDeclarations(node.body);
-            varDecls.forEach(decl => {
+            varDecls.forEach((decl) => {
                 preamble += this.hoistDeclaration(decl, visitContext.localScopeSymbols);
             });
             this.indentationLevel++;
@@ -183,7 +192,8 @@ export function generateLambda(node, context, options) {
                 isInsideAsyncFunction: isInsideAsyncFunction,
             });
             // The block visitor already adds braces, so we need to inject the preamble and param extraction.
-            lambda += "{\n" + preamble + paramExtraction + blockContent.substring(2);
+            lambda += "{\n" + preamble + paramExtraction +
+                blockContent.trimStart().substring(2);
         }
         else {
             lambda += "{\n";
@@ -210,10 +220,18 @@ export function generateLambda(node, context, options) {
     let method = "";
     // Handle generator function
     if (isInsideGeneratorFunction) {
-        signature =
-            "jspp::JsIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const 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 =

package/dist/core/codegen/helpers.js

@@ -34,22 +34,20 @@ export function getDeclaredSymbols(node) {
     return symbols;
 }
 export function generateUniqueName(prefix, ...namesToAvoid) {
-    let name = `${prefix}${this.exceptionCounter}`;
+    let name = `${prefix}${this.uniqueNameCounter}`;
     while (namesToAvoid.some((names) => names.has(name))) {
-        this.exceptionCounter++;
-        name = `${prefix}${this.exceptionCounter}`;
+        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;
@@ -189,14 +187,16 @@ 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;
+            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;
+                const isLetOrConst = (n.initializer.flags &
+                    (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
                 if (!isLetOrConst) {
                     decls.push(...n.initializer.declarations);
                 }
@@ -204,7 +204,8 @@ export function collectFunctionScopedDeclarations(node) {
         }
         else if (ts.isForInStatement(n)) {
             if (ts.isVariableDeclarationList(n.initializer)) {
-                const isLetOrConst = (n.initializer.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                const isLetOrConst = (n.initializer.flags &
+                    (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
                 if (!isLetOrConst) {
                     decls.push(...n.initializer.declarations);
                 }
@@ -212,14 +213,19 @@ export function collectFunctionScopedDeclarations(node) {
         }
         else if (ts.isForOfStatement(n)) {
             if (ts.isVariableDeclarationList(n.initializer)) {
-                const isLetOrConst = (n.initializer.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                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))) {
+        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);
@@ -231,7 +237,8 @@ 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;
+            const isLetOrConst = (stmt.declarationList.flags &
+                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
             if (isLetOrConst) {
                 decls.push(...stmt.declarationList.declarations);
             }

package/dist/core/codegen/index.js

@@ -1,14 +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, 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
@@ -36,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`;
@@ -44,23 +43,31 @@ export class CodeGenerator {
             isMainContext: true,
             isInsideFunction: true,
             isFunctionBody: true,
+            isInsideAsyncFunction: true,
             topLevelScopeSymbols: new DeclaredSymbols(),
             localScopeSymbols: new DeclaredSymbols(),
         });
         this.indentationLevel--;
-        containerCode += "  return jspp::Constants::UNDEFINED;\n";
+        containerCode += "  co_return jspp::Constants::UNDEFINED;\n";
         containerCode += "}\n\n";
         let mainCode = "int main(int argc, char** argv) {\n";
         mainCode += `  try {\n`;
         mainCode += `    jspp::setup_process_argv(argc, argv);\n`;
-        mainCode += `    ${CONTAINER_FUNCTION_NAME}();\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").call(__obj, std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1), "console.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;