@ugo-studio/jspp 0.2.5 → 0.2.7

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 { CompilerError } from "../core/error.js";
+import { Interpreter } from "../index.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/core/codegen/class-handlers.js

@@ -32,11 +32,11 @@ export function visitClassDeclaration(node, context) {
     const constructor = node.members.find(ts.isConstructorDeclaration);
     let constructorLambda = "";
     if (constructor) {
-        constructorLambda = this.generateLambda(constructor, {
+        constructorLambda = this.generateWrappedLambda(this.generateLambdaComponents(constructor, {
             ...classContext,
             isInsideFunction: true,
             lambdaName: className,
-        }, { isClass: true });
+        }, { isClass: true }));
     }
     else {
         // Default constructor
@@ -75,10 +75,10 @@ export function visitClassDeclaration(node, context) {
                 isObjectLiteralExpression: true, // Reuse this flag to handle computed properties
             });
             const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
-            const methodLambda = this.generateLambda(member, {
+            const methodLambda = this.generateWrappedLambda(this.generateLambdaComponents(member, {
                 ...classContext,
                 isInsideFunction: true,
-            });
+            }));
             if (isStatic) {
                 code +=
                     `${this.indent()}(*${className}).set_own_property(${methodName}, ${methodLambda});\n`;
@@ -94,10 +94,10 @@ export function visitClassDeclaration(node, context) {
                 isObjectLiteralExpression: true,
             });
             const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
-            const lambda = this.generateLambda(member, {
+            const lambda = this.generateWrappedLambda(this.generateLambdaComponents(member, {
                 ...classContext,
                 isInsideFunction: true,
-            });
+            }));
             if (isStatic) {
                 code +=
                     `${this.indent()}(*${className}).define_getter(${methodName}, ${lambda});\n`;
@@ -113,10 +113,10 @@ export function visitClassDeclaration(node, context) {
                 isObjectLiteralExpression: true,
             });
             const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
-            const lambda = this.generateLambda(member, {
+            const lambda = this.generateWrappedLambda(this.generateLambdaComponents(member, {
                 ...classContext,
                 isInsideFunction: true,
-            });
+            }));
             if (isStatic) {
                 code +=
                     `${this.indent()}(*${className}).define_setter(${methodName}, ${lambda});\n`;

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

@@ -44,11 +44,11 @@ export function visitForStatement(node, context) {
                         : DeclarationType.const;
                     conditionContext.localScopeSymbols.add(name, {
                         type: declType,
-                        checked: { initialized: true },
+                        checks: { initialized: true },
                     });
                     statementContext.localScopeSymbols.add(name, {
                         type: declType,
-                        checked: { initialized: true },
+                        checks: { initialized: true },
                     });
                     if (typeInfo.needsHeapAllocation) {
                         initializerCode =
@@ -440,19 +440,29 @@ export function visitSwitchStatement(node, context) {
         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, {
+        hoistedSymbols.update(funcName, {
+            features: {
+                native: {
+                    type: "lambda",
+                    name: nativeName,
+                    parameters: this.validateFunctionParams(stmt.parameters),
+                },
+            },
+        });
+        // Generate lambda components
+        const lambdaComps = this.generateLambdaComponents(stmt, contextForFunctions, {
             isAssignment: true,
-            generateOnlyLambda: true,
             nativeName,
+            noTypeSignature: true,
         });
-        code += `${this.indent()}auto ${nativeName} = ${lambda};\n`;
+        // Generate native lambda
+        const nativeLambda = this.generateNativeLambda(lambdaComps);
+        code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\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`;
+            const wrappedLambda = this.generateWrappedLambda(lambdaComps);
+            code += `${this.indent()}*${funcName} = ${wrappedLambda};\n`;
         }
     });
     let firstIf = true;

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
@@ -37,24 +38,34 @@ export function visitVariableDeclaration(node, context) {
                 initText = this.getDerefCode(initText, varName, context, initTypeInfo);
             }
         }
-        else if (ts.isArrowFunction(initExpr)) {
+        else if (ts.isArrowFunction(initExpr) ||
+            (ts.isFunctionExpression(initExpr) && !initExpr.name)) {
             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, {
+            // Mark before further visits
+            context.localScopeSymbols.update(name, {
+                features: {
+                    native: {
+                        type: "lambda",
+                        name: nativeName,
+                        parameters: this.validateFunctionParams(initExpr.parameters),
+                    },
+                },
+            });
+            // Generate lambda components
+            const lambdaComps = this.generateLambdaComponents(initExpr, initContext, {
                 isAssignment: true,
-                generateOnlyLambda: true,
                 nativeName,
+                noTypeSignature: true,
             });
-            nativeLambdaCode =
-                `auto ${nativeName} = ${lambda};\n${this.indent()}`;
+            const nativeLambda = this.generateNativeLambda(lambdaComps);
+            // Generate native lambda
+            nativeLambdaCode = `auto ${nativeName} = ${nativeLambda}`;
             // Generate AnyValue wrapper
-            initText = this.generateFullLambdaExpression(initExpr, initContext, nativeName, { isAssignment: true, noTypeSignature: true });
+            initText = this.generateWrappedLambda(lambdaComps);
         }
         initializer = " = " + initText;
     }
@@ -66,10 +77,19 @@ export function visitVariableDeclaration(node, context) {
         : (typeInfo.needsHeapAllocation && !shouldSkipDeref
             ? `*${name}`
             : name);
+    if (nativeLambdaCode)
+        nativeLambdaCode += `;\n${this.indent()}`;
     if (isLetOrConst) {
         // If there's no initializer, it should be assigned undefined.
         if (!initializer) {
-            return `${nativeLambdaCode}${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 `${nativeLambdaCode}${assignmentTarget}${initializer}`;
     }