@ugo-studio/jspp 0.1.5 → 0.1.7

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

@@ -78,7 +78,7 @@ export function visitSourceFile(node, context) {
     return code;
 }
 export function visitBlock(node, context) {
-    let code = "{\n";
+    let code = `${this.indent()}{\n`;
     this.indentationLevel++;
     const block = node;
     // Collect ONLY block-scoped declarations (let/const)
@@ -232,35 +232,201 @@ export function visitThrowStatement(node, context) {
 }
 export function visitTryStatement(node, context) {
     const tryStmt = node;
+    if (context.isInsideAsyncFunction) {
+        if (tryStmt.finallyBlock) {
+            const declaredSymbols = new Set(context.topLevelScopeSymbols.toSet());
+            this.getDeclaredSymbols(tryStmt.tryBlock).forEach((s) => declaredSymbols.add(s));
+            if (tryStmt.catchClause) {
+                this.getDeclaredSymbols(tryStmt.catchClause).forEach((s) => declaredSymbols.add(s));
+            }
+            this.getDeclaredSymbols(tryStmt.finallyBlock).forEach((s) => declaredSymbols.add(s));
+            const resultVarName = this.generateUniqueName("__try_result_", declaredSymbols);
+            const hasReturnedFlagName = this.generateUniqueName("__try_has_returned_", declaredSymbols);
+            const catchAllExPtrName = this.generateUniqueName("__catch_all_exptr", declaredSymbols);
+            let code = `${this.indent()}{\n`;
+            this.indentationLevel++;
+            code += `${this.indent()}jspp::AnyValue ${resultVarName};\n`;
+            code +=
+                `${this.indent()}std::exception_ptr ${catchAllExPtrName} = nullptr;\n`;
+            code += `${this.indent()}bool ${hasReturnedFlagName} = false;\n`;
+            const returnType = "jspp::JsPromise";
+            const returnCmd = "co_return";
+            const callPrefix = "co_await ";
+            code += `${this.indent()}try {\n`;
+            this.indentationLevel++;
+            code +=
+                `${this.indent()}${resultVarName} = ${callPrefix}([=, &${hasReturnedFlagName}]() -> ${returnType} {\n`;
+            this.indentationLevel++;
+            const innerContext = {
+                ...context,
+                isFunctionBody: false,
+                isInsideTryCatchLambda: true,
+                hasReturnedFlag: hasReturnedFlagName,
+            };
+            const exPtr = this.generateUniqueName("__ex_ptr");
+            code += `${this.indent()}std::exception_ptr ${exPtr} = nullptr;\n`;
+            code += `${this.indent()}try {\n`;
+            this.indentationLevel++;
+            code += this.visit(tryStmt.tryBlock, innerContext);
+            this.indentationLevel--;
+            code +=
+                `${this.indent()}} catch (...) { ${exPtr} = std::current_exception(); }\n`;
+            if (tryStmt.catchClause) {
+                const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText(), declaredSymbols);
+                const caughtValVar = this.generateUniqueName("__caught_val");
+                const caughtFlagVar = this.generateUniqueName("__caught_flag");
+                code +=
+                    `${this.indent()}jspp::AnyValue ${caughtValVar} = jspp::Constants::UNDEFINED;\n`;
+                code += `${this.indent()}bool ${caughtFlagVar} = false;\n`;
+                code += `${this.indent()}if (${exPtr}) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}try { std::rethrow_exception(${exPtr}); } catch (const std::exception& ${exceptionName}) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}${caughtValVar} = jspp::Exception::exception_to_any_value(${exceptionName});\n`;
+                code += `${this.indent()}${caughtFlagVar} = true;\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}} catch (...) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}${caughtValVar} = jspp::AnyValue::make_string("Unknown native exception");\n`;
+                code += `${this.indent()}${caughtFlagVar} = true;\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                code += `${this.indent()}if (${caughtFlagVar}) {\n`;
+                this.indentationLevel++;
+                code += `${this.indent()}{\n`; // Block scope
+                this.indentationLevel++;
+                if (tryStmt.catchClause.variableDeclaration) {
+                    const varName = tryStmt.catchClause.variableDeclaration.name
+                        .getText();
+                    code +=
+                        `${this.indent()}jspp::AnyValue ${varName} = ${caughtValVar};\n`;
+                }
+                const catchContext = { ...innerContext, exceptionName };
+                code += this.visit(tryStmt.catchClause.block, catchContext);
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}if (${exPtr}) { std::rethrow_exception(${exPtr}); }\n`;
+            }
+            code +=
+                `${this.indent()}${returnCmd} jspp::Constants::UNDEFINED;\n`;
+            this.indentationLevel--;
+            code += `${this.indent()}})();\n`;
+            this.indentationLevel--;
+            code +=
+                `${this.indent()}} catch (...) { ${catchAllExPtrName} = std::current_exception(); }\n`;
+            code += `${this.indent()}// finally block\n`;
+            code += this.visit(tryStmt.finallyBlock, {
+                ...context,
+                isFunctionBody: false,
+            });
+            code += `${this.indent()}// re-throw or return\n`;
+            code +=
+                `${this.indent()}if (${catchAllExPtrName}) { std::rethrow_exception(${catchAllExPtrName}); }\n`;
+            code +=
+                `${this.indent()}if (${hasReturnedFlagName}) { ${returnCmd} ${resultVarName}; }\n`;
+            this.indentationLevel--;
+            code += `${this.indent()}}\n`;
+            return code;
+        }
+        else {
+            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
+            const newContext = {
+                ...context,
+                isFunctionBody: false,
+                exceptionName,
+            };
+            const exPtr = this.generateUniqueName("__ex_ptr");
+            let code = `${this.indent()}{\n`;
+            this.indentationLevel++;
+            code += `${this.indent()}std::exception_ptr ${exPtr} = nullptr;\n`;
+            code += `${this.indent()}try {\n`;
+            this.indentationLevel++;
+            code += this.visit(tryStmt.tryBlock, newContext);
+            this.indentationLevel--;
+            code +=
+                `${this.indent()}} catch (...) { ${exPtr} = std::current_exception(); }\n`;
+            if (tryStmt.catchClause) {
+                const caughtValVar = this.generateUniqueName("__caught_val");
+                const caughtFlagVar = this.generateUniqueName("__caught_flag");
+                code +=
+                    `${this.indent()}jspp::AnyValue ${caughtValVar} = jspp::Constants::UNDEFINED;\n`;
+                code += `${this.indent()}bool ${caughtFlagVar} = false;\n`;
+                code += `${this.indent()}if (${exPtr}) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}try { std::rethrow_exception(${exPtr}); } catch (const std::exception& ${exceptionName}) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}${caughtValVar} = jspp::Exception::exception_to_any_value(${exceptionName});\n`;
+                code += `${this.indent()}${caughtFlagVar} = true;\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}} catch (...) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}${caughtValVar} = jspp::AnyValue::make_string("Unknown native exception");\n`;
+                code += `${this.indent()}${caughtFlagVar} = true;\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                code += `${this.indent()}if (${caughtFlagVar}) {\n`;
+                this.indentationLevel++;
+                code += `${this.indent()}{\n`; // Block scope
+                this.indentationLevel++;
+                if (tryStmt.catchClause.variableDeclaration) {
+                    const varName = tryStmt.catchClause.variableDeclaration.name
+                        .getText();
+                    code +=
+                        `${this.indent()}jspp::AnyValue ${varName} = ${caughtValVar};\n`;
+                }
+                code += this.visit(tryStmt.catchClause.block, newContext);
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}if (${exPtr}) { std::rethrow_exception(${exPtr}); }\n`;
+            }
+            this.indentationLevel--;
+            code += `${this.indent()}}\n`;
+            return code;
+        }
+    }
     if (tryStmt.finallyBlock) {
-        const declaredSymbols = new Set();
+        const declaredSymbols = new Set(context.topLevelScopeSymbols.toSet());
         this.getDeclaredSymbols(tryStmt.tryBlock).forEach((s) => declaredSymbols.add(s));
         if (tryStmt.catchClause) {
             this.getDeclaredSymbols(tryStmt.catchClause).forEach((s) => declaredSymbols.add(s));
         }
         this.getDeclaredSymbols(tryStmt.finallyBlock).forEach((s) => declaredSymbols.add(s));
-        const finallyLambdaName = this.generateUniqueName("__finally_", declaredSymbols);
         const resultVarName = this.generateUniqueName("__try_result_", declaredSymbols);
         const hasReturnedFlagName = this.generateUniqueName("__try_has_returned_", declaredSymbols);
+        const catchAllExPtrName = this.generateUniqueName("__catch_all_exptr", declaredSymbols);
         let code = `${this.indent()}{\n`;
         this.indentationLevel++;
-        code += `${this.indent()}jspp::AnyValue ${resultVarName};
-`;
-        code += `${this.indent()}bool ${hasReturnedFlagName} = false;
-`;
-        const finallyBlockCode = this.visit(tryStmt.finallyBlock, {
-            ...context,
-            isFunctionBody: false,
-        });
+        code += `${this.indent()}jspp::AnyValue ${resultVarName};\n`;
         code +=
-            `${this.indent()}auto ${finallyLambdaName} = [=]() ${finallyBlockCode.trim()};
-`;
-        code += `${this.indent()}try {
-`;
+            `${this.indent()}std::exception_ptr ${catchAllExPtrName} = nullptr;\n`;
+        code += `${this.indent()}bool ${hasReturnedFlagName} = false;\n`;
+        const returnType = "jspp::AnyValue";
+        const returnCmd = "return";
+        const callPrefix = "";
+        code += `${this.indent()}try {\n`;
         this.indentationLevel++;
         code +=
-            `${this.indent()}${resultVarName} = ([=, &${hasReturnedFlagName}]() -> jspp::AnyValue {
-`;
+            `${this.indent()}${resultVarName} = ${callPrefix}([=, &${hasReturnedFlagName}]() -> ${returnType} {\n`;
         this.indentationLevel++;
         const innerContext = {
             ...context,
@@ -268,19 +434,20 @@ export function visitTryStatement(node, context) {
             isInsideTryCatchLambda: true,
             hasReturnedFlag: hasReturnedFlagName,
         };
-        code += `${this.indent()}try {
-`;
+        code += `${this.indent()}try {\n`;
         this.indentationLevel++;
         code += this.visit(tryStmt.tryBlock, innerContext);
         this.indentationLevel--;
         code += `${this.indent()}}\n`;
         if (tryStmt.catchClause) {
-            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText());
+            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
             const catchContext = { ...innerContext, exceptionName };
             code +=
-                `${this.indent()}catch (const std::exception& ${exceptionName}) {
-`;
+                `${this.indent()}catch (const std::exception& ${exceptionName}) {\n`;
             this.indentationLevel++;
+            // We cannot co_await here. For now, let's just visit the catch block.
+            // If the catch block contains await, it will fail to compile.
+            // TODO: properly handle async catch by moving it out of native C++ catch.
             code += this.visit(tryStmt.catchClause.block, catchContext);
             this.indentationLevel--;
             code += `${this.indent()}}\n`;
@@ -288,30 +455,28 @@ export function visitTryStatement(node, context) {
         else {
             code += `${this.indent()}catch (...) { throw; }\n`;
         }
-        code += `${this.indent()}${this.getReturnCommand(context)} jspp::Constants::UNDEFINED;\n`;
+        code += `${this.indent()}${returnCmd} jspp::Constants::UNDEFINED;\n`;
         this.indentationLevel--;
         code += `${this.indent()}})();\n`;
         this.indentationLevel--;
-        code += `${this.indent()}} catch (...) {
-`;
-        this.indentationLevel++;
-        code += `${this.indent()}${finallyLambdaName}();\n`;
-        code += `${this.indent()}throw;\n`;
-        this.indentationLevel--;
-        code += `${this.indent()}}\n`;
-        code += `${this.indent()}${finallyLambdaName}();\n`;
-        code += `${this.indent()}if (${hasReturnedFlagName}) {
-`;
-        this.indentationLevel++;
-        code += `${this.indent()}return ${resultVarName};\n`;
-        this.indentationLevel--;
-        code += `${this.indent()}}\n`;
+        code +=
+            `${this.indent()}} catch (...) { ${catchAllExPtrName} = std::current_exception(); }\n`;
+        code += `${this.indent()}// finally block\n`;
+        code += this.visit(tryStmt.finallyBlock, {
+            ...context,
+            isFunctionBody: false,
+        });
+        code += `${this.indent()}// re-throw or return\n`;
+        code +=
+            `${this.indent()}if (${catchAllExPtrName}) { std::rethrow_exception(${catchAllExPtrName}); }\n`;
+        code +=
+            `${this.indent()}if (${hasReturnedFlagName}) { ${returnCmd} ${resultVarName}; }\n`;
         this.indentationLevel--;
         code += `${this.indent()}}\n`;
         return code;
     }
     else {
-        const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText());
+        const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
         const newContext = {
             ...context,
             isFunctionBody: false,
@@ -320,7 +485,8 @@ export function visitTryStatement(node, context) {
         let code = `${this.indent()}try `;
         code += this.visit(tryStmt.tryBlock, newContext);
         if (tryStmt.catchClause) {
-            code += ` catch (const std::exception& ${exceptionName}) `;
+            code +=
+                `${this.indent()}catch (const std::exception& ${exceptionName}) `;
             code += this.visit(tryStmt.catchClause, newContext);
         }
         return code;
@@ -337,21 +503,12 @@ export function visitCatchClause(node, context) {
         const varName = catchClause.variableDeclaration.name.getText();
         let code = `{\n`;
         this.indentationLevel++;
-        code += `${this.indent()}{\n`;
-        this.indentationLevel++;
         // The JS exception variable is always local to the catch block
         code +=
             `${this.indent()}jspp::AnyValue ${varName} = jspp::Exception::exception_to_any_value(${exceptionName});\n`;
-        // Shadow the C++ exception variable *only if* the names don't clash.
-        if (varName !== exceptionName) {
-            code +=
-                `${this.indent()}auto ${exceptionName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
-        }
         code += this.visit(catchClause.block, context);
         this.indentationLevel--;
         code += `${this.indent()}}\n`;
-        this.indentationLevel--;
-        code += `${this.indent()}}\n`;
         return code;
     }
     else {
@@ -383,32 +540,59 @@ export function visitYieldExpression(node, context) {
             let code = `${this.indent()}{\n`;
             this.indentationLevel++;
             const declaredSymbols = this.getDeclaredSymbols(expr);
+            context.topLevelScopeSymbols.toSet().forEach((s) => declaredSymbols.add(s));
             const iterableRef = this.generateUniqueName("__iter_ref", declaredSymbols);
             const iterator = this.generateUniqueName("__iter", declaredSymbols);
             const nextFunc = this.generateUniqueName("__next_func", declaredSymbols);
             const nextRes = this.generateUniqueName("__next_res", declaredSymbols);
             const varName = this.getJsVarName(expr);
             code += `${this.indent()}auto ${iterableRef} = ${exprText};\n`;
-            code +=
-                `${this.indent()}auto ${iterator} = jspp::Access::get_object_value_iterator(${iterableRef}, ${varName});\n`;
+            if (context.isInsideAsyncFunction) {
+                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 (context.isInsideAsyncFunction) {
+                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++;
-            code +=
-                `${this.indent()}co_yield ${nextRes}.get_own_property("value");\n`;
-            code +=
-                `${this.indent()}${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
+            if (context.isInsideAsyncFunction) {
+                code +=
+                    `${this.indent()}co_yield co_await ${nextRes}.get_own_property("value");\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}co_yield ${nextRes}.get_own_property("value");\n`;
+            }
+            if (context.isInsideAsyncFunction) {
+                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`;
             return code;
         }
-        return `${this.indent()}co_yield ${exprText}`;
+        const awaitPart = context.isInsideAsyncFunction ? "co_await " : "";
+        return `${this.indent()}co_yield ${awaitPart}${exprText}`;
     }
-    return `${this.indent()}co_yield jspp::Constants::UNDEFINED`;
+    const awaitPart = context.isInsideAsyncFunction ? "co_await " : "";
+    return `${this.indent()}co_yield ${awaitPart}jspp::Constants::UNDEFINED`;
 }
 export function visitReturnStatement(node, context) {
     if (context.isMainContext) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -13,6 +13,7 @@
     "src/prelude"
   ],
   "scripts": {
+    "postinstall": "bun run scripts/setup-compiler.ts",
     "dev": "bun run src/cli.ts",
     "typecheck": "tsc --noEmit",
     "precompile": "bun run scripts/precompile-headers.ts",

package/src/prelude/any_value.hpp

@@ -50,6 +50,7 @@ namespace jspp
         Promise = 11,
         DataDescriptor = 12,
         AccessorDescriptor = 13,
+        AsyncIterator = 14,
     };
 
     // The variant order MUST match JsType
@@ -67,7 +68,8 @@ namespace jspp
         std::shared_ptr<JsSymbol>,
         std::shared_ptr<JsPromise>,
         std::shared_ptr<DataDescriptor>,
-        std::shared_ptr<AccessorDescriptor>>;
+        std::shared_ptr<AccessorDescriptor>,
+        std::shared_ptr<JsAsyncIterator<AnyValue>>>;
 
     class AnyValue
     {
@@ -329,6 +331,12 @@ namespace jspp
             v.storage = std::shared_ptr<JsIterator<AnyValue>>(iterator, [](JsIterator<AnyValue> *) {});
             return v;
         }
+        static AnyValue from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept
+        {
+            AnyValue v;
+            v.storage = std::make_shared<JsAsyncIterator<AnyValue>>(std::move(iterator));
+            return v;
+        }
 
         // PROPERTY RESOLUTION HELPERS ---------------------------------------
         static AnyValue resolve_property_for_read(const AnyValue &val, const AnyValue &thisVal, const std::string &propName) noexcept
@@ -411,6 +419,7 @@ namespace jspp
         bool is_uninitialized() const noexcept { return storage.index() == 2; }
         bool is_data_descriptor() const noexcept { return storage.index() == 12; }
         bool is_accessor_descriptor() const noexcept { return storage.index() == 13; }
+        bool is_async_iterator() const noexcept { return storage.index() == 14; }
         bool is_generator() const noexcept { return is_function() && as_function()->is_generator; }
 
         // --- TYPE CASTERS
@@ -450,6 +459,10 @@ namespace jspp
         {
             return std::get<std::shared_ptr<JsIterator<AnyValue>>>(storage);
         }
+        std::shared_ptr<JsAsyncIterator<AnyValue>> as_async_iterator() const
+        {
+            return std::get<std::shared_ptr<JsAsyncIterator<AnyValue>>>(storage);
+        }
         DataDescriptor *as_data_descriptor() const noexcept
         {
             return std::get<std::shared_ptr<DataDescriptor>>(storage).get();
@@ -473,6 +486,10 @@ namespace jspp
         AnyValue set_own_property(const std::string &key, const AnyValue &value) const;
         AnyValue set_own_property(uint32_t idx, const AnyValue &value) const;
         AnyValue set_own_property(const AnyValue &key, const AnyValue &value) const;
+        // for calling the gotten the property
+        AnyValue call_own_property(const std::string &key, std::span<const AnyValue> args) const;
+        AnyValue call_own_property(uint32_t idx, std::span<const AnyValue> args) const;
+        AnyValue call_own_property(const AnyValue &key, std::span<const AnyValue> args) const;
 
         // --- DEFINERS (Object.defineProperty semantics)
         void define_data_property(const std::string &key, const AnyValue &value);
@@ -490,6 +507,15 @@ namespace jspp
         std::string to_std_string() const;
     };
 
+    // Awaiter for AnyValue
+    struct AnyValueAwaiter
+    {
+        AnyValue value; // Held by value
+        bool await_ready();
+        void await_suspend(std::coroutine_handle<> h);
+        AnyValue await_resume();
+    };
+
     // Inline implementation of operator co_await
     inline auto AnyValue::operator co_await() const
     {