@ugo-studio/jspp 0.3.0 → 0.3.2

package/dist/interpreter/core/codegen/index.js

@@ -0,0 +1,156 @@
+import ts from "typescript";
+import { DeclaredSymbols } from "../../ast/symbols.js";
+import { generateDestructuring } from "./destructuring-handlers.js";
+import { generateLambdaComponents, generateNativeLambda, generateWrappedLambda, } from "./function-handlers.js";
+import { escapeString, findEnclosingFunctionDeclarationFromReturnStatement, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isDeclarationCalledAsFunction, isDeclarationUsedAsValue, isDeclarationUsedBeforeInitialization, isGeneratorFunction, isVariableUsedWithoutDeclaration, markSymbolAsInitialized, needsTopLevelAwait, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
+import { visit } from "./visitor.js";
+export class CodeGenerator {
+    indentationLevel = 0;
+    typeAnalyzer;
+    isTypescript = false;
+    moduleFunctionName;
+    globalThisVar;
+    uniqueNameCounter = 0;
+    isWasm = false;
+    wasmExports = [];
+    // visitor
+    visit = visit;
+    // helpers
+    getDeclaredSymbols = getDeclaredSymbols;
+    generateUniqueName = generateUniqueName;
+    generateUniqueExceptionName = generateUniqueExceptionName;
+    hoistDeclaration = hoistDeclaration;
+    getScopeForNode = getScopeForNode;
+    indent = indent;
+    escapeString = escapeString;
+    getJsVarName = getJsVarName;
+    getDerefCode = getDerefCode;
+    getReturnCommand = getReturnCommand;
+    isBuiltinObject = isBuiltinObject;
+    isGeneratorFunction = isGeneratorFunction;
+    isAsyncFunction = isAsyncFunction;
+    prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
+    markSymbolAsInitialized = markSymbolAsInitialized;
+    isDeclarationCalledAsFunction = isDeclarationCalledAsFunction;
+    isDeclarationUsedAsValue = isDeclarationUsedAsValue;
+    isDeclarationUsedBeforeInitialization = isDeclarationUsedBeforeInitialization;
+    isVariableUsedWithoutDeclaration = isVariableUsedWithoutDeclaration;
+    validateFunctionParams = validateFunctionParams;
+    generateDestructuring = generateDestructuring;
+    findEnclosingFunctionDeclarationFromReturnStatement = findEnclosingFunctionDeclarationFromReturnStatement;
+    // function handlers
+    generateLambdaComponents = generateLambdaComponents;
+    generateNativeLambda = generateNativeLambda;
+    generateWrappedLambda = generateWrappedLambda;
+    /**
+     * Main entry point for the code generation process.
+     */
+    generate(ast, analyzer, isTypescript, isWasm = false) {
+        this.typeAnalyzer = analyzer;
+        this.isTypescript = isTypescript;
+        this.isWasm = isWasm;
+        this.wasmExports = [];
+        this.moduleFunctionName = this.generateUniqueName("__module_entry_point_", this.getDeclaredSymbols(ast));
+        this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
+        const isAsyncModule = needsTopLevelAwait(ast);
+        const moduleReturnType = isAsyncModule
+            ? "jspp::JsPromise"
+            : "jspp::AnyValue";
+        const moduleReturnCommand = isAsyncModule ? "co_return" : "return";
+        let declarations = `#include "jspp.hpp"\n#include "library/global_usings.hpp"\n`;
+        if (isWasm) {
+            declarations += `#include <emscripten.h>\n`;
+        }
+        declarations += `\n`;
+        // module function code
+        let moduleCode = `${moduleReturnType} ${this.moduleFunctionName}() {\n`;
+        this.indentationLevel++;
+        moduleCode +=
+            `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
+        const context = {
+            currentScopeNode: ast,
+            isMainContext: true,
+            isInsideFunction: true,
+            isFunctionBody: true,
+            isInsideAsyncFunction: isAsyncModule,
+            globalScopeSymbols: new DeclaredSymbols(),
+            localScopeSymbols: new DeclaredSymbols(),
+        };
+        const generatedBody = this.visit(ast, context);
+        moduleCode += generatedBody;
+        moduleCode +=
+            `${this.indent()}${moduleReturnCommand} jspp::Constants::UNDEFINED;\n`;
+        this.indentationLevel--;
+        moduleCode += "}\n\n";
+        // Wasm Exports
+        let wasmGlobalPointers = "";
+        let wasmWrappers = "";
+        if (isWasm) {
+            for (const exp of this.wasmExports) {
+                const paramTypes = exp.params.map((_, i) => `jspp::AnyValue`);
+                const paramList = paramTypes.length > 0
+                    ? `, ${paramTypes.join(", ")}`
+                    : "";
+                const pointerName = `__wasm_export_ptr_${exp.jsName}`;
+                wasmGlobalPointers +=
+                    `std::function<jspp::AnyValue(jspp::AnyValue${paramList})> ${pointerName} = nullptr;\n`;
+                const wrapperParamList = exp.params.map((_, i) => `double p${i}`).join(", ");
+                const callArgsList = exp.params.map((_, i) => `jspp::AnyValue::make_number(p${i})`);
+                const callArgs = callArgsList.length > 0
+                    ? `, ${callArgsList.join(", ")}`
+                    : "";
+                wasmWrappers += `extern "C" EMSCRIPTEN_KEEPALIVE\n`;
+                wasmWrappers +=
+                    `double wasm_export_${exp.jsName}(${wrapperParamList}) {\n`;
+                wasmWrappers += `    if (!${pointerName}) return 0;\n`;
+                wasmWrappers +=
+                    `    auto res = ${pointerName}(global${callArgs});\n`;
+                wasmWrappers +=
+                    `    return jspp::Operators_Private::ToNumber(res);\n`;
+                wasmWrappers += `}\n\n`;
+            }
+        }
+        // main function code
+        let mainCode = "int main(int argc, char** argv) {\n";
+        this.indentationLevel++;
+        mainCode += `${this.indent()}try {\n`;
+        this.indentationLevel++;
+        mainCode += `${this.indent()}jspp::initialize_runtime();\n`;
+        mainCode += `${this.indent()}jspp::setup_process_argv(argc, argv);\n`;
+        if (isAsyncModule) {
+            mainCode +=
+                `${this.indent()}auto p = ${this.moduleFunctionName}();\n`;
+            mainCode +=
+                `${this.indent()}p.then(nullptr, [](jspp::AnyValue err) {\n`;
+            this.indentationLevel++;
+            mainCode +=
+                `${this.indent()}auto error = std::make_shared<jspp::AnyValue>(err);\n`;
+            this.indentationLevel++;
+            mainCode +=
+                `${this.indent()}console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+            mainCode += `${this.indent()}std::exit(1);\n`;
+            this.indentationLevel--;
+            mainCode += `${this.indent()}});\n`;
+        }
+        else {
+            mainCode += `${this.indent()}${this.moduleFunctionName}();\n`;
+        }
+        mainCode += `${this.indent()}jspp::Scheduler::instance().run();\n`;
+        this.indentationLevel--;
+        mainCode += `${this.indent()}} catch (const std::exception& ex) {\n`;
+        this.indentationLevel++;
+        mainCode +=
+            `${this.indent()}auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n`;
+        this.indentationLevel++;
+        mainCode +=
+            `${this.indent()}console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+        mainCode += `${this.indent()}return 1;\n`;
+        this.indentationLevel--;
+        mainCode += `${this.indent()}}\n`;
+        mainCode += `${this.indent()}return 0;\n`;
+        this.indentationLevel--;
+        mainCode += `}`;
+        return declarations + wasmGlobalPointers + wasmWrappers + moduleCode +
+            mainCode;
+    }
+}

package/dist/{core → interpreter/core}/codegen/literal-handlers.js

@@ -11,6 +11,15 @@ export function visitIdentifier(node) {
     return node.text;
 }
 export function visitNumericLiteral(node) {
+    const getOuterExpr = (n) => !ts.isParenthesizedExpression(n) &&
+        n.kind !== ts.SyntaxKind.FirstLiteralToken
+        ? n
+        : getOuterExpr(n.parent);
+    const outerExpr = getOuterExpr(node);
+    if (!ts.isPropertyAccessExpression(outerExpr) &&
+        !ts.isElementAccessExpression(outerExpr)) {
+        return this.escapeString(node.text);
+    }
     if (node.text === "0" || (node.text.startsWith("0.") &&
         !node.text.substring(2).split("").some((c) => c !== "0")))
         return "jspp::Constants::ZERO";

package/dist/{core → interpreter/core}/codegen/statement-handlers.js

@@ -52,14 +52,31 @@ export function visitSourceFile(node, context) {
         // Mark before further visits
         this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Check for @export comment
+        let exported = false;
+        if (this.isWasm) {
+            const fullText = sourceFile.text;
+            const commentRanges = ts.getLeadingCommentRanges(fullText, stmt.pos);
+            if (commentRanges) {
+                for (const range of commentRanges) {
+                    const comment = fullText.substring(range.pos, range.end);
+                    if (comment.includes("@export")) {
+                        exported = true;
+                        break;
+                    }
+                }
+            }
+        }
         // Update features in the symbol registry
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        const argumentKeywordIsUsed = this.isVariableUsedWithoutDeclaration("arguments", stmt.body);
         hoistedSymbols.update(funcName, {
             features: {
                 native: {
                     type: "lambda",
                     name: nativeName,
                     parameters: this.validateFunctionParams(stmt.parameters),
+                    argumentKeywordIsUsed,
                 },
             },
         });
@@ -70,9 +87,18 @@ export function visitSourceFile(node, context) {
             noTypeSignature: true,
         });
         // Generate native lambda
-        if (this.isDeclarationCalledAsFunction(stmt, node)) {
+        if (this.isDeclarationCalledAsFunction(stmt, node) || exported) {
             const nativeLambda = this.generateNativeLambda(lambdaComps);
             code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+            if (exported) {
+                this.wasmExports.push({
+                    jsName: funcName,
+                    nativeName,
+                    params: Array.from(stmt.parameters),
+                });
+                code +=
+                    `${this.indent()}__wasm_export_ptr_${funcName} = ${nativeName};\n`;
+            }
         }
         // Generate AnyValue wrapped lamda
         if (this.isDeclarationUsedAsValue(stmt, node) ||
@@ -151,12 +177,14 @@ export function visitBlock(node, context) {
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
         // Update features in the symbol registry
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        const argumentKeywordIsUsed = this.isVariableUsedWithoutDeclaration("arguments", stmt.body);
         hoistedSymbols.update(funcName, {
             features: {
                 native: {
                     type: "lambda",
                     name: nativeName,
                     parameters: this.validateFunctionParams(stmt.parameters),
+                    argumentKeywordIsUsed,
                 },
             },
         });
@@ -238,7 +266,7 @@ export function visitEnumDeclaration(node, context) {
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
     // Mark as initialized
     this.markSymbolAsInitialized(name, context.globalScopeSymbols, context.localScopeSymbols);
-    const enumVar = typeInfo.needsHeapAllocation ? `(*${name})` : name;
+    const enumVar = typeInfo?.needsHeapAllocation ? `(*${name})` : name;
     let code = `${this.indent()}${enumVar} = jspp::AnyValue::make_object({});\n`;
     code += `${this.indent()}{\n`;
     this.indentationLevel++;
@@ -337,10 +365,7 @@ export function visitIfStatement(node, context) {
     const ifStmt = node;
     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 condition = this.visit(ifStmt.expression, context);
     const thenStmt = this.visit(ifStmt.thenStatement, {
         ...context,
         isFunctionBody: false,
@@ -656,7 +681,8 @@ export function visitCatchClause(node, context) {
         const exceptionValueCode = `jspp::Exception::exception_to_any_value(${exceptionName})`;
         if (ts.isIdentifier(catchClause.variableDeclaration.name)) {
             const varName = catchClause.variableDeclaration.name.text;
-            code += `${this.indent()}jspp::AnyValue ${varName} = ${exceptionValueCode};\n`;
+            code +=
+                `${this.indent()}jspp::AnyValue ${varName} = ${exceptionValueCode};\n`;
         }
         else {
             code += this.generateDestructuring(catchClause.variableDeclaration.name, exceptionValueCode, context) + ";\n";
@@ -797,6 +823,20 @@ export function visitReturnStatement(node, context) {
                 !typeInfo.isBuiltin) {
                 finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
+            const exprReturnType = this.typeAnalyzer.inferNodeReturnType(expr);
+            if (exprReturnType === "number" &&
+                context.isInsideNativeLambda &&
+                context.isInsideFunction) {
+                const funcDecl = this
+                    .findEnclosingFunctionDeclarationFromReturnStatement(expr);
+                if (funcDecl) {
+                    const funcReturnType = this.typeAnalyzer
+                        .inferFunctionReturnType(funcDecl);
+                    if (funcReturnType === "number") {
+                        finalExpr = `${finalExpr}.as_double()`;
+                    }
+                }
+            }
         }
         return `${this.indent()}${returnCmd} ${finalExpr};\n`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -14,14 +14,16 @@
     "scripts"
   ],
   "scripts": {
-    "postinstall": "bun run scripts/setup-compiler.ts",
+    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts && bun run scripts/precompile-headers.ts",
     "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
-    "precompile": "bun run scripts/precompile-headers.ts",
     "test": "bun test",
     "build": "tsc",
     "prepack": "bun run build",
-    "publish:npm": "npm publish --access=public"
+    "publish:npm": "npm publish --access=public",
+    "script:setup-compiler": "bun run scripts/setup-compiler.ts",
+    "script:setup-emsdk": "bun run scripts/setup-emsdk.ts",
+    "script:precompile-headers": "bun run scripts/precompile-headers.ts"
   },
   "devDependencies": {
     "@types/bun": "latest"