@ugo-studio/jspp 0.2.3 → 0.2.5

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

@@ -1,7 +1,7 @@
 import ts from "typescript";
-import { DeclaredSymbols } from "../../ast/symbols";
-import { CodeGenerator } from "./";
-import { collectBlockScopedDeclarations, collectFunctionScopedDeclarations, } from "./helpers";
+import { DeclaredSymbols } from "../../ast/symbols.js";
+import { collectBlockScopedDeclarations, collectFunctionScopedDeclarations, } from "./helpers.js";
+import { CodeGenerator } from "./index.js";
 export function visitSourceFile(node, context) {
     const sourceFile = node;
     let code = "";
@@ -13,22 +13,22 @@ export function visitSourceFile(node, context) {
     const hoistedSymbols = new DeclaredSymbols();
     // Hoist function declarations
     funcDecls.forEach((func) => {
-        code += this.hoistDeclaration(func, hoistedSymbols);
+        code += this.hoistDeclaration(func, hoistedSymbols, node);
     });
     // Hoist class declarations
     classDecls.forEach((cls) => {
-        code += this.hoistDeclaration(cls, hoistedSymbols);
+        code += this.hoistDeclaration(cls, hoistedSymbols, node);
     });
     // Hoist variable declarations (var)
     varDecls.forEach((decl) => {
-        code += this.hoistDeclaration(decl, hoistedSymbols);
+        code += this.hoistDeclaration(decl, hoistedSymbols, node);
     });
     // Hoist top-level let/const
     topLevelLetConst.forEach((decl) => {
-        code += this.hoistDeclaration(decl, hoistedSymbols);
+        code += this.hoistDeclaration(decl, hoistedSymbols, node);
     });
     // Compile symbols for other statements (excluding function)
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
     const localScopeSymbols = new DeclaredSymbols(hoistedSymbols); // hoistedSymbols becomes new local
     // 2. Assign all hoisted functions first
     const contextForFunctions = {
@@ -37,13 +37,29 @@ export function visitSourceFile(node, context) {
     };
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
-        if (funcName) {
-            this.markSymbolAsChecked(funcName, contextForFunctions.topLevelScopeSymbols, contextForFunctions.localScopeSymbols);
-            this.markSymbolAsChecked(funcName, topLevelScopeSymbols, localScopeSymbols);
-            const lambda = this.generateLambda(stmt, contextForFunctions, {
-                isAssignment: true,
-            });
-            code += `${this.indent()}*${funcName} = ${lambda};\n`;
+        if (!funcName)
+            return;
+        const symbol = hoistedSymbols.get(funcName);
+        if (!symbol)
+            return;
+        // Mark before further visits
+        this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
+        this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Generate and update self 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`;
         }
     });
     // 3. Process other statements
@@ -57,7 +73,7 @@ export function visitSourceFile(node, context) {
                 0;
             const contextForVisit = {
                 ...context,
-                topLevelScopeSymbols,
+                globalScopeSymbols,
                 localScopeSymbols,
                 isAssignmentOnly: !isLetOrConst,
             };
@@ -70,7 +86,7 @@ export function visitSourceFile(node, context) {
             code += this.visit(stmt, {
                 ...context,
                 isFunctionBody: false,
-                topLevelScopeSymbols,
+                globalScopeSymbols,
                 localScopeSymbols,
             });
         }
@@ -78,6 +94,7 @@ export function visitSourceFile(node, context) {
     return code;
 }
 export function visitBlock(node, context) {
+    context.currentScopeNode = node; // Update scope node
     let code = `${this.indent()}{\n`;
     this.indentationLevel++;
     const block = node;
@@ -88,18 +105,18 @@ export function visitBlock(node, context) {
     const hoistedSymbols = new DeclaredSymbols();
     // 1. Hoist all function declarations
     funcDecls.forEach((func) => {
-        code += this.hoistDeclaration(func, hoistedSymbols);
+        code += this.hoistDeclaration(func, hoistedSymbols, node);
     });
     // Hoist class declarations
     classDecls.forEach((cls) => {
-        code += this.hoistDeclaration(cls, hoistedSymbols);
+        code += this.hoistDeclaration(cls, hoistedSymbols, node);
     });
     // Hoist variable declarations (let/const only)
     blockScopedDecls.forEach((decl) => {
-        code += this.hoistDeclaration(decl, hoistedSymbols);
+        code += this.hoistDeclaration(decl, hoistedSymbols, node);
     });
     // Compile symbols for other statements (excluding function)
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
     const localScopeSymbols = new DeclaredSymbols(hoistedSymbols); // hoistedSymbols becomes new local
     // 2. Assign all hoisted functions first
     const contextForFunctions = {
@@ -108,13 +125,29 @@ export function visitBlock(node, context) {
     };
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
-        if (funcName) {
-            this.markSymbolAsChecked(funcName, contextForFunctions.topLevelScopeSymbols, contextForFunctions.localScopeSymbols);
-            this.markSymbolAsChecked(funcName, topLevelScopeSymbols, localScopeSymbols);
-            const lambda = this.generateLambda(stmt, contextForFunctions, {
-                isAssignment: true,
-            });
-            code += `${this.indent()}*${funcName} = ${lambda};\n`;
+        if (!funcName)
+            return;
+        const symbol = hoistedSymbols.get(funcName);
+        if (!symbol)
+            return;
+        // Mark before further visits
+        this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
+        this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Generate and update self 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`;
         }
     });
     // 3. Process other statements
@@ -128,7 +161,7 @@ export function visitBlock(node, context) {
                 0;
             const contextForVisit = {
                 ...context,
-                topLevelScopeSymbols,
+                globalScopeSymbols,
                 localScopeSymbols,
                 isAssignmentOnly: !isLetOrConst,
             };
@@ -141,7 +174,7 @@ export function visitBlock(node, context) {
             code += this.visit(stmt, {
                 ...context,
                 isFunctionBody: false,
-                topLevelScopeSymbols,
+                globalScopeSymbols,
                 localScopeSymbols,
             });
         }
@@ -217,7 +250,17 @@ export function visitIfStatement(node, context) {
                 isFunctionBody: false,
             });
     }
-    return `${this.indent()}if (is_truthy(${condition})) ${thenStmt}${elseStmt}`;
+    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}`;
+        }
+    }
+    return `${this.indent()}if (jspp::is_truthy(${condition})) ${thenStmt}${elseStmt}`;
 }
 export function visitExpressionStatement(node, context) {
     return (this.indent() +
@@ -234,7 +277,7 @@ export function visitTryStatement(node, context) {
     const tryStmt = node;
     if (context.isInsideAsyncFunction) {
         if (tryStmt.finallyBlock) {
-            const declaredSymbols = new Set(context.topLevelScopeSymbols.toSet());
+            const declaredSymbols = new Set(context.globalScopeSymbols.names);
             this.getDeclaredSymbols(tryStmt.tryBlock).forEach((s) => declaredSymbols.add(s));
             if (tryStmt.catchClause) {
                 this.getDeclaredSymbols(tryStmt.catchClause).forEach((s) => declaredSymbols.add(s));
@@ -339,7 +382,7 @@ export function visitTryStatement(node, context) {
             return code;
         }
         else {
-            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
+            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.globalScopeSymbols, context.localScopeSymbols);
             const newContext = {
                 ...context,
                 isFunctionBody: false,
@@ -405,7 +448,7 @@ export function visitTryStatement(node, context) {
         }
     }
     if (tryStmt.finallyBlock) {
-        const declaredSymbols = new Set(context.topLevelScopeSymbols.toSet());
+        const declaredSymbols = new Set(context.globalScopeSymbols.names);
         this.getDeclaredSymbols(tryStmt.tryBlock).forEach((s) => declaredSymbols.add(s));
         if (tryStmt.catchClause) {
             this.getDeclaredSymbols(tryStmt.catchClause).forEach((s) => declaredSymbols.add(s));
@@ -440,7 +483,7 @@ export function visitTryStatement(node, context) {
         this.indentationLevel--;
         code += `${this.indent()}}\n`;
         if (tryStmt.catchClause) {
-            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
+            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText(), context.globalScopeSymbols, context.localScopeSymbols);
             const catchContext = { ...innerContext, exceptionName };
             code +=
                 `${this.indent()}catch (const std::exception& ${exceptionName}) {\n`;
@@ -476,7 +519,7 @@ export function visitTryStatement(node, context) {
         return code;
     }
     else {
-        const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
+        const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.globalScopeSymbols, context.localScopeSymbols);
         const newContext = {
             ...context,
             isFunctionBody: false,
@@ -540,7 +583,7 @@ export function visitYieldExpression(node, context) {
             let code = `${this.indent()}{\n`;
             this.indentationLevel++;
             const declaredSymbols = this.getDeclaredSymbols(expr);
-            context.topLevelScopeSymbols.toSet().forEach((s) => declaredSymbols.add(s));
+            context.globalScopeSymbols.names.forEach((s) => declaredSymbols.add(s));
             const iterableRef = this.generateUniqueName("__iter_ref", declaredSymbols);
             const iterator = this.generateUniqueName("__iter", declaredSymbols);
             const nextFunc = this.generateUniqueName("__next_func", declaredSymbols);
@@ -566,7 +609,7 @@ export function visitYieldExpression(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++;
             if (context.isInsideAsyncFunction) {
                 code +=

package/dist/core/codegen/visitor.js

@@ -1,12 +1,12 @@
 import ts from "typescript";
-import { CodeGenerator } from "./";
-import { visitClassDeclaration } from "./class-handlers";
-import { visitCaseClause, visitDefaultClause, visitDoStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitSwitchStatement, visitWhileStatement, } from "./control-flow-handlers";
-import { visitVariableDeclaration, visitVariableDeclarationList, } from "./declaration-handlers";
-import { visitArrayLiteralExpression, visitAwaitExpression, visitBinaryExpression, visitCallExpression, visitConditionalExpression, visitDeleteExpression, visitElementAccessExpression, visitNewExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, visitTypeOfExpression, visitVoidExpression, } from "./expression-handlers";
-import { visitArrowFunction, visitFunctionDeclaration, visitFunctionExpression, } from "./function-handlers";
-import { visitFalseKeyword, visitIdentifier, visitNoSubstitutionTemplateLiteral, visitNullKeyword, visitNumericLiteral, visitStringLiteral, visitThisKeyword, visitTrueKeyword, visitUndefinedKeyword, } from "./literal-handlers";
-import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitExpressionStatement, visitIfStatement, visitLabeledStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, visitYieldExpression, } from "./statement-handlers";
+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 { 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";
 export function visit(node, context) {
     if (ts.isFunctionDeclaration(node)) {
         return visitFunctionDeclaration.call(this, node, context);

package/dist/core/parser.js

@@ -1,6 +1,6 @@
 import * as ts from "typescript";
 export class Parser {
-    parse(sourceCode) {
-        return ts.createSourceFile("temp.js", sourceCode, ts.ScriptTarget.Latest, true);
+    parse(sourceCode, fileName) {
+        return ts.createSourceFile(fileName || "temp.js", sourceCode, ts.ScriptTarget.Latest, true);
     }
 }

package/dist/index.js

@@ -1,16 +1,16 @@
 import path from "path";
-import { TypeAnalyzer } from "./analysis/typeAnalyzer";
-import { CodeGenerator } from "./core/codegen";
-import { Parser } from "./core/parser";
+import { TypeAnalyzer } from "./analysis/typeAnalyzer.js";
+import { CodeGenerator } from "./core/codegen/index.js";
+import { Parser } from "./core/parser.js";
 export class Interpreter {
     parser = new Parser();
     analyzer = new TypeAnalyzer();
     generator = new CodeGenerator();
-    interpret(jsCode) {
-        const ast = this.parser.parse(jsCode);
+    interpret(jsCode, fileName) {
+        const ast = this.parser.parse(jsCode, fileName);
         this.analyzer.analyze(ast);
         const cppCode = this.generator.generate(ast, this.analyzer);
-        const preludePath = path.resolve(__dirname, "..", "src", "prelude");
+        const preludePath = path.resolve(import.meta.dirname, "..", "src", "prelude");
         return { cppCode, preludePath };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",

package/src/prelude/utils/access.hpp

@@ -231,7 +231,7 @@ namespace jspp
             {
                 throw jspp::Exception::make_exception("Function has non-object prototype in instanceof check", "TypeError");
             }
-            
+
             AnyValue current = lhs;
 
             while (true)
@@ -253,7 +253,7 @@ namespace jspp
                 {
                     break;
                 }
-                
+
                 if (proto.is_null() || proto.is_undefined())
                     break;
                 if (is_strictly_equal_to_primitive(proto, targetProto))

package/src/prelude/utils/log_any_value/primitives.hpp

@@ -27,7 +27,14 @@ namespace jspp
             if (val.is_symbol())
                 return Color::BLUE + val.to_std_string() + Color::RESET;
             if (val.is_accessor_descriptor())
+            {
+                auto desc = val.as_accessor_descriptor();
+                if (desc->get.has_value() && !desc->set.has_value())
+                    return Color::BLUE + std::string("[Getter]") + Color::RESET;
+                if (!desc->get.has_value() && desc->set.has_value())
+                    return Color::BLUE + std::string("[Setter]") + Color::RESET;
                 return Color::BLUE + std::string("[Getter/Setter]") + Color::RESET;
+            }
 
             if (val.is_string())
             {

package/src/prelude/utils/operators.hpp

@@ -93,16 +93,14 @@ namespace jspp
     {
         switch (val.get_type())
         {
-        case JsType::Boolean:
-            return val.as_boolean();
         case JsType::Number:
             return is_truthy(val.as_double());
         case JsType::String:
-            return !val.as_string()->value.empty();
-        case JsType::Undefined:
-            return false;
+            return is_truthy(val.as_string()->value);
+        case JsType::Boolean:
+            return val.as_boolean();
         case JsType::Null:
-            return false;
+        case JsType::Undefined:
         case JsType::Uninitialized:
             return false;
         default:

package/src/prelude/values/prototypes/function.hpp

@@ -20,6 +20,24 @@ namespace jspp
                                                key);
             }
 
+            // --- call() method ---
+            if (key == "call")
+            {
+                return AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                {
+                    AnyValue thisArg = Constants::UNDEFINED;
+                    std::span<const AnyValue> fnArgs;
+
+                    if (!args.empty())
+                    {
+                        thisArg = args[0];
+                        fnArgs = args.subspan(1);
+                    }
+
+                    return thisVal.call(thisArg, fnArgs);
+                }, key);
+            }
+
             return std::nullopt;
         }
     }