@ugo-studio/jspp 0.3.2 → 0.3.4

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

@@ -106,7 +106,7 @@ export class CodeGenerator {
                 wasmWrappers +=
                     `    auto res = ${pointerName}(global${callArgs});\n`;
                 wasmWrappers +=
-                    `    return jspp::Operators_Private::ToNumber(res);\n`;
+                    `    return jspp::NumberOperators::ToDouble(res);\n`;
                 wasmWrappers += `}\n\n`;
             }
         }

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

@@ -819,22 +819,26 @@ export function visitReturnStatement(node, context) {
                 return `${this.indent()}jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)});\n`; // THROWS, not returns
             }
             if (typeInfo &&
-                !typeInfo.isParameter &&
                 !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") {
+            const funcDecl = this
+                .findEnclosingFunctionDeclarationFromReturnStatement(expr);
+            if (funcDecl) {
+                const funcReturnType = this.typeAnalyzer
+                    .inferFunctionReturnType(funcDecl);
+                if (funcReturnType === "number" &&
+                    context.isInsideNativeLambda &&
+                    context.isInsideFunction) {
+                    const exprReturnType = this.typeAnalyzer
+                        .inferNodeReturnType(expr);
+                    if (exprReturnType === "number") {
                         finalExpr = `${finalExpr}.as_double()`;
                     }
+                    else {
+                        finalExpr =
+                            `jspp::NumberOperators::ToDouble(${finalExpr})`;
+                    }
                 }
             }
         }

package/dist/interpreter/core/traverser.js

@@ -4,8 +4,7 @@ export class Traverser {
         this.traverseNode(node, null, visitor);
     }
     traverseNode(node, parent, visitor) {
-        const nodeKind = ts.SyntaxKind[node.kind];
-        const visitorActions = visitor[nodeKind];
+        const visitorActions = visitor[node.kind];
         if (visitorActions && visitorActions.enter) {
             visitorActions.enter(node, parent);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -14,7 +14,7 @@
     "scripts"
   ],
   "scripts": {
-    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts && bun run scripts/precompile-headers.ts",
+    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts",
     "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",

package/scripts/precompile-headers.ts

@@ -112,6 +112,14 @@ if (process.platform === "win32") {
     MODES[1].flags.push("-Wa,-mbig-obj");
 }
 
+const pkgDir = path.dirname(import.meta.dirname);
+const emsdkEnv = {
+    ...process.env,
+    PATH: `${path.join(pkgDir, ".emsdk")}${path.delimiter}${
+        path.join(pkgDir, ".emsdk", "upstream", "emscripten")
+    }${path.delimiter}${process.env.PATH}`,
+};
+
 async function getLatestMtime(
     dirPath: string,
     filter?: (name: string) => boolean,
@@ -146,11 +154,11 @@ async function findCppFiles(dir: string): Promise<string[]> {
 }
 
 async function runCommand(cmd: string, args: string[]): Promise<boolean> {
-    // console.log(`${COLORS.dim}> ${cmd} ${args.join(" ")}${COLORS.reset}`);
     return new Promise((resolve) => {
         const proc = spawn(cmd, args, {
             stdio: "inherit",
             shell: process.platform === "win32",
+            env: emsdkEnv,
         });
         proc.on("close", (code) => resolve(code === 0));
     });

package/src/prelude/library/array.cpp

@@ -78,7 +78,7 @@ namespace jspp {
                     }
                 } else {
                     auto lenVal = items.get_property_with_receiver("length", items);
-                    size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                    size_t len = static_cast<size_t>(jspp::NumberOperators::ToUint32(lenVal));
                     
                     for (size_t k = 0; k < len; ++k) {
                         auto kVal = items.get_property_with_receiver(std::to_string(k), items);
@@ -149,7 +149,7 @@ namespace jspp {
                     }
                 } else {
                     auto lenVal = items.get_property_with_receiver("length", items);
-                    size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                    size_t len = static_cast<size_t>(jspp::NumberOperators::ToUint32(lenVal));
                     for (size_t k = 0; k < len; ++k) {
                         auto kVal = items.get_property_with_receiver(std::to_string(k), items);
                         if (kVal.is_promise()) kVal = co_await kVal;

package/src/prelude/library/math.cpp

@@ -11,7 +11,7 @@ namespace jspp {
 
         double GetArgAsDouble(std::span<const jspp::AnyValue> args, size_t index) {
             if (index >= args.size()) return std::numeric_limits<double>::quiet_NaN();
-            return Operators_Private::ToNumber(args[index]);
+            return NumberOperators::ToDouble(args[index]);
         }
 
         jspp::AnyValue MathFunc1(std::span<const jspp::AnyValue> args, double (*func)(double)) {
@@ -86,7 +86,7 @@ namespace jspp {
             }, "ceil"));
 
             defMutable("clz32", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
-                uint32_t val = Operators_Private::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
+                uint32_t val = NumberOperators::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
                 if (val == 0) return AnyValue::make_number(32);
                 return AnyValue::make_number(std::countl_zero(val));
             }, "clz32"));
@@ -119,7 +119,7 @@ namespace jspp {
             defMutable("hypot", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 double result = 0;
                 for (const auto& arg : args) {
-                    double val = Operators_Private::ToNumber(arg);
+                    double val = NumberOperators::ToDouble(arg);
                     if (std::isinf(val)) return AnyValue::make_number(std::numeric_limits<double>::infinity());
                     result = std::hypot(result, val);
                 }
@@ -127,8 +127,8 @@ namespace jspp {
             }, "hypot"));
 
             defMutable("imul", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
-                int32_t a = Operators_Private::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
-                int32_t b = Operators_Private::ToInt32(args.size() < 2 ? Constants::UNDEFINED : args[1]);
+                int32_t a = NumberOperators::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
+                int32_t b = NumberOperators::ToInt32(args.size() < 2 ? Constants::UNDEFINED : args[1]);
                 return AnyValue::make_number(a * b);
             }, "imul"));
 
@@ -151,7 +151,7 @@ namespace jspp {
             defMutable("max", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 double maxVal = -std::numeric_limits<double>::infinity();
                 for (const auto& arg : args) {
-                    double val = Operators_Private::ToNumber(arg);
+                    double val = NumberOperators::ToDouble(arg);
                     if (std::isnan(val)) return AnyValue::make_nan();
                     if (val > maxVal) maxVal = val;
                 }
@@ -161,7 +161,7 @@ namespace jspp {
             defMutable("min", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 double minVal = std::numeric_limits<double>::infinity();
                 for (const auto& arg : args) {
-                    double val = Operators_Private::ToNumber(arg);
+                    double val = NumberOperators::ToDouble(arg);
                     if (std::isnan(val)) return AnyValue::make_nan();
                     if (val < minVal) minVal = val;
                 }
@@ -238,7 +238,7 @@ namespace jspp {
                     auto nextRes = nextFunc.call(iterObj, std::span<const jspp::AnyValue>{}, "next");
                     if (is_truthy(nextRes.get_own_property("done"))) break;
                     
-                    double val = Operators_Private::ToNumber(nextRes.get_own_property("value"));
+                    double val = NumberOperators::ToDouble(nextRes.get_own_property("value"));
                     if (std::isnan(val)) {
                         sum = std::numeric_limits<double>::quiet_NaN();
                         break;

package/src/prelude/utils/access.hpp

@@ -48,40 +48,6 @@ namespace jspp
             return var;
         }
 
-        inline AnyValue type_of(const std::optional<AnyValue> &val = std::nullopt)
-        {
-            if (!val.has_value())
-                return AnyValue::make_string("undefined");
-
-            switch (val.value().get_type())
-            {
-            case JsType::Undefined:
-                return AnyValue::make_string("undefined");
-            case JsType::Null:
-                return AnyValue::make_string("object");
-            case JsType::Boolean:
-                return AnyValue::make_string("boolean");
-            case JsType::Number:
-                return AnyValue::make_string("number");
-            case JsType::String:
-                return AnyValue::make_string("string");
-            case JsType::Symbol:
-                return AnyValue::make_string("symbol");
-            case JsType::Function:
-                return AnyValue::make_string("function");
-            case JsType::Object:
-                return AnyValue::make_string("object");
-            case JsType::Array:
-                return AnyValue::make_string("object");
-            case JsType::Iterator:
-                return AnyValue::make_string("object");
-            case JsType::AsyncIterator:
-                return AnyValue::make_string("object");
-            default:
-                return AnyValue::make_string("undefined");
-            }
-        }
-
         // Helper function to get enumerable own property keys/values of an object
         inline std::vector<AnyValue> get_object_keys(const AnyValue &obj, bool include_symbols = false)
         {

package/src/prelude/utils/assignment_operators.hpp

@@ -39,6 +39,42 @@ namespace jspp
         return lhs;
     }
 
+    inline AnyValue &operator&=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_and(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator|=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_or(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator^=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_xor(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator<<=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::left_shift(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator>>=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::right_shift(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::unsigned_right_shift(lhs, rhs);
+        return lhs;
+    }
+
     inline AnyValue &operator++(AnyValue &val)
     {
         val = jspp::add(val, 1.0);
@@ -116,4 +152,64 @@ namespace jspp
     {
         return lhs %= static_cast<double>(rhs);
     }
+
+    inline AnyValue &operator&=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_and(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator&=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs &= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator|=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_or(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator|=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs |= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator^=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_xor(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator^=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs ^= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator<<=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::left_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator<<=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs <<= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator>>=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::right_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator>>=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs >>= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::unsigned_right_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const int &rhs)
+    {
+        return unsigned_right_shift_assign(lhs, static_cast<double>(rhs));
+    }
 }

package/src/prelude/utils/operators.hpp

@@ -11,6 +11,41 @@
 
 namespace jspp
 {
+    // --- TYPE OF ---
+    inline AnyValue type_of(const std::optional<AnyValue> &val = std::nullopt)
+    {
+        if (!val.has_value())
+            return AnyValue::make_string("undefined");
+
+        switch (val.value().get_type())
+        {
+        case JsType::Undefined:
+            return AnyValue::make_string("undefined");
+        case JsType::Null:
+            return AnyValue::make_string("object");
+        case JsType::Boolean:
+            return AnyValue::make_string("boolean");
+        case JsType::Number:
+            return AnyValue::make_string("number");
+        case JsType::String:
+            return AnyValue::make_string("string");
+        case JsType::Symbol:
+            return AnyValue::make_string("symbol");
+        case JsType::Function:
+            return AnyValue::make_string("function");
+        case JsType::Object:
+            return AnyValue::make_string("object");
+        case JsType::Array:
+            return AnyValue::make_string("object");
+        case JsType::Iterator:
+            return AnyValue::make_string("object");
+        case JsType::AsyncIterator:
+            return AnyValue::make_string("object");
+        default:
+            return AnyValue::make_string("undefined");
+        }
+    }
+
     // Operator === (returns boolean wrapped in AnyValue)
     inline const AnyValue is_strictly_equal_to(const AnyValue &lhs, const double &rhs) noexcept
     {
@@ -157,15 +192,15 @@ namespace jspp
     // --- UNARY OPERATORS ---
     inline AnyValue plus(const AnyValue &val)
     {
-        return AnyValue::make_number(Operators_Private::ToNumber(val));
+        return AnyValue::make_number(NumberOperators::ToDouble(val));
     }
     inline AnyValue negate(const AnyValue &val)
     {
-        return AnyValue::make_number(-Operators_Private::ToNumber(val));
+        return AnyValue::make_number(-NumberOperators::ToDouble(val));
     }
     inline AnyValue bitwise_not(const AnyValue &val)
     {
-        return AnyValue::make_number(~Operators_Private::ToInt32(val));
+        return AnyValue::make_number(~NumberOperators::ToInt32(val));
     }
     inline AnyValue logical_not(const AnyValue &val)
     {
@@ -349,4 +384,4 @@ namespace jspp
             return lhs;
         return rhs;
     }
-}
+}