@ugo-studio/jspp 0.1.4 → 0.1.5

package/dist/analysis/scope.js

@@ -14,12 +14,17 @@ export const BUILTIN_OBJECTS = new Set([
     { name: "performance", isConst: false },
     { name: "global", isConst: false },
     { name: "globalThis", isConst: false },
+    { name: "process", isConst: false },
     { name: "Error", isConst: false },
     { name: "Promise", isConst: false },
+    { name: "Function", isConst: false },
     { name: "setTimeout", isConst: false },
     { name: "clearTimeout", isConst: false },
     { name: "setInterval", isConst: false },
     { name: "clearInterval", isConst: false },
+    { name: "Array", isConst: false },
+    { name: "Object", isConst: false },
+    { name: "Math", isConst: false },
 ]);
 // Represents a single scope (e.g., a function body or a block statement)
 export class Scope {
@@ -79,11 +84,23 @@ export class ScopeManager {
     }
     // Defines a variable in the current scope.
     define(name, type) {
+        // if (name === "named" || name === "letVal") console.log("Defining", name, "in scope. isBuiltin:", type.isBuiltin, " type:", type.type);
         if (this.reservedKeywords.has(name) && !type.isBuiltin) {
             throw new Error(`SyntaxError: Unexpected reserved word "${name}"`);
         }
         this.currentScope.define(name, type);
     }
+    // Defines a `var` variable (hoisted to function or global scope).
+    defineVar(name, type) {
+        if (this.reservedKeywords.has(name) && !type.isBuiltin) {
+            throw new Error(`SyntaxError: Unexpected reserved word "${name}"`);
+        }
+        let scope = this.currentScope;
+        while (scope.parent && scope.ownerFunction === scope.parent.ownerFunction) {
+            scope = scope.parent;
+        }
+        scope.define(name, type);
+    }
     // Looks up a variable's type information from the current scope upwards.
     lookup(name) {
         const scope = this.currentScope.findScopeFor(name);

package/dist/analysis/typeAnalyzer.js

@@ -362,6 +362,7 @@ export class TypeAnalyzer {
                 enter: (node) => {
                     if (ts.isVariableDeclaration(node)) {
                         const name = node.name.getText();
+                        const isBlockScoped = (node.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
                         const isConst = (node.parent.flags & ts.NodeFlags.Const) !== 0;
                         let type = "auto";
                         let needsHeap = false;
@@ -381,7 +382,12 @@ export class TypeAnalyzer {
                             isConst,
                             needsHeapAllocation: needsHeap,
                         };
-                        this.scopeManager.define(name, typeInfo);
+                        if (isBlockScoped) {
+                            this.scopeManager.define(name, typeInfo);
+                        }
+                        else {
+                            this.scopeManager.defineVar(name, typeInfo);
+                        }
                     }
                 },
             },

package/dist/ast/symbols.js

@@ -0,0 +1,29 @@
+export var DeclaredSymbolType;
+(function (DeclaredSymbolType) {
+    DeclaredSymbolType["letOrConst"] = "letOrConst";
+    DeclaredSymbolType["function"] = "function";
+    DeclaredSymbolType["var"] = "var";
+})(DeclaredSymbolType || (DeclaredSymbolType = {}));
+export class DeclaredSymbols {
+    symbols;
+    constructor(...m) {
+        this.symbols = new Map();
+        m.forEach((ds) => ds.symbols.forEach((v, k) => this.symbols.set(k, v)));
+    }
+    has(name) {
+        return this.symbols.has(name);
+    }
+    get(name) {
+        return this.symbols.get(name);
+    }
+    set(name, value) {
+        return this.symbols.set(name, value);
+    }
+    update(name, update) {
+        const oldValue = this.get(name);
+        if (oldValue) {
+            const newValue = { ...oldValue, ...update };
+            return this.symbols.set(name, newValue);
+        }
+    }
+}

package/dist/ast/types.js

@@ -1,7 +1 @@
 import * as ts from "typescript";
-export var DeclaredSymbolType;
-(function (DeclaredSymbolType) {
-    DeclaredSymbolType["letOrConst"] = "letOrConst";
-    DeclaredSymbolType["function"] = "function";
-    DeclaredSymbolType["var"] = "var";
-})(DeclaredSymbolType || (DeclaredSymbolType = {}));

package/dist/cli-utils/args.js

@@ -0,0 +1,57 @@
+import path from "path";
+import { COLORS } from "./colors";
+export function parseArgs(rawArgs) {
+    let jsFilePathArg = null;
+    let isRelease = false;
+    let keepCpp = false;
+    let outputExePath = null;
+    let scriptArgs = [];
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!arg)
+            continue;
+        if (arg === "--") {
+            scriptArgs = rawArgs.slice(i + 1);
+            break;
+        }
+        if (arg === "--release") {
+            isRelease = true;
+        }
+        else if (arg === "--keep-cpp") {
+            keepCpp = true;
+        }
+        else if (arg === "-o" || arg === "--output") {
+            if (i + 1 < rawArgs.length) {
+                outputExePath = rawArgs[i + 1] ?? null;
+                i++;
+            }
+            else {
+                console.error(`${COLORS.red}Error: --output requires a file path argument.${COLORS.reset}`);
+                process.exit(1);
+            }
+        }
+        else if (arg.startsWith("-")) {
+            console.warn(`${COLORS.yellow}Warning: Unknown argument '${arg}'${COLORS.reset}`);
+        }
+        else {
+            if (jsFilePathArg) {
+                console.error(`${COLORS.red}Error: Multiple input files specified.${COLORS.reset}`);
+                process.exit(1);
+            }
+            jsFilePathArg = arg;
+        }
+    }
+    if (!jsFilePathArg) {
+        console.log(`${COLORS.bold}Usage:${COLORS.reset} jspp <path-to-js-file> [--release] [--keep-cpp] [-o <output-path>] [-- <args...>]`);
+        process.exit(1);
+    }
+    return {
+        jsFilePath: path.resolve(process.cwd(), jsFilePathArg),
+        isRelease,
+        keepCpp,
+        outputExePath: outputExePath
+            ? path.resolve(process.cwd(), outputExePath)
+            : null,
+        scriptArgs,
+    };
+}

package/dist/cli-utils/colors.js

@@ -0,0 +1,9 @@
+export const COLORS = {
+    reset: "\x1b[0m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+};

package/dist/cli-utils/file-utils.js

@@ -0,0 +1,20 @@
+import fs from "fs/promises";
+import path from "path";
+export async function getLatestMtime(dirPath) {
+    let maxMtime = 0;
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            const nestedMtime = await getLatestMtime(fullPath);
+            if (nestedMtime > maxMtime)
+                maxMtime = nestedMtime;
+        }
+        else {
+            const stats = await fs.stat(fullPath);
+            if (stats.mtimeMs > maxMtime)
+                maxMtime = stats.mtimeMs;
+        }
+    }
+    return maxMtime;
+}

package/dist/cli-utils/spinner.js

@@ -0,0 +1,55 @@
+import { COLORS } from "./colors";
+export class Spinner {
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    interval = null;
+    frameIndex = 0;
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    start() {
+        process.stdout.write("\x1b[?25l"); // Hide cursor
+        this.frameIndex = 0;
+        this.render();
+        this.interval = setInterval(() => {
+            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+            this.render();
+        }, 80);
+    }
+    update(text) {
+        this.text = text;
+        this.render();
+    }
+    stop(symbol = "", color = COLORS.reset) {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        this.clearLine();
+        process.stdout.write(`${color}${symbol} ${COLORS.reset} ${this.text}\n`);
+        process.stdout.write("\x1b[?25h"); // Show cursor
+    }
+    succeed(text) {
+        if (text)
+            this.text = text;
+        this.stop("✔", COLORS.green);
+    }
+    fail(text) {
+        if (text)
+            this.text = text;
+        this.stop("✖", COLORS.red);
+    }
+    info(text) {
+        if (text)
+            this.text = text;
+        this.stop("ℹ", COLORS.cyan);
+    }
+    render() {
+        this.clearLine();
+        const frame = this.frames[this.frameIndex];
+        process.stdout.write(`${COLORS.cyan}${frame} ${COLORS.reset} ${this.text}`);
+    }
+    clearLine() {
+        process.stdout.write("\r\x1b[K");
+    }
+}

package/dist/cli.js

@@ -1,63 +1,138 @@
 #!/usr/bin/env bun
 import fs from "fs/promises";
 import path from "path";
+import pkg from "../package.json";
+import { parseArgs } from "./cli-utils/args";
+import { COLORS } from "./cli-utils/colors";
+import { getLatestMtime } from "./cli-utils/file-utils";
+import { Spinner } from "./cli-utils/spinner";
 import { Interpreter } from "./index";
 async function main() {
-    const args = process.argv.slice(2);
-    if (args.length === 0) {
-        console.log("Usage: jspp <path-to-js-file>");
-        process.exit(1);
-    }
-    const jsFilePath = path.resolve(process.cwd(), args[0]);
+    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
     const jsFileName = path.basename(jsFilePath, ".js");
-    const outputDir = path.dirname(jsFilePath);
-    const cppFilePath = path.join(outputDir, `${jsFileName}.cpp`);
-    const exeFilePath = path.join(outputDir, `${jsFileName}.exe`);
+    const sourceDir = path.dirname(jsFilePath);
+    // Intermediate C++ file goes alongside the source JS file
+    const cppFilePath = path.join(sourceDir, `${jsFileName}.cpp`);
+    // Determine output executable path
+    let exeFilePath;
+    if (outputExePath) {
+        exeFilePath = outputExePath;
+    }
+    else {
+        const ext = process.platform === "win32" ? ".exe" : "";
+        exeFilePath = path.join(sourceDir, `${jsFileName}${ext}`);
+    }
+    // Mode Configuration
+    const mode = isRelease ? "release" : "debug";
+    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"];
+    const pchDir = path.resolve(process.cwd(), "prelude-build", mode);
+    const spinner = new Spinner("Initializing...");
     try {
+        spinner.start();
+        // 1. Interpreter Phase
+        spinner.update(`Reading ${path.basename(jsFilePath)}...`);
         const jsCode = await fs.readFile(jsFilePath, "utf-8");
+        spinner.update("Transpiling to C++...");
         const interpreter = new Interpreter();
         const { cppCode, preludePath } = interpreter.interpret(jsCode);
-        console.log(`Generated C++ code ${cppFilePath}...`);
-        await fs.mkdir(outputDir, { recursive: true });
+        // 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);
-        console.log(`Compiling ${cppFilePath}...`);
-        const compile = Bun.spawnSync({
+        spinner.succeed(`Generated ${COLORS.dim}${path.basename(cppFilePath)}${COLORS.reset}`);
+        // 2. Precompiled Header Check
+        spinner.text = "Checking precompiled headers...";
+        spinner.start();
+        const pchFile = path.join(pchDir, "index.hpp.gch");
+        let shouldRebuild = false;
+        try {
+            const pchStats = await fs.stat(pchFile);
+            const sourceMtime = await getLatestMtime(preludePath);
+            if (sourceMtime > pchStats.mtimeMs) {
+                shouldRebuild = true;
+            }
+        }
+        catch (e) {
+            shouldRebuild = true;
+        }
+        if (shouldRebuild) {
+            spinner.update("Rebuilding precompiled headers (this may take a while)...");
+            // Use spawn (async) instead of spawnSync to keep spinner alive
+            const rebuild = Bun.spawn({
+                cmd: ["bun", "run", "scripts/precompile-headers.ts"],
+                stdout: "pipe", // pipe to hide output unless error, or handle differently
+                stderr: "pipe",
+            });
+            const exitCode = await rebuild.exited;
+            if (exitCode !== 0) {
+                const stderr = await new Response(rebuild.stderr).text();
+                spinner.fail("Failed to rebuild precompiled headers");
+                console.error(stderr);
+                process.exit(1);
+            }
+            spinner.succeed("Precompiled headers updated");
+        }
+        else {
+            spinner.succeed("Precompiled headers up-to-date");
+        }
+        // 3. Compilation Phase
+        spinner.text = `Compiling binary...`;
+        spinner.start();
+        // Ensure output directory exists
+        await fs.mkdir(path.dirname(exeFilePath), { recursive: true });
+        const compile = Bun.spawn({
             cmd: [
                 "g++",
                 "-std=c++23",
+                ...flags,
                 cppFilePath,
                 "-o",
                 exeFilePath,
                 "-I",
+                pchDir,
+                "-I",
                 preludePath,
-                "-O3",
-                "-DNDEBUG",
-                // "-include",
-                // path.join(process.cwd(), "prelude-build", "index.hpp"),
             ],
-            stdout: "inherit",
-            stderr: "inherit",
+            stdout: "pipe",
+            stderr: "pipe",
         });
-        if (compile.exitCode !== 0) {
-            console.error(`Compilation failed for ${cppFilePath}`);
+        const compileExitCode = await compile.exited;
+        if (compileExitCode !== 0) {
+            const stderr = await new Response(compile.stderr).text();
+            spinner.fail(`Compilation failed`);
+            console.error(stderr);
             process.exit(1);
         }
-        console.log(`Running ${exeFilePath}...`);
-        console.log("\x1b[32m\n------start------\x1b[0m");
-        const run = Bun.spawnSync({
-            cmd: [exeFilePath],
+        spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset}`);
+        // Clean up C++ file if not requested to keep
+        if (!keepCpp) {
+            try {
+                await fs.unlink(cppFilePath);
+            }
+            catch (e) {
+                // Ignore error if file cannot be deleted
+            }
+        }
+        // 4. Execution Phase
+        console.log(`\n${COLORS.cyan}--- Running Output ---${COLORS.reset}`);
+        const run = Bun.spawn({
+            cmd: [exeFilePath, ...scriptArgs],
             stdout: "inherit",
             stderr: "inherit",
         });
-        console.log("\x1b[32m\n------end--------\x1b[0m");
-        if (run.exitCode !== 0) {
-            console.error(`Execution failed for ${exeFilePath}`);
+        const runExitCode = await run.exited;
+        console.log(`${COLORS.cyan}----------------------${COLORS.reset}\n`);
+        if (runExitCode !== 0) {
+            console.error(`${COLORS.red}Execution failed with exit code ${runExitCode}${COLORS.reset}`);
             process.exit(1);
         }
-        console.log(`Successfully ran ${exeFilePath}`);
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
+        spinner.fail("An unexpected error occurred");
+        console.error(error);
         process.exit(1);
     }
 }

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

@@ -20,7 +20,7 @@ export function visitClassDeclaration(node, context) {
             const scope = this.getScopeForNode(extendsExpr);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(extendsExpr.getText(), scope);
             if (typeInfo) {
-                parentName = this.getDerefCode(parentName, this.getJsVarName(extendsExpr), typeInfo);
+                parentName = this.getDerefCode(parentName, this.getJsVarName(extendsExpr), context, typeInfo);
             }
         }
     }
@@ -42,16 +42,16 @@ export function visitClassDeclaration(node, context) {
         // Default constructor
         if (parentName) {
             constructorLambda =
-                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, const std::vector<jspp::AnyValue>& args) mutable -> jspp::AnyValue {
+                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
                  auto __parent = ${parentName};
-                 __parent.as_function("super")->call(${this.globalThisVar}, args);
-                 return jspp::AnyValue::make_undefined();
+                 __parent.call(${this.globalThisVar}, args, "super");
+                 return jspp::Constants::UNDEFINED;
              }, "${className}")`;
         }
         else {
             constructorLambda =
-                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, const std::vector<jspp::AnyValue>& args) mutable -> jspp::AnyValue {
-                 return jspp::AnyValue::make_undefined();
+                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
+                 return jspp::Constants::UNDEFINED;
              }, "${className}")`;
         }
     }
@@ -63,6 +63,10 @@ export function visitClassDeclaration(node, context) {
         code +=
             `${this.indent()}(*${className}).get_own_property("prototype").set_prototype(${parentName}.get_own_property("prototype"));\n`;
     }
+    else {
+        code +=
+            `${this.indent()}(*${className}).get_own_property("prototype").set_prototype(::Object.get_own_property("prototype"));\n`;
+    }
     // Members
     for (const member of node.members) {
         if (ts.isMethodDeclaration(member)) {

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

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols";
 import { CodeGenerator } from "./";
 export function visitForStatement(node, context) {
     const forStmt = node;
@@ -10,6 +11,10 @@ export function visitForStatement(node, context) {
     this.indentationLevel++; // Enter a new scope for the for loop
     // Handle initializer
     let initializerCode = "";
+    let conditionContext = {
+        ...context,
+        topLevelScopeSymbols: this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols),
+    };
     if (forStmt.initializer) {
         if (ts.isVariableDeclarationList(forStmt.initializer)) {
             const varDeclList = forStmt.initializer;
@@ -22,10 +27,15 @@ export function visitForStatement(node, context) {
                     const name = decl.name.getText();
                     const initValue = decl.initializer
                         ? this.visit(decl.initializer, context)
-                        : "jspp::AnyValue::make_undefined()";
+                        : "jspp::Constants::UNDEFINED";
                     const scope = this.getScopeForNode(decl);
                     const typeInfo = this.typeAnalyzer.scopeManager
                         .lookupFromScope(name, scope);
+                    conditionContext.localScopeSymbols = new DeclaredSymbols();
+                    conditionContext.localScopeSymbols.set(name, {
+                        type: DeclaredSymbolType.letOrConst,
+                        checkedIfUninitialized: true,
+                    });
                     if (typeInfo.needsHeapAllocation) {
                         initializerCode =
                             `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
@@ -49,7 +59,7 @@ export function visitForStatement(node, context) {
     }
     code += `${this.indent()}for (${initializerCode}; `;
     if (forStmt.condition) {
-        code += `(${this.visit(forStmt.condition, context)}).is_truthy()`;
+        code += `is_truthy(${this.visit(forStmt.condition, conditionContext)})`;
     }
     code += "; ";
     if (forStmt.incrementor) {
@@ -105,12 +115,12 @@ export function visitForInStatement(node, context) {
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(varName, scope);
             if (typeInfo.needsHeapAllocation) {
                 code +=
-                    `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+                    `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 assignmentTarget = `*${varName}`;
             }
             else {
                 code +=
-                    `${this.indent()}jspp::AnyValue ${varName} = jspp::AnyValue::make_undefined();\n`;
+                    `${this.indent()}jspp::AnyValue ${varName} = jspp::Constants::UNDEFINED;\n`;
                 assignmentTarget = varName;
             }
         }
@@ -129,7 +139,7 @@ export function visitForInStatement(node, context) {
     if (ts.isIdentifier(expr)) {
         const scope = this.getScopeForNode(expr);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.getText(), scope);
-        derefExpr = this.getDerefCode(exprText, this.getJsVarName(expr), typeInfo);
+        derefExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
     }
     const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
     code +=
@@ -177,12 +187,12 @@ export function visitForOfStatement(node, context) {
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemName, scope);
             if (typeInfo.needsHeapAllocation) {
                 code +=
-                    `${this.indent()}auto ${elemName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+                    `${this.indent()}auto ${elemName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 assignmentTarget = `*${elemName}`;
             }
             else {
                 code +=
-                    `${this.indent()}jspp::AnyValue ${elemName} = jspp::AnyValue::make_undefined();\n`;
+                    `${this.indent()}jspp::AnyValue ${elemName} = jspp::Constants::UNDEFINED;\n`;
                 assignmentTarget = elemName;
             }
         }
@@ -201,7 +211,7 @@ export function visitForOfStatement(node, context) {
         const scope = this.getScopeForNode(forOf.expression);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(forOf.expression.getText(), scope);
         const varName = this.getJsVarName(forOf.expression);
-        derefIterable = this.getDerefCode(iterableExpr, varName, typeInfo);
+        derefIterable = this.getDerefCode(iterableExpr, varName, context, typeInfo);
     }
     const declaredSymbols = this.getDeclaredSymbols(forOf.statement);
     const iterableRef = this.generateUniqueName("__iter_ref", declaredSymbols);
@@ -213,11 +223,11 @@ export function visitForOfStatement(node, context) {
     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`;
+        `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("next");\n`;
     code +=
-        `${this.indent()}auto ${nextRes} = ${nextFunc}->call(${iterator}, {});\n`;
+        `${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()}${assignmentTarget} = ${nextRes}.get_own_property("value");\n`;
@@ -230,7 +240,7 @@ export function visitForOfStatement(node, context) {
         code += `${this.indent()}${context.currentLabel}_continue:;\n`;
     }
     code +=
-        `${this.indent()}${nextRes} = ${nextFunc}->call(${iterator}, {});\n`;
+        `${this.indent()}${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
     this.indentationLevel--;
     code += `${this.indent()}}\n`;
     this.indentationLevel--; // Exit the scope for the for-of loop
@@ -248,7 +258,7 @@ export function visitWhileStatement(node, context) {
     const conditionText = condition.kind === ts.SyntaxKind.TrueKeyword ||
         condition.kind === ts.SyntaxKind.FalseKeyword
         ? condition.getText()
-        : `(${this.visit(condition, context)}).is_truthy()`;
+        : `is_truthy(${this.visit(condition, context)})`;
     let code = "";
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}: {\n`;
@@ -288,7 +298,7 @@ export function visitWhileStatement(node, context) {
 }
 export function visitDoStatement(node, context) {
     const condition = node.expression;
-    const conditionText = `(${this.visit(condition, context)}).is_truthy()`;
+    const conditionText = `is_truthy(${this.visit(condition, context)})`;
     let code = "";
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}: {\n`;
@@ -346,7 +356,7 @@ export function visitSwitchStatement(node, context) {
         `${this.indent()}const jspp::AnyValue ${switchValueVar} = ${expressionCode};\n`;
     code += `${this.indent()}bool ${fallthroughVar} = false;\n`;
     // Hoist variable declarations
-    const hoistedSymbols = new Map();
+    const hoistedSymbols = new DeclaredSymbols();
     for (const clause of switchStmt.caseBlock.clauses) {
         if (ts.isCaseClause(clause) || ts.isDefaultClause(clause)) {
             for (const stmt of clause.statements) {
@@ -363,7 +373,7 @@ export function visitSwitchStatement(node, context) {
         }
     }
     // Prepare scope symbols for the switch block
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.currentScopeSymbols);
+    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
     let firstIf = true;
     for (const clause of switchStmt.caseBlock.clauses) {
         if (ts.isCaseClause(clause)) {
@@ -374,13 +384,13 @@ export function visitSwitchStatement(node, context) {
             let condition = "";
             if (firstIf) {
                 condition =
-                    `(${fallthroughVar} || ${switchValueVar}.is_strictly_equal_to_primitive(${caseExprCode}))`;
+                    `(${fallthroughVar} || jspp::is_strictly_equal_to_primitive(${switchValueVar}, ${caseExprCode}))`;
                 code += `${this.indent()}if ${condition} {\n`;
                 firstIf = false;
             }
             else {
                 condition =
-                    `(${fallthroughVar} || ${switchValueVar}.is_strictly_equal_to_primitive(${caseExprCode}))`;
+                    `(${fallthroughVar} || jspp::is_strictly_equal_to_primitive(${switchValueVar}, ${caseExprCode}))`;
                 code += `${this.indent()}if ${condition} {\n`;
             }
             this.indentationLevel++;
@@ -392,7 +402,7 @@ export function visitSwitchStatement(node, context) {
                         const contextForFunction = {
                             ...context,
                             topLevelScopeSymbols,
-                            currentScopeSymbols: hoistedSymbols,
+                            localScopeSymbols: hoistedSymbols,
                         };
                         const lambda = this.generateLambda(stmt, contextForFunction, { isAssignment: true });
                         code += `${this.indent()}*${funcName} = ${lambda};\n`;
@@ -404,7 +414,7 @@ export function visitSwitchStatement(node, context) {
                         switchBreakLabel,
                         currentLabel: undefined, // Clear currentLabel for nested visits
                         topLevelScopeSymbols,
-                        currentScopeSymbols: hoistedSymbols,
+                        localScopeSymbols: hoistedSymbols,
                         derefBeforeAssignment: true,
                         isAssignmentOnly: ts.isVariableStatement(stmt),
                     });
@@ -431,7 +441,7 @@ export function visitSwitchStatement(node, context) {
                     switchBreakLabel,
                     currentLabel: undefined, // Clear currentLabel for nested visits
                     topLevelScopeSymbols,
-                    currentScopeSymbols: hoistedSymbols,
+                    localScopeSymbols: hoistedSymbols,
                     derefBeforeAssignment: true,
                     isAssignmentOnly: ts.isVariableStatement(stmt),
                 });