@ugo-studio/jspp 0.1.3 → 0.1.5

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

@@ -1,42 +1,48 @@
 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 hoistedSymbols = new Set();
-    // 1. Hoist function declarations
+    const classDecls = sourceFile.statements.filter(ts.isClassDeclaration);
+    const hoistedSymbols = new DeclaredSymbols();
+    // Hoist function declarations
     funcDecls.forEach((func) => {
-        const funcName = func.name?.getText();
-        if (funcName && !hoistedSymbols.has(funcName)) {
-            hoistedSymbols.add(funcName);
-            code +=
-                `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
-        }
+        code += this.hoistDeclaration(func, hoistedSymbols);
+    });
+    // Hoist class declarations
+    classDecls.forEach((cls) => {
+        code += this.hoistDeclaration(cls, hoistedSymbols);
     });
-    // Hoist variable declarations
+    // Hoist variable declarations (var)
     varDecls.forEach((decl) => {
-        const name = decl.name.getText();
-        if (hoistedSymbols.has(name)) {
-            return;
-        }
-        hoistedSymbols.add(name);
-        const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-            0;
-        const initializer = isLetOrConst
-            ? "jspp::AnyValue::make_uninitialized()"
-            : "jspp::AnyValue::make_undefined()";
-        code +=
-            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+        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,
+        localScopeSymbols: new DeclaredSymbols(context.localScopeSymbols, hoistedSymbols),
+    };
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
         if (funcName) {
-            const lambda = this.generateLambda(stmt, true);
+            this.markSymbolAsChecked(funcName, contextForFunctions.topLevelScopeSymbols, contextForFunctions.localScopeSymbols);
+            this.markSymbolAsChecked(funcName, topLevelScopeSymbols, localScopeSymbols);
+            const lambda = this.generateLambda(stmt, contextForFunctions, {
+                isAssignment: true,
+            });
             code += `${this.indent()}*${funcName} = ${lambda};\n`;
         }
     });
@@ -51,6 +57,8 @@ export function visitSourceFile(node, context) {
                 0;
             const contextForVisit = {
                 ...context,
+                topLevelScopeSymbols,
+                localScopeSymbols,
                 isAssignmentOnly: !isLetOrConst,
             };
             const assignments = this.visit(stmt.declarationList, contextForVisit);
@@ -59,7 +67,12 @@ export function visitSourceFile(node, context) {
             }
         }
         else {
-            code += this.visit(stmt, context);
+            code += this.visit(stmt, {
+                ...context,
+                isFunctionBody: false,
+                topLevelScopeSymbols,
+                localScopeSymbols,
+            });
         }
     });
     return code;
@@ -68,40 +81,39 @@ export function visitBlock(node, context) {
     let code = "{\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 hoistedSymbols = new Set();
+    const classDecls = block.statements.filter(ts.isClassDeclaration);
+    const hoistedSymbols = new DeclaredSymbols();
     // 1. Hoist all function declarations
     funcDecls.forEach((func) => {
-        const funcName = func.name?.getText();
-        if (funcName && !hoistedSymbols.has(funcName)) {
-            hoistedSymbols.add(funcName);
-            code +=
-                `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
-        }
+        code += this.hoistDeclaration(func, hoistedSymbols);
     });
-    // Hoist variable declarations
-    varDecls.forEach((decl) => {
-        const name = decl.name.getText();
-        if (hoistedSymbols.has(name)) {
-            return;
-        }
-        hoistedSymbols.add(name);
-        const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-            0;
-        const initializer = isLetOrConst
-            ? "jspp::AnyValue::make_uninitialized()"
-            : "jspp::AnyValue::make_undefined()";
-        code +=
-            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+    // Hoist class declarations
+    classDecls.forEach((cls) => {
+        code += this.hoistDeclaration(cls, hoistedSymbols);
     });
+    // 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,
+        localScopeSymbols: new DeclaredSymbols(context.localScopeSymbols, hoistedSymbols),
+    };
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
         if (funcName) {
-            const lambda = this.generateLambda(stmt, true);
+            this.markSymbolAsChecked(funcName, contextForFunctions.topLevelScopeSymbols, contextForFunctions.localScopeSymbols);
+            this.markSymbolAsChecked(funcName, topLevelScopeSymbols, localScopeSymbols);
+            const lambda = this.generateLambda(stmt, contextForFunctions, {
+                isAssignment: true,
+            });
             code += `${this.indent()}*${funcName} = ${lambda};\n`;
         }
     });
@@ -116,6 +128,8 @@ export function visitBlock(node, context) {
                 0;
             const contextForVisit = {
                 ...context,
+                topLevelScopeSymbols,
+                localScopeSymbols,
                 isAssignmentOnly: !isLetOrConst,
             };
             const assignments = this.visit(stmt.declarationList, contextForVisit);
@@ -124,13 +138,18 @@ export function visitBlock(node, context) {
             }
         }
         else {
-            code += this.visit(stmt, context);
+            code += this.visit(stmt, {
+                ...context,
+                isFunctionBody: false,
+                topLevelScopeSymbols,
+                localScopeSymbols,
+            });
         }
     });
     if (context.isFunctionBody) {
         const lastStatement = block.statements[block.statements.length - 1];
         if (!lastStatement || !ts.isReturnStatement(lastStatement)) {
-            code += `${this.indent()}${this.getReturnCmd(context)} jspp::AnyValue::make_undefined();\n`;
+            code += `${this.indent()}${this.getReturnCommand(context)} jspp::Constants::UNDEFINED;\n`;
         }
     }
     this.indentationLevel--;
@@ -142,156 +161,47 @@ export function visitVariableStatement(node, context) {
         this.visit(node.declarationList, context) +
         ";\n");
 }
-export function visitForStatement(node, context) {
-    const forStmt = node;
-    let code = "";
-    this.indentationLevel++; // Enter a new scope for the for loop
-    // Handle initializer
-    let initializerCode = "";
-    if (forStmt.initializer) {
-        if (ts.isVariableDeclarationList(forStmt.initializer)) {
-            const varDeclList = forStmt.initializer;
-            const isLetOrConst = (varDeclList.flags &
-                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-                0;
-            if (isLetOrConst) {
-                // For `let` or `const` in for loop, they are block-scoped to the loop.
-                // Declare the variable within the loop's scope.
-                // The C++ for loop initializer can contain a declaration.
-                const decl = varDeclList.declarations[0]; // Assuming single declaration for simplicity
-                if (decl) {
-                    const name = decl.name.getText();
-                    const initValue = decl.initializer
-                        ? this.visit(decl.initializer, context)
-                        : "jspp::AnyValue::make_undefined()";
-                    initializerCode =
-                        `auto ${name} = std::make_unique<jspp::AnyValue>(${initValue})`;
-                }
-            }
-            else {
-                // For 'var', it's already hoisted, so this is an assignment.
-                initializerCode = this.visit(forStmt.initializer, {
-                    ...context,
-                    isAssignmentOnly: true,
-                });
-            }
-        }
-        else {
-            // If it's an expression (e.g., `i = 0`)
-            initializerCode = this.visit(forStmt.initializer, context);
-        }
-    }
-    code += `${this.indent()}for (${initializerCode}; `;
-    if (forStmt.condition) {
-        code += `(${this.visit(forStmt.condition, context)}).is_truthy()`;
+export function visitBreakStatement(node, context) {
+    if (node.label) {
+        return `${this.indent()}goto ${node.label.text}_break;\n`;
     }
-    code += "; ";
-    if (forStmt.incrementor) {
-        code += this.visit(forStmt.incrementor, context);
+    if (context.switchBreakLabel) {
+        return `${this.indent()}goto ${context.switchBreakLabel};\n`;
     }
-    code += ") ";
-    code += this.visit(forStmt.statement, {
-        ...context,
-        isFunctionBody: false,
-    });
-    this.indentationLevel--; // Exit the scope for the for loop
-    return code;
+    return `${this.indent()}break;\n`;
 }
-export function visitForInStatement(node, context) {
-    const forIn = node;
-    let code = `${this.indent()}{\n`;
-    this.indentationLevel++; // Enter a new scope for the for-in loop
-    let varName = "";
-    if (ts.isVariableDeclarationList(forIn.initializer)) {
-        const decl = forIn.initializer.declarations[0];
-        if (decl) {
-            varName = decl.name.getText();
-            // Declare the shared_ptr before the loop
-            code +=
-                `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
-        }
-    }
-    else if (ts.isIdentifier(forIn.initializer)) {
-        varName = forIn.initializer.getText();
-        // Assume it's already declared in an outer scope, just assign to it.
-        // No explicit declaration here.
-    }
-    const expr = forIn.expression;
-    const exprText = this.visit(expr, context);
-    let derefExpr = exprText;
-    if (ts.isIdentifier(expr)) {
-        derefExpr = `jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)})`;
+export function visitContinueStatement(node, context) {
+    if (node.label) {
+        return `${this.indent()}goto ${node.label.text}_continue;\n`;
     }
-    const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
-    code +=
-        `${this.indent()}std::vector<std::string> ${keysVar} = jspp::Access::get_object_keys(${derefExpr});\n`;
-    code += `${this.indent()}for (const auto& ${varName}_str : ${keysVar}) {\n`;
-    this.indentationLevel++;
-    code +=
-        `${this.indent()}*${varName} = jspp::AnyValue::make_string(${varName}_str);\n`;
-    code += this.visit(forIn.statement, {
-        ...context,
-        isFunctionBody: false,
-    });
-    this.indentationLevel--;
-    code += `${this.indent()}}}\n`;
-    this.indentationLevel--; // Exit the scope for the for-in loop
-    return code;
+    return `${this.indent()}continue;\n`;
 }
-export function visitForOfStatement(node, context) {
-    const forOf = node;
-    let code = "";
-    this.indentationLevel++; // Enter a new scope for the for-of loop
-    let varName = "";
-    if (ts.isVariableDeclarationList(forOf.initializer)) {
-        const decl = forOf.initializer.declarations[0];
-        if (decl) {
-            varName = decl.name.getText();
-            // Declare the shared_ptr before the loop
-            code +=
-                `${this.indent()}{ auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
-        }
+export function visitLabeledStatement(node, context) {
+    const label = node.label.text;
+    const statement = node.statement;
+    const isLoop = ts.isForStatement(statement) ||
+        ts.isForInStatement(statement) ||
+        ts.isForOfStatement(statement) ||
+        ts.isWhileStatement(statement) ||
+        ts.isDoStatement(statement);
+    const statementContext = { ...context, currentLabel: label };
+    if (ts.isSwitchStatement(statement)) {
+        return this.visit(statement, statementContext);
     }
-    else if (ts.isIdentifier(forOf.initializer)) {
-        varName = forOf.initializer.getText();
-        // Assume it's already declared in an outer scope, just assign to it.
-        // No explicit declaration here.
-        code += `${this.indent()}{\n`;
+    const statementCode = this.visit(statement, statementContext);
+    if (isLoop) {
+        return statementCode;
     }
-    const iterableExpr = this.visit(forOf.expression, context);
-    const derefIterable = ts.isIdentifier(forOf.expression)
-        ? `jspp::Access::deref(${iterableExpr}, ${this.getJsVarName(forOf.expression)})`
-        : iterableExpr;
-    const iteratorFn = this.generateUniqueName("__iter_fn_", new Set());
-    const iteratorPtr = this.generateUniqueName("__iter_ptr_", new Set());
-    const nextRes = this.generateUniqueName("__res__", new Set());
-    code +=
-        `${this.indent()}auto ${iteratorFn} = ${derefIterable}.get_own_property(Symbol.get_own_property("iterator"));\n`;
-    code +=
-        `${this.indent()}if (!${iteratorFn}.is_generator()) { throw jspp::RuntimeError::make_error("${iterableExpr} is not iterable", "TypeError"); }\n`;
-    code +=
-        `${this.indent()}auto ${iteratorPtr} = ${iteratorFn}.as_function()->call({}).as_iterator();\n`;
-    code += `${this.indent()}auto ${nextRes} = ${iteratorPtr}->next();\n`;
-    code += `${this.indent()}while (!${nextRes}.done) {\n`;
+    // A non-loop statement can only be broken from.
+    // We wrap it in a labeled block.
+    let code = `${this.indent()}${label}: {\n`;
     this.indentationLevel++;
-    code +=
-        `${this.indent()}*${varName} = ${nextRes}.value.value_or(jspp::AnyValue::make_undefined());\n`;
-    code += this.visit(forOf.statement, {
-        ...context,
-        isFunctionBody: false,
-    });
-    code += `${this.indent()}${nextRes} = ${iteratorPtr}->next();\n`;
+    code += statementCode;
     this.indentationLevel--;
-    code += `${this.indent()}}}\n`;
-    this.indentationLevel--; // Exit the scope for the for-of loop
+    code += `${this.indent()}}\n`;
+    code += `${this.indent()}${label}_break:; // break target for ${label}\n`;
     return code;
 }
-export function visitBreakStatement(node, context) {
-    return "break;";
-}
-export function visitContinueStatement(node, context) {
-    return "continue;";
-}
 export function visitIfStatement(node, context) {
     const ifStmt = node;
     const condition = this.visit(ifStmt.expression, context);
@@ -307,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() +
@@ -317,7 +227,7 @@ 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::RuntimeError(${expr});
+    return `${this.indent()}throw jspp::Exception(${expr});
 `;
 }
 export function visitTryStatement(node, context) {
@@ -334,18 +244,23 @@ export function visitTryStatement(node, context) {
         const hasReturnedFlagName = this.generateUniqueName("__try_has_returned_", declaredSymbols);
         let code = `${this.indent()}{\n`;
         this.indentationLevel++;
-        code += `${this.indent()}jspp::AnyValue ${resultVarName};\n`;
-        code += `${this.indent()}bool ${hasReturnedFlagName} = false;\n`;
+        code += `${this.indent()}jspp::AnyValue ${resultVarName};
+`;
+        code += `${this.indent()}bool ${hasReturnedFlagName} = false;
+`;
         const finallyBlockCode = this.visit(tryStmt.finallyBlock, {
             ...context,
             isFunctionBody: false,
         });
         code +=
-            `${this.indent()}auto ${finallyLambdaName} = [=]() ${finallyBlockCode.trim()};\n`;
-        code += `${this.indent()}try {\n`;
+            `${this.indent()}auto ${finallyLambdaName} = [=]() ${finallyBlockCode.trim()};
+`;
+        code += `${this.indent()}try {
+`;
         this.indentationLevel++;
         code +=
-            `${this.indent()}${resultVarName} = ([=, &${hasReturnedFlagName}]() -> jspp::AnyValue {\n`;
+            `${this.indent()}${resultVarName} = ([=, &${hasReturnedFlagName}]() -> jspp::AnyValue {
+`;
         this.indentationLevel++;
         const innerContext = {
             ...context,
@@ -353,7 +268,8 @@ export function visitTryStatement(node, context) {
             isInsideTryCatchLambda: true,
             hasReturnedFlag: hasReturnedFlagName,
         };
-        code += `${this.indent()}try {\n`;
+        code += `${this.indent()}try {
+`;
         this.indentationLevel++;
         code += this.visit(tryStmt.tryBlock, innerContext);
         this.indentationLevel--;
@@ -362,7 +278,8 @@ export function visitTryStatement(node, context) {
             const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText());
             const catchContext = { ...innerContext, exceptionName };
             code +=
-                `${this.indent()}catch (const std::exception& ${exceptionName}) {\n`;
+                `${this.indent()}catch (const std::exception& ${exceptionName}) {
+`;
             this.indentationLevel++;
             code += this.visit(tryStmt.catchClause.block, catchContext);
             this.indentationLevel--;
@@ -371,18 +288,20 @@ export function visitTryStatement(node, context) {
         else {
             code += `${this.indent()}catch (...) { throw; }\n`;
         }
-        code += `${this.indent()}${this.getReturnCmd(context)} jspp::AnyValue::make_undefined();\n`;
+        code += `${this.indent()}${this.getReturnCommand(context)} jspp::Constants::UNDEFINED;\n`;
         this.indentationLevel--;
         code += `${this.indent()}})();\n`;
         this.indentationLevel--;
-        code += `${this.indent()}} catch (...) {\n`;
+        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}) {\n`;
+        code += `${this.indent()}if (${hasReturnedFlagName}) {
+`;
         this.indentationLevel++;
         code += `${this.indent()}return ${resultVarName};\n`;
         this.indentationLevel--;
@@ -420,13 +339,13 @@ export function visitCatchClause(node, context) {
         this.indentationLevel++;
         code += `${this.indent()}{\n`;
         this.indentationLevel++;
-        // Always create the JS exception variable.
+        // The JS exception variable is always local to the catch block
         code +=
-            `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::RuntimeError::error_to_value(${exceptionName}));\n`;
+            `${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`;
+                `${this.indent()}auto ${exceptionName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
         }
         code += this.visit(catchClause.block, context);
         this.indentationLevel--;
@@ -446,77 +365,101 @@ export function visitCatchClause(node, context) {
 export function visitYieldExpression(node, context) {
     if (node.expression) {
         const expr = node.expression;
-        const exprText = this.visit(expr, context);
+        let exprText = this.visit(expr, context);
         if (ts.isIdentifier(expr)) {
             const scope = this.getScopeForNode(expr);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
             if (!typeInfo) {
-                return `${this.indent()}jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)})\n`; // THROWS, not returns
+                return `${this.indent()}jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)})\n`; // THROWS, not returns
             }
             if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                return `${this.indent()}co_yield jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)})`;
+                exprText = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
         }
+        // Handle `yield*` expression
+        if (!!node.asteriskToken) {
+            let code = `${this.indent()}{\n`;
+            this.indentationLevel++;
+            const declaredSymbols = this.getDeclaredSymbols(expr);
+            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`;
+            code +=
+                `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("next");\n`;
+            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`;
+            this.indentationLevel--;
+            code += `${this.indent()}}\n`;
+            return code;
+        }
         return `${this.indent()}co_yield ${exprText}`;
     }
-    return `${this.indent()}co_yield jspp::AnyValue::make_undefined()`;
+    return `${this.indent()}co_yield jspp::Constants::UNDEFINED`;
 }
 export function visitReturnStatement(node, context) {
     if (context.isMainContext) {
-        return `${this.indent()}jspp::RuntimeError::throw_invalid_return_statement_error();\n`;
+        return `${this.indent()}jspp::Exception::throw_invalid_return_statement();\n`;
     }
     const returnStmt = node;
-    const returnCmd = this.getReturnCmd(context);
+    const returnCmd = this.getReturnCommand(context);
     if (context.isInsideTryCatchLambda && context.hasReturnedFlag) {
         let returnCode = `${this.indent()}${context.hasReturnedFlag} = true;\n`;
         if (returnStmt.expression) {
             const expr = returnStmt.expression;
             const exprText = this.visit(expr, context);
+            let finalExpr = exprText;
             if (ts.isIdentifier(expr)) {
                 const scope = this.getScopeForNode(expr);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
                 if (!typeInfo) {
                     returnCode +=
-                        `${this.indent()}jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)});\n`; // THROWS, not returns
+                        `${this.indent()}jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)});\n`; // THROWS, not returns
                 }
-                if (typeInfo &&
+                else if (typeInfo &&
                     !typeInfo.isParameter &&
                     !typeInfo.isBuiltin) {
-                    returnCode +=
-                        `${this.indent()}${returnCmd} jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
+                    finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
                 }
-                else {
-                    returnCode += `${this.indent()}${returnCmd} ${exprText};\n`;
-                }
-            }
-            else {
-                returnCode += `${this.indent()}${returnCmd} ${exprText};\n`;
             }
+            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;
     }
     if (returnStmt.expression) {
         const expr = returnStmt.expression;
         const exprText = this.visit(expr, context);
+        let finalExpr = exprText;
         if (ts.isIdentifier(expr)) {
             const scope = this.getScopeForNode(expr);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
             if (!typeInfo) {
-                return `${this.indent()}jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)});\n`; // THROWS, not returns
+                return `${this.indent()}jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)});\n`; // THROWS, not returns
             }
             if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                return `${this.indent()}${returnCmd} jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
+                finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
         }
-        return `${this.indent()}${returnCmd} ${exprText};\n`;
+        return `${this.indent()}${returnCmd} ${finalExpr};\n`;
     }
-    return `${this.indent()}${returnCmd} jspp::AnyValue::make_undefined();\n`;
+    return `${this.indent()}${returnCmd} jspp::Constants::UNDEFINED;\n`;
 }