@ugo-studio/jspp 0.2.5 → 0.2.6

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

@@ -1,6 +1,8 @@
 import ts from "typescript";
 import { DeclaredSymbols } from "../../ast/symbols.js";
-import { collectBlockScopedDeclarations, collectFunctionScopedDeclarations, } from "./helpers.js";
+import { constants } from "../constants.js";
+import { CompilerError } from "../error.js";
+import { collectBlockScopedDeclarations, collectFunctionScopedDeclarations, shouldIgnoreStatement, } from "./helpers.js";
 import { CodeGenerator } from "./index.js";
 export function visitSourceFile(node, context) {
     const sourceFile = node;
@@ -8,8 +10,9 @@ export function visitSourceFile(node, context) {
     // 1. Collect all var declarations (recursively) + top-level let/const
     const varDecls = collectFunctionScopedDeclarations(sourceFile);
     const topLevelLetConst = collectBlockScopedDeclarations(sourceFile.statements);
-    const funcDecls = sourceFile.statements.filter(ts.isFunctionDeclaration);
+    const funcDecls = sourceFile.statements.filter((s) => ts.isFunctionDeclaration(s) && !!s.body);
     const classDecls = sourceFile.statements.filter(ts.isClassDeclaration);
+    const enumDecls = sourceFile.statements.filter(ts.isEnumDeclaration);
     const hoistedSymbols = new DeclaredSymbols();
     // Hoist function declarations
     funcDecls.forEach((func) => {
@@ -19,6 +22,10 @@ export function visitSourceFile(node, context) {
     classDecls.forEach((cls) => {
         code += this.hoistDeclaration(cls, hoistedSymbols, node);
     });
+    // Hoist enum declarations
+    enumDecls.forEach((enm) => {
+        code += this.hoistDeclaration(enm, hoistedSymbols, node);
+    });
     // Hoist variable declarations (var)
     varDecls.forEach((decl) => {
         code += this.hoistDeclaration(decl, hoistedSymbols, node);
@@ -68,19 +75,11 @@ export function visitSourceFile(node, context) {
             // Already handled
         }
         else if (ts.isVariableStatement(stmt)) {
-            const isLetOrConst = (stmt.declarationList.flags &
-                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-                0;
-            const contextForVisit = {
+            code += this.visit(stmt, {
                 ...context,
                 globalScopeSymbols,
                 localScopeSymbols,
-                isAssignmentOnly: !isLetOrConst,
-            };
-            const assignments = this.visit(stmt.declarationList, contextForVisit);
-            if (assignments) {
-                code += `${this.indent()}${assignments};\n`;
-            }
+            });
         }
         else {
             code += this.visit(stmt, {
@@ -100,8 +99,9 @@ export function visitBlock(node, context) {
     const block = node;
     // Collect ONLY block-scoped declarations (let/const)
     const blockScopedDecls = collectBlockScopedDeclarations(block.statements);
-    const funcDecls = block.statements.filter(ts.isFunctionDeclaration);
+    const funcDecls = block.statements.filter((s) => ts.isFunctionDeclaration(s) && !!s.body);
     const classDecls = block.statements.filter(ts.isClassDeclaration);
+    const enumDecls = block.statements.filter(ts.isEnumDeclaration);
     const hoistedSymbols = new DeclaredSymbols();
     // 1. Hoist all function declarations
     funcDecls.forEach((func) => {
@@ -111,6 +111,10 @@ export function visitBlock(node, context) {
     classDecls.forEach((cls) => {
         code += this.hoistDeclaration(cls, hoistedSymbols, node);
     });
+    // Hoist enum declarations
+    enumDecls.forEach((enm) => {
+        code += this.hoistDeclaration(enm, hoistedSymbols, node);
+    });
     // Hoist variable declarations (let/const only)
     blockScopedDecls.forEach((decl) => {
         code += this.hoistDeclaration(decl, hoistedSymbols, node);
@@ -156,19 +160,11 @@ export function visitBlock(node, context) {
             // Do nothing, already handled
         }
         else if (ts.isVariableStatement(stmt)) {
-            const isLetOrConst = (stmt.declarationList.flags &
-                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-                0;
-            const contextForVisit = {
+            code += this.visit(stmt, {
                 ...context,
                 globalScopeSymbols,
                 localScopeSymbols,
-                isAssignmentOnly: !isLetOrConst,
-            };
-            const assignments = this.visit(stmt.declarationList, contextForVisit);
-            if (assignments) {
-                code += `${this.indent()}${assignments};\n`;
-            }
+            });
         }
         else {
             code += this.visit(stmt, {
@@ -190,9 +186,87 @@ export function visitBlock(node, context) {
     return code;
 }
 export function visitVariableStatement(node, context) {
-    return (this.indent() +
-        this.visit(node.declarationList, context) +
-        ";\n");
+    if (shouldIgnoreStatement(node)) {
+        return "";
+    }
+    const isLetOrConst = (node.declarationList.flags &
+        (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+        0;
+    const visitContext = {
+        ...context,
+        isAssignmentOnly: !isLetOrConst,
+    };
+    const assignments = this.visit(node.declarationList, visitContext);
+    if (assignments) {
+        return `${this.indent()}${assignments};\n`;
+    }
+    return "";
+}
+export function visitTypeAliasDeclaration(node, context) {
+    return "";
+}
+export function visitInterfaceDeclaration(node, context) {
+    return "";
+}
+export function visitEnumDeclaration(node, context) {
+    const name = node.name.getText();
+    const scope = this.getScopeForNode(node);
+    const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+    // Mark as initialized
+    this.markSymbolAsInitialized(name, context.globalScopeSymbols, context.localScopeSymbols);
+    const enumVar = typeInfo.needsHeapAllocation ? `(*${name})` : name;
+    let code = `${this.indent()}${enumVar} = jspp::AnyValue::make_object({});\n`;
+    code += `${this.indent()}{\n`;
+    this.indentationLevel++;
+    code +=
+        `${this.indent()}jspp::AnyValue lastVal = jspp::AnyValue::make_number(-1);\n`; // Previous value tracker
+    for (const member of node.members) {
+        const memberName = member.name.getText();
+        let valueCode = "";
+        // Handle member name (it could be a string literal or identifier)
+        let key = "";
+        if (ts.isIdentifier(member.name)) {
+            key = `"${memberName}"`;
+        }
+        else if (ts.isStringLiteral(member.name)) {
+            key = member.name.getText(); // Includes quotes
+        }
+        else {
+            // Computed property names or numeric literals in enums are rarer but possible
+            // For now assume simple enum
+            key = `"${memberName}"`;
+        }
+        if (member.initializer) {
+            // Visit initializer
+            valueCode = this.visit(member.initializer, context);
+        }
+        else {
+            // Auto-increment
+            valueCode = `lastVal + 1`;
+        }
+        code += `${this.indent()}lastVal = ${valueCode};\n`;
+        code +=
+            `${this.indent()}${enumVar}.set_own_property(${key}, lastVal);\n`;
+        // Reverse mapping for numeric enums
+        code += `${this.indent()}if (lastVal.is_number()) {\n`;
+        this.indentationLevel++;
+        code +=
+            `${this.indent()}${enumVar}.set_own_property(lastVal, jspp::AnyValue::make_string(${key}));\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+    }
+    this.indentationLevel--;
+    code += `${this.indent()}}\n`;
+    return code;
+}
+export function visitModuleDeclaration(node, context) {
+    return "";
+}
+export function visitImportDeclaration(node, context) {
+    return "";
+}
+export function visitImportEqualsDeclaration(node, context) {
+    return "";
 }
 export function visitBreakStatement(node, context) {
     if (node.label) {
@@ -237,7 +311,12 @@ export function visitLabeledStatement(node, context) {
 }
 export function visitIfStatement(node, context) {
     const ifStmt = node;
-    const condition = this.visit(ifStmt.expression, context);
+    const isBinaryExpression = ts.isBinaryExpression(ifStmt.expression) &&
+        constants.booleanOperators.includes(ifStmt.expression.operatorToken.kind);
+    const condition = this.visit(ifStmt.expression, {
+        ...context,
+        supportedNativeLiterals: isBinaryExpression ? ["boolean"] : undefined,
+    });
     const thenStmt = this.visit(ifStmt.thenStatement, {
         ...context,
         isFunctionBody: false,
@@ -250,15 +329,8 @@ export function visitIfStatement(node, context) {
                 isFunctionBody: false,
             });
     }
-    if (ts.isBinaryExpression(ifStmt.expression)) {
-        const binExpr = ifStmt.expression;
-        const op = binExpr.operatorToken.getText();
-        const isBoolean = op === "==" || op === "!=" || op === "===" ||
-            op === "!==" || op === "<" || op === ">" || op === "<=" ||
-            op === ">=" || op === "instanceof" || op === "in";
-        if (isBoolean) {
-            return `${this.indent()}if ((${condition}).as_boolean()) ${thenStmt}${elseStmt}`;
-        }
+    if (isBinaryExpression) {
+        return `${this.indent()}if (${condition}) ${thenStmt}${elseStmt}`;
     }
     return `${this.indent()}if (jspp::is_truthy(${condition})) ${thenStmt}${elseStmt}`;
 }
@@ -540,7 +612,7 @@ export function visitCatchClause(node, context) {
     const exceptionName = context.exceptionName;
     if (!exceptionName) {
         // This should not happen if it's coming from a TryStatement
-        throw new Error("Compiler bug: exceptionName not found in context for CatchClause");
+        throw new CompilerError("exceptionName not found in context for CatchClause", node, "CompilerBug");
     }
     if (catchClause.variableDeclaration) {
         const varName = catchClause.variableDeclaration.name.getText();

package/dist/core/codegen/visitor.js

@@ -2,11 +2,11 @@ import ts from "typescript";
 import { visitClassDeclaration } from "./class-handlers.js";
 import { visitCaseClause, visitDefaultClause, visitDoStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitSwitchStatement, visitWhileStatement, } from "./control-flow-handlers.js";
 import { visitVariableDeclaration, visitVariableDeclarationList, } from "./declaration-handlers.js";
-import { visitArrayLiteralExpression, visitAwaitExpression, visitBinaryExpression, visitCallExpression, visitConditionalExpression, visitDeleteExpression, visitElementAccessExpression, visitNewExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, visitTypeOfExpression, visitVoidExpression, } from "./expression-handlers.js";
+import { visitArrayLiteralExpression, visitAsExpression, visitAwaitExpression, visitBinaryExpression, visitCallExpression, visitConditionalExpression, visitDeleteExpression, visitElementAccessExpression, visitNewExpression, visitNonNullExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitSatisfiesExpression, visitTemplateExpression, visitTypeAssertionExpression, visitTypeOfExpression, visitVoidExpression, } from "./expression-handlers.js";
 import { visitArrowFunction, visitFunctionDeclaration, visitFunctionExpression, } from "./function-handlers.js";
 import { CodeGenerator } from "./index.js";
 import { visitFalseKeyword, visitIdentifier, visitNoSubstitutionTemplateLiteral, visitNullKeyword, visitNumericLiteral, visitStringLiteral, visitThisKeyword, visitTrueKeyword, visitUndefinedKeyword, } from "./literal-handlers.js";
-import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitExpressionStatement, visitIfStatement, visitLabeledStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, visitYieldExpression, } from "./statement-handlers.js";
+import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitEnumDeclaration, visitExpressionStatement, visitIfStatement, visitImportDeclaration, visitImportEqualsDeclaration, visitInterfaceDeclaration, visitLabeledStatement, visitModuleDeclaration, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitTypeAliasDeclaration, visitVariableStatement, visitYieldExpression, } from "./statement-handlers.js";
 export function visit(node, context) {
     if (ts.isFunctionDeclaration(node)) {
         return visitFunctionDeclaration.call(this, node, context);
@@ -114,6 +114,26 @@ export function visit(node, context) {
             return visitNullKeyword.call(this);
         case ts.SyntaxKind.ThisKeyword:
             return visitThisKeyword.call(this);
+        case ts.SyntaxKind.AsExpression:
+            return visitAsExpression.call(this, node, context);
+        case ts.SyntaxKind.TypeAssertionExpression:
+            return visitTypeAssertionExpression.call(this, node, context);
+        case ts.SyntaxKind.NonNullExpression:
+            return visitNonNullExpression.call(this, node, context);
+        case ts.SyntaxKind.SatisfiesExpression:
+            return visitSatisfiesExpression.call(this, node, context);
+        case ts.SyntaxKind.TypeAliasDeclaration:
+            return visitTypeAliasDeclaration.call(this, node, context);
+        case ts.SyntaxKind.InterfaceDeclaration:
+            return visitInterfaceDeclaration.call(this, node, context);
+        case ts.SyntaxKind.EnumDeclaration:
+            return visitEnumDeclaration.call(this, node, context);
+        case ts.SyntaxKind.ModuleDeclaration:
+            return visitModuleDeclaration.call(this, node, context);
+        case ts.SyntaxKind.ImportDeclaration:
+            return visitImportDeclaration.call(this, node, context);
+        case ts.SyntaxKind.ImportEqualsDeclaration:
+            return visitImportEqualsDeclaration.call(this, node, context);
         default:
             return `/* Unhandled node: ${ts.SyntaxKind[node.kind]} */`;
     }

package/dist/core/constants.js

@@ -0,0 +1,16 @@
+import ts from "typescript";
+const booleanOperators = [
+    ts.SyntaxKind.EqualsEqualsEqualsToken,
+    ts.SyntaxKind.EqualsEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsToken,
+    ts.SyntaxKind.InstanceOfKeyword,
+    ts.SyntaxKind.InKeyword,
+    ts.SyntaxKind.LessThanToken,
+    ts.SyntaxKind.LessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanToken,
+    ts.SyntaxKind.GreaterThanEqualsToken,
+];
+export const constants = Object.freeze({
+    booleanOperators,
+});

package/dist/core/error.js

@@ -0,0 +1,58 @@
+import ts from "typescript";
+const COLORS = {
+    reset: "\x1b[0m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    cyan: "\x1b[36m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+};
+export class CompilerError extends Error {
+    node;
+    type;
+    constructor(message, node, type = "SyntaxError") {
+        super(message);
+        this.node = node;
+        this.type = type;
+        Object.setPrototypeOf(this, CompilerError.prototype);
+    }
+    getFormattedError() {
+        const sourceFile = this.node.getSourceFile();
+        if (!sourceFile) {
+            return `${COLORS.red}${this.type}: ${this.message}${COLORS.reset}`;
+        }
+        const start = this.node.getStart();
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+        // Get the full line content safely
+        const lineStartPos = sourceFile.getPositionOfLineAndCharacter(line, 0);
+        let lineEndPos;
+        try {
+            lineEndPos = sourceFile.getLineEndOfPosition(start);
+        }
+        catch {
+            lineEndPos = sourceFile.text.length;
+        }
+        const lineContent = sourceFile.text.substring(lineStartPos, lineEndPos).replace(/\r/g, ''); // Remove CR
+        const fileName = sourceFile.fileName;
+        const lineNum = line + 1;
+        const charNum = character + 1;
+        let output = `\n${COLORS.red}${COLORS.bold}${this.type}:${COLORS.reset} ${this.message}\n`;
+        output += `   ${COLORS.dim}at ${fileName}:${lineNum}:${charNum}${COLORS.reset}\n\n`;
+        // Code frame
+        const lineNumStr = `${lineNum} | `;
+        output += `${COLORS.dim}${lineNumStr}${COLORS.reset}${lineContent}\n`;
+        // Adjust pointer position if there are tabs
+        let pointerPadding = "";
+        for (let i = 0; i < character; i++) {
+            if (lineContent[i] === '\t') {
+                pointerPadding += "\t";
+            }
+            else {
+                pointerPadding += " ";
+            }
+        }
+        const padding = " ".repeat(lineNumStr.length) + pointerPadding;
+        output += `${padding}${COLORS.red}^${COLORS.reset}\n`;
+        return output;
+    }
+}

package/dist/index.js

@@ -6,10 +6,13 @@ export class Interpreter {
     parser = new Parser();
     analyzer = new TypeAnalyzer();
     generator = new CodeGenerator();
-    interpret(jsCode, fileName) {
-        const ast = this.parser.parse(jsCode, fileName);
+    interpret(code, fileName) {
+        const ast = this.parser.parse(code, fileName);
         this.analyzer.analyze(ast);
-        const cppCode = this.generator.generate(ast, this.analyzer);
+        const isTypescript = fileName
+            ? path.extname(fileName) === ".ts"
+            : false;
+        const cppCode = this.generator.generate(ast, this.analyzer, isTypescript);
         const preludePath = path.resolve(import.meta.dirname, "..", "src", "prelude");
         return { cppCode, preludePath };
     }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
   "type": "module",
   "bin": {
-    "jspp": "dist/cli.js"
+    "jspp": "dist/cli/index.js"
   },
   "files": [
     "dist",
@@ -15,7 +15,7 @@
   ],
   "scripts": {
     "postinstall": "bun run scripts/setup-compiler.ts",
-    "dev": "bun run src/cli.ts",
+    "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
     "precompile": "bun run scripts/precompile-headers.ts",
     "test": "bun test",