@ugo-studio/jspp 0.2.4 → 0.2.6

package/dist/cli/index.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import pkg from "../../package.json" with { type: "json" };
+import { Interpreter } from "../index.js";
+import { CompilerError } from "../core/error.js";
+import { parseArgs } from "./args.js";
+import { COLORS } from "./colors.js";
+import { getLatestMtime } from "./file-utils.js";
+import { Spinner } from "./spinner.js";
+const pkgDir = path.dirname(path.dirname(import.meta.dirname));
+async function main() {
+    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
+    const ext = path.extname(jsFilePath);
+    const jsFileName = path.basename(jsFilePath, ext);
+    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"] : ["-O0"];
+    if (process.platform === "win32") {
+        flags.push("-Wa,-mbig-obj");
+    }
+    const pchDir = path.resolve(pkgDir, "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, 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);
+        spinner.succeed(`Generated cpp`);
+        // 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 = spawn("bun", [
+                "run",
+                "scripts/precompile-headers.ts",
+            ], {
+                cwd: pkgDir,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            const stderrChunks = [];
+            if (rebuild.stderr) {
+                rebuild.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+            }
+            const exitCode = await new Promise((resolve) => {
+                rebuild.on("close", (code) => resolve(code ?? 1));
+            });
+            if (exitCode !== 0) {
+                const stderr = Buffer.concat(stderrChunks).toString();
+                spinner.fail("Failed to rebuild precompiled headers");
+                console.error(stderr);
+                process.exit(1);
+            }
+            spinner.succeed("Precompiled headers updated");
+        }
+        else {
+            spinner.succeed("Precompiled headers");
+        }
+        // 3. Compilation Phase
+        spinner.text = `Compiling binary...`;
+        spinner.start();
+        // Ensure output directory exists
+        await fs.mkdir(path.dirname(exeFilePath), { recursive: true });
+        const compile = spawn("g++", [
+            "-std=c++23",
+            ...flags,
+            cppFilePath,
+            "-o",
+            exeFilePath,
+            "-I",
+            pchDir,
+            "-I",
+            preludePath,
+        ], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const compileStderrChunks = [];
+        if (compile.stderr) {
+            compile.stderr.on("data", (chunk) => compileStderrChunks.push(chunk));
+        }
+        const compileExitCode = await new Promise((resolve) => {
+            compile.on("close", (code) => resolve(code ?? 1));
+        });
+        if (compileExitCode !== 0) {
+            const stderr = Buffer.concat(compileStderrChunks).toString();
+            spinner.fail(`Compilation failed`);
+            console.error(stderr);
+            process.exit(1);
+        }
+        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 = spawn(exeFilePath, scriptArgs, {
+            stdio: "inherit",
+        });
+        const runExitCode = await new Promise((resolve) => {
+            run.on("close", (code) => resolve(code ?? 1));
+        });
+        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);
+        }
+    }
+    catch (error) {
+        if (error instanceof CompilerError) {
+            spinner.fail("Compilation failed");
+            console.error(error.getFormattedError());
+            process.exit(1);
+        }
+        spinner.fail("An unexpected error occurred");
+        console.error(error);
+        process.exit(1);
+    }
+}
+main();

package/dist/cli/spinner.js

@@ -0,0 +1,55 @@
+import { COLORS } from "./colors.js";
+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

@@ -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/control-flow-handlers.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols.js";
+import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
 import { CodeGenerator } from "./index.js";
 export function visitForStatement(node, context) {
     const forStmt = node;
@@ -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,
+                        checks: { initialized: true },
+                    });
+                    statementContext.localScopeSymbols.add(name, {
+                        type: declType,
+                        checks: { 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`;

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

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function visitVariableDeclarationList(node, context) {
     return node.declarations
@@ -12,27 +13,50 @@ export function visitVariableDeclaration(node, context) {
     const scope = this.getScopeForNode(varDecl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
     // Mark the symbol as checked
-    this.markSymbolAsChecked(name, context.topLevelScopeSymbols, context.localScopeSymbols);
+    this.markSymbolAsInitialized(name, context.globalScopeSymbols, context.localScopeSymbols);
+    let nativeLambdaCode = "";
     let initializer = "";
+    let shouldSkipDeref = false;
     if (varDecl.initializer) {
         const initExpr = varDecl.initializer;
-        const initContext = {
-            ...context,
-            lambdaName: ts.isArrowFunction(initExpr) ? name : undefined, // Pass the variable name for arrow functions
-        };
         let initText = ts.isNumericLiteral(initExpr)
             ? initExpr.getText()
-            : this.visit(initExpr, initContext);
+            : this.visit(initExpr, context);
         if (ts.isIdentifier(initExpr)) {
             const initScope = this.getScopeForNode(initExpr);
             const initTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, initScope);
             const varName = this.getJsVarName(initExpr);
+            // Check if both target and initializer are heap allocated
+            if (typeInfo.needsHeapAllocation &&
+                initTypeInfo?.needsHeapAllocation) {
+                shouldSkipDeref = true;
+            }
             if (initTypeInfo &&
                 !initTypeInfo.isParameter &&
-                !initTypeInfo.isBuiltin) {
-                initText = this.getDerefCode(initText, varName, initContext, initTypeInfo);
+                !initTypeInfo.isBuiltin &&
+                !shouldSkipDeref) {
+                initText = this.getDerefCode(initText, varName, context, initTypeInfo);
             }
         }
+        else if (ts.isArrowFunction(initExpr)) {
+            const initContext = {
+                ...context,
+                lambdaName: name, // Use the variable name as function name
+            };
+            // Generate and update self name
+            const nativeName = this.generateUniqueName(`__${name}_native_`, context.localScopeSymbols, context.globalScopeSymbols);
+            context.localScopeSymbols.update(name, { func: { nativeName } });
+            // Generate lambda
+            const lambda = this.generateLambda(initExpr, initContext, {
+                isAssignment: true,
+                generateOnlyLambda: true,
+                nativeName,
+            });
+            nativeLambdaCode =
+                `auto ${nativeName} = ${lambda};\n${this.indent()}`;
+            // Generate AnyValue wrapper
+            initText = this.generateFullLambdaExpression(initExpr, initContext, nativeName, { isAssignment: true, noTypeSignature: true });
+        }
         initializer = " = " + initText;
     }
     const isLetOrConst = (varDecl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
@@ -40,19 +64,28 @@ export function visitVariableDeclaration(node, context) {
         (!context.localScopeSymbols.has(name));
     const assignmentTarget = shouldDeref
         ? this.getDerefCode(name, name, context, typeInfo)
-        : (typeInfo.needsHeapAllocation ? `*${name}` : name);
+        : (typeInfo.needsHeapAllocation && !shouldSkipDeref
+            ? `*${name}`
+            : name);
     if (isLetOrConst) {
         // If there's no initializer, it should be assigned undefined.
         if (!initializer) {
-            return `${assignmentTarget} = jspp::Constants::UNDEFINED`;
+            // Constant variables must be initialized
+            const isConst = (varDecl.parent.flags & (ts.NodeFlags.Const)) !== 0;
+            if (isConst) {
+                throw new CompilerError(`The constant "${name}" must be initialized`, varDecl, "SyntaxError");
+            }
+            else {
+                return `${nativeLambdaCode}${assignmentTarget} = jspp::Constants::UNDEFINED`;
+            }
         }
-        return `${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
     }
     // For 'var', it's a bit more complex.
     if (context.isAssignmentOnly) {
         if (!initializer)
             return "";
-        return `${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
     }
     else {
         // This case should not be hit with the new hoisting logic,