@ugo-studio/jspp 0.1.4 → 0.1.6

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

@@ -2,14 +2,19 @@ import ts from "typescript";
 import { CodeGenerator } from "./";
 export function visitIdentifier(node) {
     if (node.text === "NaN") {
-        return "jspp::AnyValue::make_nan()";
+        // return "jspp::AnyValue::make_nan()";
+        return "jspp::Constants::NaN";
     }
     if (node.text === "undefined") {
-        return "jspp::AnyValue::make_undefined()";
+        return visitUndefinedKeyword();
     }
     return node.text;
 }
 export function visitNumericLiteral(node) {
+    if (node.text === "0")
+        return "jspp::Constants::ZERO";
+    if (node.text === "1")
+        return "jspp::Constants::ONE";
     return `jspp::AnyValue::make_number(${this.escapeString(node.text)})`;
 }
 export function visitStringLiteral(node) {
@@ -19,16 +24,20 @@ export function visitNoSubstitutionTemplateLiteral(node) {
     return `jspp::AnyValue::make_string("${this.escapeString(node.text)}")`;
 }
 export function visitTrueKeyword() {
-    return "jspp::AnyValue::make_boolean(true)";
+    // return "jspp::AnyValue::make_boolean(true)";
+    return "jspp::Constants::TRUE";
 }
 export function visitFalseKeyword() {
-    return "jspp::AnyValue::make_boolean(false)";
+    // return "jspp::AnyValue::make_boolean(false)";
+    return "jspp::Constants::FALSE";
 }
 export function visitUndefinedKeyword() {
-    return "jspp::AnyValue::make_undefined()";
+    // return "jspp::AnyValue::make_undefined()";
+    return "jspp::Constants::UNDEFINED";
 }
 export function visitNullKeyword() {
-    return "jspp::AnyValue::make_null()";
+    // return "jspp::AnyValue::make_null()";
+    return "jspp::Constants::Null";
 }
 export function visitThisKeyword() {
     return `${this.globalThisVar}`;

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

@@ -1,15 +1,17 @@
 import ts from "typescript";
+import { DeclaredSymbols } from "../../ast/symbols";
 import { CodeGenerator } from "./";
+import { collectBlockScopedDeclarations, collectFunctionScopedDeclarations, } from "./helpers";
 export function visitSourceFile(node, context) {
     const sourceFile = node;
     let code = "";
-    const varDecls = sourceFile.statements
-        .filter(ts.isVariableStatement)
-        .flatMap((stmt) => stmt.declarationList.declarations);
+    // 1. Collect all var declarations (recursively) + top-level let/const
+    const varDecls = collectFunctionScopedDeclarations(sourceFile);
+    const topLevelLetConst = collectBlockScopedDeclarations(sourceFile.statements);
     const funcDecls = sourceFile.statements.filter(ts.isFunctionDeclaration);
     const classDecls = sourceFile.statements.filter(ts.isClassDeclaration);
-    const hoistedSymbols = new Map();
-    // 1. Hoist function declarations
+    const hoistedSymbols = new DeclaredSymbols();
+    // Hoist function declarations
     funcDecls.forEach((func) => {
         code += this.hoistDeclaration(func, hoistedSymbols);
     });
@@ -17,19 +19,27 @@ export function visitSourceFile(node, context) {
     classDecls.forEach((cls) => {
         code += this.hoistDeclaration(cls, hoistedSymbols);
     });
-    // Hoist variable declarations
+    // Hoist variable declarations (var)
     varDecls.forEach((decl) => {
         code += this.hoistDeclaration(decl, hoistedSymbols);
     });
+    // Hoist top-level let/const
+    topLevelLetConst.forEach((decl) => {
+        code += this.hoistDeclaration(decl, hoistedSymbols);
+    });
+    // Compile symbols for other statements (excluding function)
+    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    const localScopeSymbols = new DeclaredSymbols(hoistedSymbols); // hoistedSymbols becomes new local
     // 2. Assign all hoisted functions first
     const contextForFunctions = {
         ...context,
-        currentScopeSymbols: new Map(context.currentScopeSymbols),
+        localScopeSymbols: new DeclaredSymbols(context.localScopeSymbols, hoistedSymbols),
     };
-    hoistedSymbols.forEach((v, k) => contextForFunctions.currentScopeSymbols.set(k, v));
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
         if (funcName) {
+            this.markSymbolAsChecked(funcName, contextForFunctions.topLevelScopeSymbols, contextForFunctions.localScopeSymbols);
+            this.markSymbolAsChecked(funcName, topLevelScopeSymbols, localScopeSymbols);
             const lambda = this.generateLambda(stmt, contextForFunctions, {
                 isAssignment: true,
             });
@@ -38,8 +48,6 @@ export function visitSourceFile(node, context) {
     });
     // 3. Process other statements
     sourceFile.statements.forEach((stmt) => {
-        const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.currentScopeSymbols);
-        const currentScopeSymbols = hoistedSymbols; // hoistedSymbols becomes new local
         if (ts.isFunctionDeclaration(stmt)) {
             // Already handled
         }
@@ -50,7 +58,7 @@ export function visitSourceFile(node, context) {
             const contextForVisit = {
                 ...context,
                 topLevelScopeSymbols,
-                currentScopeSymbols,
+                localScopeSymbols,
                 isAssignmentOnly: !isLetOrConst,
             };
             const assignments = this.visit(stmt.declarationList, contextForVisit);
@@ -63,24 +71,21 @@ export function visitSourceFile(node, context) {
                 ...context,
                 isFunctionBody: false,
                 topLevelScopeSymbols,
-                currentScopeSymbols,
-                // currentScopeSymbols: undefined, // clear the currentScopeSymbols for nested visit
-                // topLevelScopeSymbols: undefined, // clear the topLevelScopeSymbols for nested visit
+                localScopeSymbols,
             });
         }
     });
     return code;
 }
 export function visitBlock(node, context) {
-    let code = "{\n";
+    let code = `${this.indent()}{\n`;
     this.indentationLevel++;
     const block = node;
-    const varDecls = block.statements
-        .filter(ts.isVariableStatement)
-        .flatMap((stmt) => stmt.declarationList.declarations);
+    // Collect ONLY block-scoped declarations (let/const)
+    const blockScopedDecls = collectBlockScopedDeclarations(block.statements);
     const funcDecls = block.statements.filter(ts.isFunctionDeclaration);
     const classDecls = block.statements.filter(ts.isClassDeclaration);
-    const hoistedSymbols = new Map();
+    const hoistedSymbols = new DeclaredSymbols();
     // 1. Hoist all function declarations
     funcDecls.forEach((func) => {
         code += this.hoistDeclaration(func, hoistedSymbols);
@@ -89,19 +94,23 @@ export function visitBlock(node, context) {
     classDecls.forEach((cls) => {
         code += this.hoistDeclaration(cls, hoistedSymbols);
     });
-    // Hoist variable declarations
-    varDecls.forEach((decl) => {
+    // Hoist variable declarations (let/const only)
+    blockScopedDecls.forEach((decl) => {
         code += this.hoistDeclaration(decl, hoistedSymbols);
     });
+    // Compile symbols for other statements (excluding function)
+    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    const localScopeSymbols = new DeclaredSymbols(hoistedSymbols); // hoistedSymbols becomes new local
     // 2. Assign all hoisted functions first
     const contextForFunctions = {
         ...context,
-        currentScopeSymbols: new Map(context.currentScopeSymbols),
+        localScopeSymbols: new DeclaredSymbols(context.localScopeSymbols, hoistedSymbols),
     };
-    hoistedSymbols.forEach((v, k) => contextForFunctions.currentScopeSymbols.set(k, v));
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
         if (funcName) {
+            this.markSymbolAsChecked(funcName, contextForFunctions.topLevelScopeSymbols, contextForFunctions.localScopeSymbols);
+            this.markSymbolAsChecked(funcName, topLevelScopeSymbols, localScopeSymbols);
             const lambda = this.generateLambda(stmt, contextForFunctions, {
                 isAssignment: true,
             });
@@ -110,8 +119,6 @@ export function visitBlock(node, context) {
     });
     // 3. Process other statements
     block.statements.forEach((stmt) => {
-        const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.currentScopeSymbols);
-        const currentScopeSymbols = hoistedSymbols; // hoistedSymbols becomes new local
         if (ts.isFunctionDeclaration(stmt)) {
             // Do nothing, already handled
         }
@@ -122,7 +129,7 @@ export function visitBlock(node, context) {
             const contextForVisit = {
                 ...context,
                 topLevelScopeSymbols,
-                currentScopeSymbols,
+                localScopeSymbols,
                 isAssignmentOnly: !isLetOrConst,
             };
             const assignments = this.visit(stmt.declarationList, contextForVisit);
@@ -135,16 +142,14 @@ export function visitBlock(node, context) {
                 ...context,
                 isFunctionBody: false,
                 topLevelScopeSymbols,
-                currentScopeSymbols,
-                // currentScopeSymbols: undefined, // clear the currentScopeSymbols for nested visit
-                // topLevelScopeSymbols: undefined, // clear the topLevelScopeSymbols for nested visit
+                localScopeSymbols,
             });
         }
     });
     if (context.isFunctionBody) {
         const lastStatement = block.statements[block.statements.length - 1];
         if (!lastStatement || !ts.isReturnStatement(lastStatement)) {
-            code += `${this.indent()}${this.getReturnCommand(context)} jspp::AnyValue::make_undefined();\n`;
+            code += `${this.indent()}${this.getReturnCommand(context)} jspp::Constants::UNDEFINED;\n`;
         }
     }
     this.indentationLevel--;
@@ -212,7 +217,7 @@ export function visitIfStatement(node, context) {
                 isFunctionBody: false,
             });
     }
-    return `${this.indent()}if ((${condition}).is_truthy()) ${thenStmt}${elseStmt}`;
+    return `${this.indent()}if (is_truthy(${condition})) ${thenStmt}${elseStmt}`;
 }
 export function visitExpressionStatement(node, context) {
     return (this.indent() +
@@ -222,35 +227,206 @@ export function visitExpressionStatement(node, context) {
 export function visitThrowStatement(node, context) {
     const throwStmt = node;
     const expr = this.visit(throwStmt.expression, context);
-    return `${this.indent()}throw jspp::Exception(${expr});
+    return `${this.indent()}throw jspp::Exception(${expr});
 `;
 }
 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};\n`;
-        code += `${this.indent()}bool ${hasReturnedFlagName} = false;\n`;
-        const finallyBlockCode = this.visit(tryStmt.finallyBlock, {
-            ...context,
-            isFunctionBody: false,
-        });
         code +=
-            `${this.indent()}auto ${finallyLambdaName} = [=]() ${finallyBlockCode.trim()};\n`;
+            `${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 {\n`;
+            `${this.indent()}${resultVarName} = ${callPrefix}([=, &${hasReturnedFlagName}]() -> ${returnType} {\n`;
         this.indentationLevel++;
         const innerContext = {
             ...context,
@@ -264,11 +440,14 @@ export function visitTryStatement(node, context) {
         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}) {\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`;
@@ -276,28 +455,28 @@ export function visitTryStatement(node, context) {
         else {
             code += `${this.indent()}catch (...) { throw; }\n`;
         }
-        code += `${this.indent()}${this.getReturnCommand(context)} jspp::AnyValue::make_undefined();\n`;
+        code += `${this.indent()}${returnCmd} jspp::Constants::UNDEFINED;\n`;
         this.indentationLevel--;
         code += `${this.indent()}})();\n`;
         this.indentationLevel--;
-        code += `${this.indent()}} catch (...) {\n`;
-        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}) {\n`;
-        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,
@@ -306,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;
@@ -323,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::AnyValue::make_undefined());\n`;
-        }
         code += this.visit(catchClause.block, context);
         this.indentationLevel--;
         code += `${this.indent()}}\n`;
-        this.indentationLevel--;
-        code += `${this.indent()}}\n`;
         return code;
     }
     else {
@@ -361,7 +532,7 @@ export function visitYieldExpression(node, context) {
             if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                exprText = this.getDerefCode(exprText, this.getJsVarName(expr), typeInfo);
+                exprText = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
         }
         // Handle `yield*` expression
@@ -369,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`;
+            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 ${iterator} = jspp::Access::get_object_value_iterator(${iterableRef}, ${varName});\n`;
-            code +=
-                `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("next").as_function();\n`;
-            code +=
-                `${this.indent()}auto ${nextRes} = ${nextFunc}->call(${iterator}, {});\n`;
+                `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("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 (!${nextRes}.get_own_property("done").is_truthy()) {\n`;
+                `${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}, {});\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`;
+            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::AnyValue::make_undefined()`;
+    const awaitPart = context.isInsideAsyncFunction ? "co_await " : "";
+    return `${this.indent()}co_yield ${awaitPart}jspp::Constants::UNDEFINED`;
 }
 export function visitReturnStatement(node, context) {
     if (context.isMainContext) {
@@ -418,14 +616,14 @@ export function visitReturnStatement(node, context) {
                 else if (typeInfo &&
                     !typeInfo.isParameter &&
                     !typeInfo.isBuiltin) {
-                    finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), typeInfo);
+                    finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
                 }
             }
             returnCode += `${this.indent()}${returnCmd} ${finalExpr};\n`;
         }
         else {
             returnCode +=
-                `${this.indent()}${returnCmd} jspp::AnyValue::make_undefined();\n`;
+                `${this.indent()}${returnCmd} jspp::Constants::UNDEFINED;\n`;
         }
         return returnCode;
     }
@@ -442,10 +640,10 @@ export function visitReturnStatement(node, context) {
             if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), typeInfo);
+                finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
         }
         return `${this.indent()}${returnCmd} ${finalExpr};\n`;
     }
-    return `${this.indent()}${returnCmd} jspp::AnyValue::make_undefined();\n`;
+    return `${this.indent()}${returnCmd} jspp::Constants::UNDEFINED;\n`;
 }

package/dist/core/codegen/visitor.js

@@ -3,7 +3,7 @@ import { CodeGenerator } from "./";
 import { visitClassDeclaration } from "./class-handlers";
 import { visitCaseClause, visitDefaultClause, visitDoStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitSwitchStatement, visitWhileStatement, } from "./control-flow-handlers";
 import { visitVariableDeclaration, visitVariableDeclarationList, } from "./declaration-handlers";
-import { visitArrayLiteralExpression, visitAwaitExpression, visitBinaryExpression, visitCallExpression, visitConditionalExpression, visitElementAccessExpression, visitNewExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, visitTypeOfExpression, visitVoidExpression, } from "./expression-handlers";
+import { visitArrayLiteralExpression, visitAwaitExpression, visitBinaryExpression, visitCallExpression, visitConditionalExpression, visitDeleteExpression, visitElementAccessExpression, visitNewExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, visitTypeOfExpression, visitVoidExpression, } from "./expression-handlers";
 import { visitArrowFunction, visitFunctionDeclaration, visitFunctionExpression, } from "./function-handlers";
 import { visitFalseKeyword, visitIdentifier, visitNoSubstitutionTemplateLiteral, visitNullKeyword, visitNumericLiteral, visitStringLiteral, visitThisKeyword, visitTrueKeyword, visitUndefinedKeyword, } from "./literal-handlers";
 import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitExpressionStatement, visitIfStatement, visitLabeledStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, visitYieldExpression, } from "./statement-handlers";
@@ -72,6 +72,8 @@ export function visit(node, context) {
             return visitBinaryExpression.call(this, node, context);
         case ts.SyntaxKind.ConditionalExpression:
             return visitConditionalExpression.call(this, node, context);
+        case ts.SyntaxKind.DeleteExpression:
+            return visitDeleteExpression.call(this, node, context);
         case ts.SyntaxKind.ThrowStatement:
             return visitThrowStatement.call(this, node, context);
         case ts.SyntaxKind.TryStatement: