@ugo-studio/jspp 0.3.1 → 0.3.3

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

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { RESERVED_VAR_NAMES_FOR_STRICT_MODE } from "../../analysis/scope.js";
+import { RESERVED_VAR_NAMES } from "../../analysis/scope.js";
 import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function visitVariableDeclarationList(node, context) {
@@ -18,8 +18,8 @@ export function visitVariableDeclaration(node, context) {
         return this.generateDestructuring(varDecl.name, rhsCode, context);
     }
     const name = varDecl.name.getText();
-    if (RESERVED_VAR_NAMES_FOR_STRICT_MODE.has(name)) {
-        throw new CompilerError(`Cannot declare a variable named '${name}' in strict mode.`, varDecl.name, "SyntaxError");
+    if (RESERVED_VAR_NAMES.has(name)) {
+        throw new CompilerError(`Cannot declare a variable named '${name}'.`, varDecl.name, "SyntaxError");
     }
     const scope = this.getScopeForNode(varDecl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
@@ -53,7 +53,7 @@ export function visitVariableDeclaration(node, context) {
             (ts.isFunctionExpression(initExpr) && !initExpr.name)) {
             const initContext = {
                 ...context,
-                lambdaName: name, // Use the variable name as function name
+                functionName: name, // Use the variable name as function name
             };
             const nativeName = this.generateUniqueName(`__${name}_native_`, context.localScopeSymbols, context.globalScopeSymbols);
             const scopeNode = ts.isVariableDeclarationList(varDecl.parent)
@@ -92,16 +92,28 @@ export function visitVariableDeclaration(node, context) {
                 return nativeLambdaCode;
             }
         }
-        initializer = " = " + initText;
+        initializer = initText;
     }
     const isLetOrConst = (varDecl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
     const shouldDeref = context.derefBeforeAssignment &&
         (!context.localScopeSymbols.has(name));
-    const assignmentTarget = shouldDeref
+    let assignmentTarget = shouldDeref
         ? this.getDerefCode(name, name, context, typeInfo)
         : (typeInfo?.needsHeapAllocation && !shouldSkipDeref
             ? `*${name}`
             : name);
+    const sym = context.localScopeSymbols.get(name) ||
+        context.globalScopeSymbols.get(name);
+    if (sym?.checks.skippedHoisting) {
+        assignmentTarget = typeInfo?.needsHeapAllocation && !shouldSkipDeref
+            ? `auto ${name}`
+            : `jspp::AnyValue ${name}`;
+        if (initializer) {
+            initializer = typeInfo?.needsHeapAllocation && !shouldSkipDeref
+                ? `std::make_shared<jspp::AnyValue>(${initializer})`
+                : initializer;
+        }
+    }
     if (nativeLambdaCode)
         nativeLambdaCode += `;\n${this.indent()}`;
     if (isLetOrConst) {
@@ -116,19 +128,19 @@ export function visitVariableDeclaration(node, context) {
                 return `${nativeLambdaCode}${assignmentTarget} = jspp::Constants::UNDEFINED`;
             }
         }
-        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget} = ${initializer}`;
     }
     // For 'var', it's a bit more complex.
     if (context.isAssignmentOnly) {
         if (!initializer)
             return "";
-        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget} = ${initializer}`;
     }
     else {
         // This case should not be hit with the new hoisting logic,
         // but is kept for safety.
         const initValue = initializer
-            ? initializer.substring(3)
+            ? initializer
             : "jspp::Constants::UNDEFINED";
         if (typeInfo?.needsHeapAllocation) {
             return `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;

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

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { RESERVED_VAR_NAMES_FOR_STRICT_MODE } from "../../analysis/scope.js";
+import { RESERVED_VAR_NAMES } from "../../analysis/scope.js";
 import { CompilerError } from "../error.js";
 import { visitObjectPropertyName } from "./expression-handlers.js";
 import { CodeGenerator } from "./index.js";
@@ -13,8 +13,8 @@ export function generateDestructuring(lhs, rhsCode, context) {
     const genAssignment = (pattern, valueCode) => {
         if (ts.isIdentifier(pattern)) {
             const name = pattern.text;
-            if (RESERVED_VAR_NAMES_FOR_STRICT_MODE.has(name)) {
-                throw new CompilerError(`Cannot destructure to a variable named '${name}' in strict mode.`, pattern, "SyntaxError");
+            if (RESERVED_VAR_NAMES.has(name)) {
+                throw new CompilerError(`Cannot destructure to a variable named '${name}'.`, pattern, "SyntaxError");
             }
             const scope = this.getScopeForNode(pattern);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);

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

@@ -247,6 +247,17 @@ export function visitPrefixUnaryExpression(node, context) {
     const operand = this.visit(prefixUnaryExpr.operand, context);
     const operator = ts.tokenToString(prefixUnaryExpr.operator);
     if (operator === "++" || operator === "--") {
+        const opFunc = operator === "++" ? "add" : "sub";
+        if (ts.isPropertyAccessExpression(prefixUnaryExpr.operand)) {
+            const obj = this.visit(prefixUnaryExpr.operand.expression, context);
+            const prop = visitObjectPropertyName.call(this, prefixUnaryExpr.operand.name, context);
+            return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), 1.0))`;
+        }
+        else if (ts.isElementAccessExpression(prefixUnaryExpr.operand)) {
+            const obj = this.visit(prefixUnaryExpr.operand.expression, context);
+            const prop = visitObjectPropertyName.call(this, prefixUnaryExpr.operand.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), 1.0))`;
+        }
         let target = operand;
         if (ts.isIdentifier(prefixUnaryExpr.operand)) {
             const scope = this.getScopeForNode(prefixUnaryExpr.operand);
@@ -289,6 +300,20 @@ export function visitPostfixUnaryExpression(node, context) {
     const postfixUnaryExpr = node;
     const operand = this.visit(postfixUnaryExpr.operand, context);
     const operator = ts.tokenToString(postfixUnaryExpr.operator);
+    if (ts.isPropertyAccessExpression(postfixUnaryExpr.operand)) {
+        const obj = this.visit(postfixUnaryExpr.operand.expression, context);
+        const prop = visitObjectPropertyName.call(this, postfixUnaryExpr.operand.name, context);
+        const opFunc = operator === "++" ? "add" : "sub";
+        // Postfix needs IILE to return old value
+        return `([&]() { auto oldVal = ${obj}.get_own_property(${prop}); ${obj}.set_own_property(${prop}, jspp::${opFunc}(oldVal, 1.0)); return oldVal; })()`;
+    }
+    else if (ts.isElementAccessExpression(postfixUnaryExpr.operand)) {
+        const obj = this.visit(postfixUnaryExpr.operand.expression, context);
+        const prop = visitObjectPropertyName.call(this, postfixUnaryExpr.operand.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+        const opFunc = operator === "++" ? "add" : "sub";
+        // Postfix needs IILE to return old value
+        return `([&]() { auto oldVal = ${obj}.get_own_property(${prop}); ${obj}.set_own_property(${prop}, jspp::${opFunc}(oldVal, 1.0)); return oldVal; })()`;
+    }
     let target = operand;
     if (ts.isIdentifier(postfixUnaryExpr.operand)) {
         const scope = this.getScopeForNode(postfixUnaryExpr.operand);
@@ -402,42 +427,36 @@ export function visitBinaryExpression(node, context) {
     if (assignmentOperators.includes(opToken.kind)) {
         if (opToken.kind ===
             ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
-            const leftText = this.visit(binExpr.left, visitContext);
             const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
+                const leftText = this.visit(binExpr.left, visitContext);
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
+                const target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
-                return `${target} = jspp::unsigned_right_shift(${target}, ${rightText})`;
+                return `jspp::unsigned_right_shift_assign(${target}, ${rightText})`;
             }
-        }
-        if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
-            const leftText = this.visit(binExpr.left, visitContext);
-            const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
-            if (ts.isIdentifier(binExpr.left)) {
-                const scope = this.getScopeForNode(binExpr.left);
-                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
-                    ? `*${leftText}`
-                    : leftText;
-                return `${target} = jspp::pow(${target}, ${rightText})`;
+            else if (ts.isPropertyAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+                return `${obj}.set_own_property(${prop}, jspp::unsigned_right_shift(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else if (ts.isElementAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+                return `${obj}.set_own_property(${prop}, jspp::unsigned_right_shift(${obj}.get_own_property(${prop}), ${rightText}))`;
             }
-            // For complex LHS, we need a different approach, but this is a start.
         }
         if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
             opToken.kind === ts.SyntaxKind.BarBarEqualsToken ||
             opToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-            const leftText = this.visit(binExpr.left, visitContext);
             const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
+                const leftText = this.visit(binExpr.left, visitContext);
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
+                const target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
@@ -450,6 +469,29 @@ export function visitBinaryExpression(node, context) {
                     return `jspp::nullish_coalesce_assign(${target}, ${rightText})`;
                 }
             }
+            else if (ts.isPropertyAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+                const func = opToken.kind ===
+                    ts.SyntaxKind.AmpersandAmpersandEqualsToken
+                    ? "logical_and"
+                    : (opToken.kind === ts.SyntaxKind.BarBarEqualsToken
+                        ? "logical_or"
+                        : "nullish_coalesce");
+                // Logical assignments return newVal, set_own_property returns newVal.
+                return `${obj}.set_own_property(${prop}, jspp::${func}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else if (ts.isElementAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+                const func = opToken.kind ===
+                    ts.SyntaxKind.AmpersandAmpersandEqualsToken
+                    ? "logical_and"
+                    : (opToken.kind === ts.SyntaxKind.BarBarEqualsToken
+                        ? "logical_or"
+                        : "nullish_coalesce");
+                return `${obj}.set_own_property(${prop}, jspp::${func}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
         }
         const leftText = this.visit(binExpr.left, visitContext);
         let rightText = ts.isNumericLiteral(binExpr.right)
@@ -460,6 +502,35 @@ export function visitBinaryExpression(node, context) {
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope);
             rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
+        if (ts.isPropertyAccessExpression(binExpr.left)) {
+            const obj = this.visit(binExpr.left.expression, context);
+            const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+            const opBase = op.slice(0, -1); // "+=", "-=" -> "+", "-"
+            const opFunc = opBase === "+" ? "add" : (opBase === "-" ? "sub" : (opBase === "*" ? "mul" : (opBase === "/" ? "div" : (opBase === "%" ? "mod" : (opBase === "&" ? "bitwise_and" : (opBase === "|" ? "bitwise_or" : (opBase === "^" ? "bitwise_xor" : (opBase === "<<" ? "left_shift" : (opBase === ">>"
+                ? "right_shift"
+                : "")))))))));
+            if (opFunc) {
+                return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else {
+                // Fallback to IILE if we don't have an opFunc mapping
+                return `([&]() { auto val = ${obj}.get_own_property(${prop}); val ${op} ${rightText}; ${obj}.set_own_property(${prop}, val); return val; })()`;
+            }
+        }
+        else if (ts.isElementAccessExpression(binExpr.left)) {
+            const obj = this.visit(binExpr.left.expression, context);
+            const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            const opBase = op.slice(0, -1);
+            const opFunc = opBase === "+" ? "add" : (opBase === "-" ? "sub" : (opBase === "*" ? "mul" : (opBase === "/" ? "div" : (opBase === "%" ? "mod" : (opBase === "&" ? "bitwise_and" : (opBase === "|" ? "bitwise_or" : (opBase === "^" ? "bitwise_xor" : (opBase === "<<" ? "left_shift" : (opBase === ">>"
+                ? "right_shift"
+                : "")))))))));
+            if (opFunc) {
+                return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else {
+                return `([&]() { auto val = ${obj}.get_own_property(${prop}); val ${op} ${rightText}; ${obj}.set_own_property(${prop}, val); return val; })()`;
+            }
+        }
         let target = leftText;
         if (ts.isIdentifier(binExpr.left)) {
             const scope = this.getScopeForNode(binExpr.left);
@@ -607,7 +678,8 @@ export function visitBinaryExpression(node, context) {
             finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), visitContext, typeInfo);
         }
         // Number optimizations
-        if (typeInfo && typeInfo.type === "number") {
+        const nodeType = this.typeAnalyzer.inferNodeReturnType(binExpr.left);
+        if (nodeType === "number") {
             finalLeft = `${finalLeft}.as_double()`;
         }
     }
@@ -623,7 +695,8 @@ export function visitBinaryExpression(node, context) {
             finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
         // Number optimizations
-        if (typeInfo && typeInfo.type === "number") {
+        const nodeType = this.typeAnalyzer.inferNodeReturnType(binExpr.right);
+        if (nodeType === "number") {
             finalRight = `${finalRight}.as_double()`;
         }
     }
@@ -642,101 +715,82 @@ export function visitBinaryExpression(node, context) {
     if (opToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
         return `jspp::nullish_coalesce(${finalLeft}, ${finalRight})`;
     }
-    const isLiteral = (n) => ts.isNumericLiteral(n);
-    const supportsNativeBoolean = ts.isIfStatement(node.parent) ||
-        ts.isConditionalExpression(node.parent);
     // Native values for lhs and rhs
-    const literalLeft = isLiteral(binExpr.left)
+    const literalLeft = ts.isNumericLiteral(binExpr.left)
         ? binExpr.left.getText()
         : finalLeft;
-    const literalRight = isLiteral(binExpr.right)
+    const literalRight = ts.isNumericLiteral(binExpr.right)
         ? binExpr.right.getText()
         : finalRight;
-    // Operations that returns boolean should return the native boolean if supported
-    if (constants.booleanOperators.includes(opToken.kind) &&
-        supportsNativeBoolean) {
-        if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-            return `jspp::is_strictly_equal_to_primitive(${literalLeft}, ${literalRight})`;
-        }
-        if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-            return `jspp::is_equal_to_primitive(${literalLeft}, ${literalRight})`;
-        }
-        if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-            return `!jspp::is_strictly_equal_to_primitive(${literalLeft}, ${literalRight})`;
-        }
-        if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-            return `!jspp::is_equal_to_primitive(${literalLeft}, ${literalRight})`;
-        }
-        let funcName = "";
-        if (opToken.kind === ts.SyntaxKind.LessThanToken) {
-            funcName = "jspp::less_than_primitive";
-        }
-        if (opToken.kind === ts.SyntaxKind.LessThanEqualsToken) {
-            funcName = "jspp::less_than_or_equal_primitive";
-        }
-        if (opToken.kind === ts.SyntaxKind.GreaterThanToken) {
-            funcName = "jspp::greater_than_primitive";
-        }
-        if (opToken.kind === ts.SyntaxKind.GreaterThanEqualsToken) {
-            funcName = "jspp::greater_than_or_equal_primitive";
+    let supportsNativeValue = false;
+    const exprReturnType = this.typeAnalyzer.inferNodeReturnType(node);
+    if (exprReturnType === "boolean" &&
+        (ts.isIfStatement(node.parent) ||
+            ts.isConditionalExpression(node.parent))) {
+        supportsNativeValue = true;
+    }
+    else if (exprReturnType === "number" &&
+        context.isInsideNativeLambda &&
+        context.isInsideFunction) {
+        const funcDecl = this
+            .findEnclosingFunctionDeclarationFromReturnStatement(node);
+        if (funcDecl) {
+            const funcReturnType = this.typeAnalyzer.inferFunctionReturnType(funcDecl);
+            if (funcReturnType === "number") {
+                supportsNativeValue = true;
+            }
         }
-        // For C++ primitive literals, standard operators are fine if they map directly,
-        // but we are safe using our functions (which handle doubles correctly).
-        // Actually, for pure numeric literals like "1 < 2", we can leave it as is if we want optimization,
-        // but consistency is safer.
-        // Let's stick to valid C++ syntax for literals if possible to avoid overhead?
-        // jspp::less_than(1, 2) works.
-        return `${funcName}(${literalLeft}, ${literalRight})`;
     }
+    const method = supportsNativeValue ? "_native" : "";
     // Return boxed value
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-        return `jspp::is_strictly_equal_to(${literalLeft}, ${literalRight})`;
+        return `jspp::is_strictly_equal_to${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-        return `jspp::is_equal_to(${literalLeft}, ${literalRight})`;
+        return `jspp::is_equal_to${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-        return `jspp::not_strictly_equal_to(${literalLeft}, ${literalRight})`;
+        return `jspp::not_strictly_equal_to${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        return `jspp::not_equal_to(${literalLeft}, ${literalRight})`;
+        return `jspp::not_equal_to${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskToken) {
-        return `jspp::pow(${literalLeft}, ${literalRight})`;
+        return `jspp::pow${method}(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken) {
-        return `jspp::unsigned_right_shift(${literalLeft}, ${literalRight})`;
+        return `jspp::unsigned_right_shift${method}(${literalLeft}, ${literalRight})`;
     }
     // For other arithmetic and bitwise operations, use native operations if possible
     switch (op) {
         case "+":
-            return `jspp::add(${literalLeft}, ${literalRight})`;
+            return `jspp::add${method}(${literalLeft}, ${literalRight})`;
         case "-":
-            return `jspp::sub(${literalLeft}, ${literalRight})`;
+            return `jspp::sub${method}(${literalLeft}, ${literalRight})`;
         case "*":
-            return `jspp::mul(${literalLeft}, ${literalRight})`;
+            return `jspp::mul${method}(${literalLeft}, ${literalRight})`;
         case "/":
-            return `jspp::div(${literalLeft}, ${literalRight})`;
+            return `jspp::div${method}(${literalLeft}, ${literalRight})`;
         case "%":
-            return `jspp::mod(${literalLeft}, ${literalRight})`;
+            return `jspp::mod${method}(${literalLeft}, ${literalRight})`;
         case "^":
-            return `jspp::bitwise_xor(${literalLeft}, ${literalRight})`;
+            return `jspp::bitwise_xor${method}(${literalLeft}, ${literalRight})`;
         case "&":
-            return `jspp::bitwise_and(${literalLeft}, ${literalRight})`;
+            return `jspp::bitwise_and${method}(${literalLeft}, ${literalRight})`;
         case "|":
-            return `jspp::bitwise_or(${literalLeft}, ${literalRight})`;
+            return `jspp::bitwise_or${method}(${literalLeft}, ${literalRight})`;
         case "<<":
-            return `jspp::left_shift(${literalLeft}, ${literalRight})`;
+            return `jspp::left_shift${method}(${literalLeft}, ${literalRight})`;
         case ">>":
-            return `jspp::right_shift(${literalLeft}, ${literalRight})`;
+            return `jspp::right_shift${method}(${literalLeft}, ${literalRight})`;
         case "<":
-            return `jspp::less_than(${literalLeft}, ${literalRight})`;
+            return `jspp::less_than${method}(${literalLeft}, ${literalRight})`;
         case ">":
-            return `jspp::greater_than(${literalLeft}, ${literalRight})`;
+            return `jspp::greater_than${method}(${literalLeft}, ${literalRight})`;
         case "<=":
-            return `jspp::less_than_or_equal(${literalLeft}, ${literalRight})`;
+            return `jspp::less_than_or_equal${method}(${literalLeft}, ${literalRight})`;
         case ">=":
-            return `jspp::greater_than_or_equal(${literalLeft}, ${literalRight})`;
+            return `jspp::greater_than_or_equal${method}(${literalLeft}, ${literalRight})`;
     }
     return `/* Unhandled Operator: ${finalLeft} ${op} ${finalRight} */`; // Default fallback
 }
@@ -1283,7 +1337,7 @@ export function visitTypeOfExpression(node, context) {
             derefExpr = this.getDerefCode(exprText, this.getJsVarName(typeOfExpr.expression), context, typeInfo);
         }
     }
-    return `jspp::Access::type_of(${derefExpr})`;
+    return `jspp::type_of(${derefExpr})`;
 }
 export function visitAwaitExpression(node, context) {
     const awaitExpr = node;