@ugo-studio/jspp 0.2.3 → 0.2.5

package/README.md

@@ -52,7 +52,7 @@ To contribute to JSPP or run its test suite, follow these steps:
 ### Prerequisites
 
 - **Node.js:** This project uses Node.js for package management and script execution.
-  - [Install Node.js](https://nodejs.org/)
+  - [Install Node.js >= v20.0.0](https://nodejs.org/)
 - **C++ Compiler:** A compiler with support for C++23 is required. This project is tested with `g++`.
   - `g++` (MinGW on Windows, or available via build-essentials on Linux)
 

package/dist/analysis/typeAnalyzer.js

@@ -1,7 +1,7 @@
 import * as ts from "typescript";
-import { isBuiltinObject } from "../core/codegen/helpers";
-import { Traverser } from "../core/traverser";
-import { Scope, ScopeManager } from "./scope";
+import { isBuiltinObject } from "../core/codegen/helpers.js";
+import { Traverser } from "../core/traverser.js";
+import { Scope, ScopeManager } from "./scope.js";
 export class TypeAnalyzer {
     traverser = new Traverser();
     scopeManager = new ScopeManager();
@@ -19,7 +19,8 @@ export class TypeAnalyzer {
                 const definingScope = this.scopeManager.currentScope
                     .findScopeFor(name);
                 if (definingScope) {
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     const definingFunc = definingScope.ownerFunction;
                     if (definingFunc !== currentFuncNode) {
                         const typeInfo = this.scopeManager.lookup(name);
@@ -34,7 +35,8 @@ export class TypeAnalyzer {
             // Enter new scope for any block-like structure
             Block: {
                 enter: (node, parent) => {
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                     if (parent && ts.isCatchClause(parent) &&
@@ -57,7 +59,8 @@ export class TypeAnalyzer {
             ForStatement: {
                 enter: (node) => {
                     this.loopDepth++;
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
@@ -69,7 +72,8 @@ export class TypeAnalyzer {
             ForOfStatement: {
                 enter: (node) => {
                     this.loopDepth++;
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
@@ -81,7 +85,8 @@ export class TypeAnalyzer {
             ForInStatement: {
                 enter: (node) => {
                     this.loopDepth++;
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                     const forIn = node;
@@ -112,7 +117,8 @@ export class TypeAnalyzer {
             WhileStatement: {
                 enter: (node) => {
                     this.loopDepth++;
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
@@ -124,7 +130,8 @@ export class TypeAnalyzer {
             DoStatement: {
                 enter: (node) => {
                     this.loopDepth++;
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
@@ -136,7 +143,8 @@ export class TypeAnalyzer {
             SwitchStatement: {
                 enter: (node) => {
                     this.switchDepth++;
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
@@ -197,6 +205,15 @@ export class TypeAnalyzer {
                         this.functionTypeInfo.set(node, funcType);
                         this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
+                        // Catch invalid parameters
+                        node.parameters.forEach((p) => {
+                            if (p.getText() == "this") {
+                                const sourceFile = node.getSourceFile();
+                                const { line, character } = sourceFile
+                                    .getLineAndCharacterOfPosition(p.getStart());
+                                throw new SyntaxError(`Cannot use 'this' as a parameter name.\n\n${" ".repeat(6)}at ${sourceFile.fileName}:${line + 1}:${character + 1}\n`);
+                            }
+                        });
                         // Define parameters in the new scope
                         node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
                             type: "auto",
@@ -230,6 +247,15 @@ export class TypeAnalyzer {
                         if (node.name) {
                             this.scopeManager.define(node.name.getText(), funcType);
                         }
+                        // Catch invalid parameters
+                        node.parameters.forEach((p) => {
+                            if (p.getText() == "this") {
+                                const sourceFile = node.getSourceFile();
+                                const { line, character } = sourceFile
+                                    .getLineAndCharacterOfPosition(p.getStart());
+                                throw new SyntaxError(`Cannot use 'this' as a parameter name.\n\n${" ".repeat(6)}at ${sourceFile.fileName}:${line + 1}:${character + 1}\n`);
+                            }
+                        });
                         // Define parameters in the new scope
                         node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
                             type: "auto",
@@ -262,6 +288,15 @@ export class TypeAnalyzer {
                             this.scopeManager.define(funcName, funcType);
                             this.functionTypeInfo.set(node, funcType);
                         }
+                        // Catch invalid parameters
+                        node.parameters.forEach((p) => {
+                            if (p.getText() == "this") {
+                                const sourceFile = node.getSourceFile();
+                                const { line, character } = sourceFile
+                                    .getLineAndCharacterOfPosition(p.getStart());
+                                throw new SyntaxError(`Cannot use 'this' as a parameter name.\n\n${" ".repeat(6)}at ${sourceFile.fileName}:${line + 1}:${character + 1}\n`);
+                            }
+                        });
                         this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
                         // Define parameters in the new scope
@@ -292,7 +327,8 @@ export class TypeAnalyzer {
                         };
                         this.scopeManager.define(name, typeInfo);
                     }
-                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                        null;
                     this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
@@ -362,7 +398,8 @@ 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 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;
@@ -375,6 +412,11 @@ export class TypeAnalyzer {
                                 type = "function";
                                 needsHeap = true;
                             }
+                            else if (ts.isIdentifier(node.initializer)) {
+                                const typeInfo = this.scopeManager.lookup(node.initializer.text);
+                                needsHeap = typeInfo?.needsHeapAllocation ??
+                                    false;
+                            }
                         }
                         const typeInfo = {
                             type,
@@ -396,7 +438,8 @@ export class TypeAnalyzer {
                     if (ts.isIdentifier(node)) {
                         if (isBuiltinObject.call(this, node))
                             return;
-                        const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                        const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
+                            null;
                         if (currentFuncNode &&
                             (ts.isFunctionDeclaration(currentFuncNode) ||
                                 ts.isFunctionExpression(currentFuncNode)) &&

package/dist/ast/symbols.js

@@ -1,32 +1,74 @@
-export var DeclaredSymbolType;
-(function (DeclaredSymbolType) {
-    DeclaredSymbolType["letOrConst"] = "letOrConst";
-    DeclaredSymbolType["function"] = "function";
-    DeclaredSymbolType["var"] = "var";
-})(DeclaredSymbolType || (DeclaredSymbolType = {}));
+export var DeclarationType;
+(function (DeclarationType) {
+    DeclarationType["var"] = "var";
+    DeclarationType["let"] = "let";
+    DeclarationType["const"] = "const";
+    DeclarationType["function"] = "function";
+    DeclarationType["class"] = "class";
+})(DeclarationType || (DeclarationType = {}));
+export class DeclaredSymbol {
+    type;
+    checked;
+    func;
+    constructor(type) {
+        this.type = type;
+        this.checked = {
+            initialized: false,
+        };
+        this.func = null;
+    }
+    get isMutable() {
+        return this.type === DeclarationType.let ||
+            this.type === DeclarationType.var;
+    }
+    updateChecked(update) {
+        this.checked = {
+            ...this.checked,
+            ...update,
+        };
+    }
+    updateFunc(update) {
+        this.func = update
+            ? {
+                ...this.func,
+                ...update,
+            }
+            : null;
+    }
+}
 export class DeclaredSymbols {
     symbols;
     constructor(...m) {
         this.symbols = new Map();
         m.forEach((ds) => ds.symbols.forEach((v, k) => this.symbols.set(k, v)));
     }
+    get names() {
+        return new Set(this.symbols.keys());
+    }
     has(name) {
         return this.symbols.has(name);
     }
     get(name) {
         return this.symbols.get(name);
     }
-    set(name, value) {
-        return this.symbols.set(name, value);
+    add(name, value) {
+        const sym = new DeclaredSymbol(value.type);
+        if (value.checked !== undefined)
+            sym.updateChecked(value.checked);
+        if (value.func !== undefined)
+            sym.updateFunc(value.func);
+        return this.symbols.set(name, sym);
     }
     update(name, update) {
-        const oldValue = this.get(name);
-        if (oldValue) {
-            const newValue = { ...oldValue, ...update };
-            return this.symbols.set(name, newValue);
+        const sym = this.get(name);
+        if (sym) {
+            if (update.type !== undefined)
+                sym.type = update.type;
+            if (update.checked !== undefined)
+                sym.updateChecked(update.checked);
+            if (update.func !== undefined)
+                sym.updateFunc(update.func);
+            return this.symbols.set(name, sym);
         }
     }
-    toSet() {
-        return new Set(this.symbols.keys());
-    }
 }

package/dist/cli-utils/args.js

@@ -1,6 +1,6 @@
 import path from "path";
-import pkg from "../../package.json";
-import { COLORS } from "./colors";
+import pkg from "../../package.json" with { type: "json" };
+import { COLORS } from "./colors.js";
 export function parseArgs(rawArgs) {
     let jsFilePathArg = null;
     let isRelease = false;

package/dist/cli-utils/spinner.js

@@ -1,4 +1,4 @@
-import { COLORS } from "./colors";
+import { COLORS } from "./colors.js";
 export class Spinner {
     frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
     interval = null;

package/dist/cli.js

@@ -2,13 +2,13 @@
 import { spawn } from "child_process";
 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";
-const pkgDir = path.dirname(__dirname);
+import pkg from "../package.json" with { type: "json" };
+import { parseArgs } from "./cli-utils/args.js";
+import { COLORS } from "./cli-utils/colors.js";
+import { getLatestMtime } from "./cli-utils/file-utils.js";
+import { Spinner } from "./cli-utils/spinner.js";
+import { Interpreter } from "./index.js";
+const pkgDir = path.dirname(import.meta.dirname);
 async function main() {
     const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
     const jsFileName = path.basename(jsFilePath, ".js");
@@ -41,7 +41,7 @@ async function main() {
         const jsCode = await fs.readFile(jsFilePath, "utf-8");
         spinner.update("Transpiling to C++...");
         const interpreter = new Interpreter();
-        const { cppCode, preludePath } = interpreter.interpret(jsCode);
+        const { cppCode, preludePath } = interpreter.interpret(jsCode, jsFilePath);
         // 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);

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

@@ -1,6 +1,6 @@
 import ts from "typescript";
-import { CodeGenerator } from "./";
-import { visitObjectPropertyName } from "./expression-handlers";
+import { visitObjectPropertyName } from "./expression-handlers.js";
+import { CodeGenerator } from "./index.js";
 export function visitClassDeclaration(node, context) {
     const className = node.name.getText();
     // Check extends

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

@@ -1,6 +1,6 @@
 import ts from "typescript";
-import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols";
-import { CodeGenerator } from "./";
+import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
+import { CodeGenerator } from "./index.js";
 export function visitForStatement(node, context) {
     const forStmt = node;
     let code = "";
@@ -11,9 +11,14 @@ export function visitForStatement(node, context) {
     this.indentationLevel++; // Enter a new scope for the for loop
     // Handle initializer
     let initializerCode = "";
-    let conditionContext = {
+    const conditionContext = {
         ...context,
-        topLevelScopeSymbols: this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols),
+        globalScopeSymbols: this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols),
+    };
+    const statementContext = {
+        ...context,
+        currentLabel: undefined,
+        isFunctionBody: false,
     };
     if (forStmt.initializer) {
         if (ts.isVariableDeclarationList(forStmt.initializer)) {
@@ -32,9 +37,18 @@ export function visitForStatement(node, context) {
                     const typeInfo = this.typeAnalyzer.scopeManager
                         .lookupFromScope(name, scope);
                     conditionContext.localScopeSymbols = new DeclaredSymbols();
-                    conditionContext.localScopeSymbols.set(name, {
-                        type: DeclaredSymbolType.letOrConst,
-                        checkedIfUninitialized: true,
+                    const declType = (varDeclList.flags &
+                        (ts.NodeFlags.Let)) !==
+                        0
+                        ? DeclarationType.let
+                        : DeclarationType.const;
+                    conditionContext.localScopeSymbols.add(name, {
+                        type: declType,
+                        checked: { initialized: true },
+                    });
+                    statementContext.localScopeSymbols.add(name, {
+                        type: declType,
+                        checked: { initialized: true },
                     });
                     if (typeInfo.needsHeapAllocation) {
                         initializerCode =
@@ -59,18 +73,15 @@ export function visitForStatement(node, context) {
     }
     code += `${this.indent()}for (${initializerCode}; `;
     if (forStmt.condition) {
-        code += `is_truthy(${this.visit(forStmt.condition, conditionContext)})`;
+        code += `jspp::is_truthy(${this.visit(forStmt.condition, conditionContext)})`;
     }
     code += "; ";
     if (forStmt.incrementor) {
         code += this.visit(forStmt.incrementor, context);
     }
     code += ") ";
-    const statementCode = this.visit(forStmt.statement, {
-        ...context,
-        currentLabel: undefined,
-        isFunctionBody: false,
-    }).trim();
+    const statementCode = this.visit(forStmt.statement, statementContext)
+        .trim();
     if (ts.isBlock(node.statement)) {
         let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
         if (context.currentLabel) {
@@ -240,7 +251,7 @@ export function visitForOfStatement(node, context) {
             `${this.indent()}auto ${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
     }
     code +=
-        `${this.indent()}while (!is_truthy(${nextRes}.get_own_property("done"))) {\n`;
+        `${this.indent()}while (!jspp::is_truthy(${nextRes}.get_own_property("done"))) {\n`;
     this.indentationLevel++;
     code +=
         `${this.indent()}${assignmentTarget} = ${nextRes}.get_own_property("value");\n`;
@@ -277,7 +288,7 @@ export function visitWhileStatement(node, context) {
     const conditionText = condition.kind === ts.SyntaxKind.TrueKeyword ||
         condition.kind === ts.SyntaxKind.FalseKeyword
         ? condition.getText()
-        : `is_truthy(${this.visit(condition, context)})`;
+        : `jspp::is_truthy(${this.visit(condition, context)})`;
     let code = "";
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}: {\n`;
@@ -317,7 +328,7 @@ export function visitWhileStatement(node, context) {
 }
 export function visitDoStatement(node, context) {
     const condition = node.expression;
-    const conditionText = `is_truthy(${this.visit(condition, context)})`;
+    const conditionText = `jspp::is_truthy(${this.visit(condition, context)})`;
     let code = "";
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}: {\n`;
@@ -358,6 +369,7 @@ export function visitDoStatement(node, context) {
 }
 export function visitSwitchStatement(node, context) {
     const switchStmt = node;
+    context.currentScopeNode = node; // Update scope node
     let code = "";
     const declaredSymbols = this.getDeclaredSymbols(switchStmt.caseBlock);
     const switchBreakLabel = this.generateUniqueName("__switch_break_", declaredSymbols);
@@ -374,25 +386,75 @@ export function visitSwitchStatement(node, context) {
     code +=
         `${this.indent()}const jspp::AnyValue ${switchValueVar} = ${expressionCode};\n`;
     code += `${this.indent()}bool ${fallthroughVar} = false;\n`;
-    // Hoist variable declarations
-    const hoistedSymbols = new DeclaredSymbols();
+    // Collect declarations from all clauses
+    const funcDecls = [];
+    const classDecls = [];
+    const blockScopedDecls = [];
     for (const clause of switchStmt.caseBlock.clauses) {
-        if (ts.isCaseClause(clause) || ts.isDefaultClause(clause)) {
-            for (const stmt of clause.statements) {
-                if (ts.isVariableStatement(stmt)) {
-                    const varDecls = stmt.declarationList.declarations;
-                    for (const decl of varDecls) {
-                        code += this.hoistDeclaration(decl, hoistedSymbols);
-                    }
-                }
-                else if (ts.isFunctionDeclaration(stmt)) {
-                    code += this.hoistDeclaration(stmt, hoistedSymbols);
+        for (const stmt of clause.statements) {
+            if (ts.isFunctionDeclaration(stmt)) {
+                funcDecls.push(stmt);
+            }
+            else if (ts.isClassDeclaration(stmt)) {
+                classDecls.push(stmt);
+            }
+            else if (ts.isVariableStatement(stmt)) {
+                const isLetOrConst = (stmt.declarationList.flags &
+                    (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                if (isLetOrConst) {
+                    blockScopedDecls.push(...stmt.declarationList.declarations);
                 }
             }
         }
     }
-    // Prepare scope symbols for the switch block
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    const hoistedSymbols = new DeclaredSymbols();
+    // 1. Hoist function declarations
+    funcDecls.forEach((func) => {
+        code += this.hoistDeclaration(func, hoistedSymbols, node);
+    });
+    // 2. Hoist class declarations
+    classDecls.forEach((cls) => {
+        code += this.hoistDeclaration(cls, hoistedSymbols, node);
+    });
+    // 3. Hoist variable declarations (let/const only)
+    blockScopedDecls.forEach((decl) => {
+        code += this.hoistDeclaration(decl, hoistedSymbols, node);
+    });
+    // Compile symbols for other statements
+    const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
+    const localScopeSymbols = new DeclaredSymbols(hoistedSymbols);
+    // 4. Assign hoisted functions (Optimization)
+    const contextForFunctions = {
+        ...context,
+        localScopeSymbols: new DeclaredSymbols(context.localScopeSymbols, hoistedSymbols),
+    };
+    funcDecls.forEach((stmt) => {
+        const funcName = stmt.name?.getText();
+        if (!funcName)
+            return;
+        const symbol = hoistedSymbols.get(funcName);
+        if (!symbol)
+            return;
+        // Mark initialized
+        this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
+        this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Generate native name
+        const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        hoistedSymbols.update(funcName, { func: { nativeName } });
+        // Generate lambda
+        const lambda = this.generateLambda(stmt, contextForFunctions, {
+            isAssignment: true,
+            generateOnlyLambda: true,
+            nativeName,
+        });
+        code += `${this.indent()}auto ${nativeName} = ${lambda};\n`;
+        // Generate AnyValue wrapper
+        if (this.isFunctionUsedAsValue(stmt, node) ||
+            this.isFunctionUsedBeforeDeclaration(funcName, node)) {
+            const fullExpression = this.generateFullLambdaExpression(stmt, contextForFunctions, nativeName, { isAssignment: true, noTypeSignature: true });
+            code += `${this.indent()}*${funcName} = ${fullExpression};\n`;
+        }
+    });
     let firstIf = true;
     for (const clause of switchStmt.caseBlock.clauses) {
         if (ts.isCaseClause(clause)) {
@@ -416,15 +478,23 @@ export function visitSwitchStatement(node, context) {
             code += `${this.indent()}${fallthroughVar} = true;\n`;
             for (const stmt of clause.statements) {
                 if (ts.isFunctionDeclaration(stmt)) {
-                    const funcName = stmt.name?.getText();
-                    if (funcName) {
-                        const contextForFunction = {
-                            ...context,
-                            topLevelScopeSymbols,
-                            localScopeSymbols: hoistedSymbols,
-                        };
-                        const lambda = this.generateLambda(stmt, contextForFunction, { isAssignment: true });
-                        code += `${this.indent()}*${funcName} = ${lambda};\n`;
+                    // Already handled
+                }
+                else if (ts.isVariableStatement(stmt)) {
+                    const isLetOrConst = (stmt.declarationList.flags &
+                        (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+                        0;
+                    const contextForVisit = {
+                        ...context,
+                        switchBreakLabel,
+                        currentLabel: undefined,
+                        globalScopeSymbols,
+                        localScopeSymbols,
+                        isAssignmentOnly: !isLetOrConst,
+                    };
+                    const assignments = this.visit(stmt.declarationList, contextForVisit);
+                    if (assignments) {
+                        code += `${this.indent()}${assignments};\n`;
                     }
                 }
                 else {
@@ -432,10 +502,8 @@ export function visitSwitchStatement(node, context) {
                         ...context,
                         switchBreakLabel,
                         currentLabel: undefined, // Clear currentLabel for nested visits
-                        topLevelScopeSymbols,
-                        localScopeSymbols: hoistedSymbols,
-                        derefBeforeAssignment: true,
-                        isAssignmentOnly: ts.isVariableStatement(stmt),
+                        globalScopeSymbols,
+                        localScopeSymbols,
                     });
                 }
             }
@@ -455,15 +523,35 @@ export function visitSwitchStatement(node, context) {
             }
             this.indentationLevel++;
             for (const stmt of clause.statements) {
-                code += this.visit(stmt, {
-                    ...context,
-                    switchBreakLabel,
-                    currentLabel: undefined, // Clear currentLabel for nested visits
-                    topLevelScopeSymbols,
-                    localScopeSymbols: hoistedSymbols,
-                    derefBeforeAssignment: true,
-                    isAssignmentOnly: ts.isVariableStatement(stmt),
-                });
+                if (ts.isFunctionDeclaration(stmt)) {
+                    // Already handled
+                }
+                else if (ts.isVariableStatement(stmt)) {
+                    const isLetOrConst = (stmt.declarationList.flags &
+                        (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+                        0;
+                    const contextForVisit = {
+                        ...context,
+                        switchBreakLabel,
+                        currentLabel: undefined,
+                        globalScopeSymbols,
+                        localScopeSymbols,
+                        isAssignmentOnly: !isLetOrConst,
+                    };
+                    const assignments = this.visit(stmt.declarationList, contextForVisit);
+                    if (assignments) {
+                        code += `${this.indent()}${assignments};\n`;
+                    }
+                }
+                else {
+                    code += this.visit(stmt, {
+                        ...context,
+                        switchBreakLabel,
+                        currentLabel: undefined, // Clear currentLabel for nested visits
+                        globalScopeSymbols,
+                        localScopeSymbols,
+                    });
+                }
             }
             this.indentationLevel--;
             code += `${this.indent()}}\n`;