@ugo-studio/jspp 0.3.0 → 0.3.2

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

@@ -35,7 +35,7 @@ export function visitClassDeclaration(node, context) {
         constructorLambda = this.generateWrappedLambda(this.generateLambdaComponents(constructor, {
             ...classContext,
             isInsideFunction: true,
-            lambdaName: className,
+            functionName: className,
         }, { isClass: true }));
     }
     else {

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

@@ -50,7 +50,7 @@ export function visitForStatement(node, context) {
                         type: declType,
                         checks: { initialized: true },
                     });
-                    if (typeInfo.needsHeapAllocation) {
+                    if (typeInfo?.needsHeapAllocation) {
                         initializerCode =
                             `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
                     }
@@ -124,7 +124,7 @@ export function visitForInStatement(node, context) {
             varName = decl.name.getText();
             const scope = this.getScopeForNode(decl);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(varName, scope);
-            if (typeInfo.needsHeapAllocation) {
+            if (typeInfo?.needsHeapAllocation) {
                 code +=
                     `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 assignmentTarget = `*${varName}`;
@@ -140,7 +140,7 @@ export function visitForInStatement(node, context) {
         varName = forIn.initializer.getText();
         const scope = this.getScopeForNode(forIn.initializer);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(varName, scope);
-        assignmentTarget = typeInfo.needsHeapAllocation
+        assignmentTarget = typeInfo?.needsHeapAllocation
             ? `*${varName}`
             : varName;
     }
@@ -154,11 +154,10 @@ export function visitForInStatement(node, context) {
     }
     const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
     code +=
-        `${this.indent()}std::vector<std::string> ${keysVar} = jspp::Access::get_object_keys(${derefExpr});\n`;
-    code += `${this.indent()}for (const auto& ${varName}_str : ${keysVar}) {\n`;
+        `${this.indent()}std::vector<jspp::AnyValue> ${keysVar} = jspp::Access::get_object_keys(${derefExpr});\n`;
+    code += `${this.indent()}for (const auto& ${varName}_val : ${keysVar}) {\n`;
     this.indentationLevel++;
-    code +=
-        `${this.indent()}${assignmentTarget} = jspp::AnyValue::make_string(${varName}_str);\n`;
+    code += `${this.indent()}${assignmentTarget} = ${varName}_val;\n`;
     code += this.visit(forIn.statement, {
         ...context,
         currentLabel: undefined,
@@ -196,7 +195,7 @@ export function visitForOfStatement(node, context) {
             elemName = decl.name.getText();
             const scope = this.getScopeForNode(decl);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemName, scope);
-            if (typeInfo.needsHeapAllocation) {
+            if (typeInfo?.needsHeapAllocation) {
                 code +=
                     `${this.indent()}auto ${elemName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 assignmentTarget = `*${elemName}`;
@@ -212,7 +211,7 @@ export function visitForOfStatement(node, context) {
         elemName = forOf.initializer.getText();
         const scope = this.getScopeForNode(forOf.initializer);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemName, scope);
-        assignmentTarget = typeInfo.needsHeapAllocation
+        assignmentTarget = typeInfo?.needsHeapAllocation
             ? `*${elemName}`
             : elemName;
     }
@@ -440,12 +439,14 @@ export function visitSwitchStatement(node, context) {
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
         // Generate native name
         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,
                 },
             },
         });
@@ -475,13 +476,13 @@ export function visitSwitchStatement(node, context) {
             let condition = "";
             if (firstIf) {
                 condition =
-                    `(${fallthroughVar} || jspp::is_strictly_equal_to_primitive(${switchValueVar}, ${caseExprCode}))`;
+                    `(${fallthroughVar} || jspp::is_strictly_equal_to_native(${switchValueVar}, ${caseExprCode}))`;
                 code += `${this.indent()}if ${condition} {\n`;
                 firstIf = false;
             }
             else {
                 condition =
-                    `(${fallthroughVar} || jspp::is_strictly_equal_to_primitive(${switchValueVar}, ${caseExprCode}))`;
+                    `(${fallthroughVar} || jspp::is_strictly_equal_to_native(${switchValueVar}, ${caseExprCode}))`;
                 code += `${this.indent()}if ${condition} {\n`;
             }
             this.indentationLevel++;

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

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { RESERVED_VAR_NAMES } from "../../analysis/scope.js";
 import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function visitVariableDeclarationList(node, context) {
@@ -17,6 +18,9 @@ export function visitVariableDeclaration(node, context) {
         return this.generateDestructuring(varDecl.name, rhsCode, context);
     }
     const name = varDecl.name.getText();
+    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);
     // Mark the symbol as checked
@@ -34,7 +38,7 @@ export function visitVariableDeclaration(node, context) {
             const initTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, initScope);
             const varName = this.getJsVarName(initExpr);
             // Check if both target and initializer are heap allocated
-            if (typeInfo.needsHeapAllocation &&
+            if (typeInfo?.needsHeapAllocation &&
                 initTypeInfo?.needsHeapAllocation) {
                 shouldSkipDeref = true;
             }
@@ -49,12 +53,14 @@ 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)
                 ? varDecl.parent.parent.parent
                 : varDecl.parent;
+            const argumentKeywordIsUsed = ts.isFunctionExpression(initExpr) &&
+                this.isVariableUsedWithoutDeclaration("arguments", initExpr.body);
             // Mark before further visits
             context.localScopeSymbols.update(name, {
                 features: {
@@ -62,6 +68,7 @@ export function visitVariableDeclaration(node, context) {
                         type: "lambda",
                         name: nativeName,
                         parameters: this.validateFunctionParams(initExpr.parameters),
+                        argumentKeywordIsUsed,
                     },
                 },
             });
@@ -85,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
+        : (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) {
@@ -109,21 +128,21 @@ 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) {
+        if (typeInfo?.needsHeapAllocation) {
             return `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
         }
         else {

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

@@ -1,4 +1,6 @@
 import ts from "typescript";
+import { RESERVED_VAR_NAMES } from "../../analysis/scope.js";
+import { CompilerError } from "../error.js";
 import { visitObjectPropertyName } from "./expression-handlers.js";
 import { CodeGenerator } from "./index.js";
 import {} from "./visitor.js";
@@ -11,6 +13,9 @@ export function generateDestructuring(lhs, rhsCode, context) {
     const genAssignment = (pattern, valueCode) => {
         if (ts.isIdentifier(pattern)) {
             const name = pattern.text;
+            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);
             // Mark initialized if it's a declaration
@@ -103,7 +108,7 @@ export function generateDestructuring(lhs, rhsCode, context) {
             });
             // Call the return method to clean resources
             innerCode +=
-                `${this.indent()}jspp::Access::call_optional_property_with_optional_call(${iterVar}, "return", {}, "return");\n`;
+                `${this.indent()}jspp::Access::call_optional_property_with_optional_call(${iterVar}, "return", {});\n`;
             return innerCode;
         }
         else if (ts.isObjectBindingPattern(pattern) ||
@@ -150,9 +155,9 @@ export function generateDestructuring(lhs, rhsCode, context) {
                 }
                 if (isRest) {
                     const keysArray = `{${seenKeys.map((k) => k.startsWith('"') && k.endsWith('"')
-                        ? k
-                        : `(${k}).to_property_key()`).join(", ")}}`;
-                    const restValueCode = `jspp::Access::get_rest_object(${valueCode}, std::vector<std::string>${keysArray})`;
+                        ? `jspp::AnyValue::make_string(${k})`
+                        : `(${k})`).join(", ")}}`;
+                    const restValueCode = `jspp::Access::get_rest_object(${valueCode}, std::vector<jspp::AnyValue>${keysArray})`;
                     innerCode += genAssignment(target, restValueCode);
                 }
                 else {

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

@@ -84,11 +84,11 @@ export function visitObjectLiteralExpression(node, context) {
         ts.isMethodDeclaration(prop) || ts.isGetAccessor(prop) ||
         ts.isSetAccessor(prop) || ts.isSpreadAssignment(prop))) {
         // Empty object
-        return `jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"))`;
+        return `jspp::AnyValue::make_object({}).set_prototype(::Object.get_own_property("prototype"))`;
     }
     let code = `([&]() {\n`;
     code +=
-        `${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"));\n`;
+        `${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object({}).set_prototype(::Object.get_own_property("prototype"));\n`;
     this.indentationLevel++;
     for (const prop of properties) {
         if (ts.isPropertyAssignment(prop)) {
@@ -200,7 +200,7 @@ export function visitArrayLiteralExpression(node, context) {
         const elementsSpan = elements.length > 0
             ? `std::span<const jspp::AnyValue>((const jspp::AnyValue[]){${elementsJoined}}, ${elements.length})`
             : "std::span<const jspp::AnyValue>{}";
-        return `jspp::AnyValue::make_array_with_proto(${elementsSpan}, ::Array.get_own_property("prototype"))`;
+        return `jspp::AnyValue::make_array(${elementsSpan}).set_prototype(::Array.get_own_property("prototype"))`;
     }
     const arrVar = this.generateUniqueName("__arr_", this.getDeclaredSymbols(node));
     let code = `([&]() {\n`;
@@ -238,7 +238,7 @@ export function visitArrayLiteralExpression(node, context) {
     }
     this.indentationLevel--;
     code +=
-        `${this.indent()}  return jspp::AnyValue::make_array_with_proto(std::move(${arrVar}), ::Array.get_own_property("prototype"));\n`;
+        `${this.indent()}  return jspp::AnyValue::make_array(std::move(${arrVar})).set_prototype(::Array.get_own_property("prototype"));\n`;
     code += `${this.indent()}})()`;
     return code;
 }
@@ -254,7 +254,7 @@ export function visitPrefixUnaryExpression(node, context) {
             if (context.derefBeforeAssignment) {
                 target = this.getDerefCode(operand, operand, context, typeInfo);
             }
-            else if (typeInfo.needsHeapAllocation) {
+            else if (typeInfo?.needsHeapAllocation) {
                 target = `*${operand}`;
             }
         }
@@ -277,7 +277,7 @@ export function visitPrefixUnaryExpression(node, context) {
             if (context.derefBeforeAssignment) {
                 target = this.getDerefCode(operand, operand, context, typeInfo);
             }
-            else if (typeInfo.needsHeapAllocation) {
+            else if (typeInfo?.needsHeapAllocation) {
                 target = `*${operand}`;
             }
         }
@@ -296,7 +296,7 @@ export function visitPostfixUnaryExpression(node, context) {
         if (context.derefBeforeAssignment) {
             target = this.getDerefCode(operand, operand, context, typeInfo);
         }
-        else if (typeInfo.needsHeapAllocation) {
+        else if (typeInfo?.needsHeapAllocation) {
             target = `*${operand}`;
         }
     }
@@ -381,7 +381,6 @@ export function visitBinaryExpression(node, context) {
     const op = opToken.getText();
     const visitContext = {
         ...context,
-        supportedNativeLiterals: undefined,
     };
     const assignmentOperators = [
         ts.SyntaxKind.PlusEqualsToken,
@@ -409,7 +408,7 @@ export function visitBinaryExpression(node, context) {
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo.needsHeapAllocation
+                target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 return `${target} = jspp::unsigned_right_shift(${target}, ${rightText})`;
@@ -422,7 +421,7 @@ export function visitBinaryExpression(node, context) {
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo.needsHeapAllocation
+                target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 return `${target} = jspp::pow(${target}, ${rightText})`;
@@ -438,7 +437,7 @@ export function visitBinaryExpression(node, context) {
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo.needsHeapAllocation
+                target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
@@ -468,7 +467,7 @@ export function visitBinaryExpression(node, context) {
             if (context.derefBeforeAssignment) {
                 target = this.getDerefCode(leftText, leftText, visitContext, typeInfo);
             }
-            else if (typeInfo.needsHeapAllocation) {
+            else if (typeInfo?.needsHeapAllocation) {
                 target = `*${leftText}`;
             }
         }
@@ -575,7 +574,7 @@ export function visitBinaryExpression(node, context) {
         }
         const target = context.derefBeforeAssignment
             ? this.getDerefCode(leftText, leftText, visitContext, typeInfo)
-            : (typeInfo.needsHeapAllocation ? `*${leftText}` : leftText);
+            : (typeInfo?.needsHeapAllocation ? `*${leftText}` : leftText);
         // Update scope symbols on variable re-assignment
         // Reset features
         if (ts.isIdentifier(binExpr.left)) {
@@ -608,7 +607,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()`;
         }
     }
@@ -624,7 +624,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()`;
         }
     }
@@ -643,100 +644,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 = context.supportedNativeLiterals?.includes("boolean") || false;
     // 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
 }
@@ -744,10 +727,7 @@ export function visitConditionalExpression(node, context) {
     const condExpr = node;
     const isBinaryExpression = ts.isBinaryExpression(condExpr.condition) &&
         constants.booleanOperators.includes(condExpr.condition.operatorToken.kind);
-    const condition = this.visit(condExpr.condition, {
-        ...context,
-        supportedNativeLiterals: isBinaryExpression ? ["boolean"] : undefined,
-    });
+    const condition = this.visit(condExpr.condition, context);
     const whenTrueStmt = this.visit(condExpr.whenTrue, {
         ...context,
         isFunctionBody: false,
@@ -1023,6 +1003,7 @@ export function visitCallExpression(node, context) {
         if (nativeFeature && nativeFeature.type === "lambda") {
             const nativeName = nativeFeature.name;
             const parameters = nativeFeature.parameters || [];
+            const argumentKeywordIsUsed = nativeFeature.argumentKeywordIsUsed;
             if (!hasSpread) {
                 let argsPart = "";
                 if (parameters) {
@@ -1041,10 +1022,17 @@ export function visitCallExpression(node, context) {
                         .filter((_, i) => !parameters[i]?.dotDotDotToken).join(", ");
                     if (argsText)
                         argsPart += `, ${argsText}`;
-                    if (argsArray.length > parameters.length &&
+                    if (argsArray.length >= parameters.length &&
                         !!parameters[parameters.length - 1]?.dotDotDotToken) {
                         const restArgsText = `jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{${argsArray.slice(parameters.length - 1).join(", ")}})`;
-                        argsPart += `, ${restArgsText}`;
+                        argsPart += `, ${restArgsText}${argumentKeywordIsUsed ? `, ${argsArray.length}` : ""}`;
+                    }
+                    else if (argsArray.length > parameters.length &&
+                        argumentKeywordIsUsed) {
+                        const restArgsArray = argsArray.slice(parameters.length);
+                        const nativeRestArgsText = `std::span<const jspp::AnyValue>((const jspp::AnyValue[]){${restArgsArray.join(", ")}}, ${restArgsArray.length})`;
+                        argsPart +=
+                            `, ${argsArray.length}, ${nativeRestArgsText}`;
                     }
                 }
                 const callImplementation = `${nativeName}(jspp::Constants::UNDEFINED${argsPart})`;
@@ -1070,28 +1058,34 @@ export function visitCallExpression(node, context) {
                     if (!p)
                         continue;
                     if (p.dotDotDotToken) {
-                        callArgs.push(`jspp::AnyValue::make_array(std::vector<jspp::AnyValue>(${argsVar}.begin() + std::min((size_t)${i}, ${argsVar}.size()), ${argsVar}.end()))`);
+                        callArgs.push(`jspp::AnyValue::make_array(std::vector<jspp::AnyValue>(${argsVar}.begin() + std::min((std::size_t)${i}, ${argsVar}.size()), ${argsVar}.end()))`);
                     }
                     else {
                         callArgs.push(`(${argsVar}.size() > ${i} ? ${argsVar}[${i}] : jspp::Constants::UNDEFINED)`);
                     }
                 }
-                let callExprStr = `${nativeName}(jspp::Constants::UNDEFINED${callArgs.length > 0 ? ", " + callArgs.join(", ") : ""})`;
+                const callArgsPart = callArgs.length > 0
+                    ? `, ${callArgs.join(", ")}`
+                    : "";
+                const totalArgsSizePart = argumentKeywordIsUsed
+                    ? `, ${argsVar}.size()`
+                    : "";
+                let callImplementation = `${nativeName}(jspp::Constants::UNDEFINED${callArgsPart}${totalArgsSizePart})`;
                 if (symbol.features.isGenerator) {
                     if (symbol.features.isAsync) {
-                        callExprStr =
-                            `jspp::AnyValue::from_async_iterator(${callExprStr})`;
+                        callImplementation =
+                            `jspp::AnyValue::from_async_iterator(${callImplementation})`;
                     }
                     else {
-                        callExprStr =
-                            `jspp::AnyValue::from_iterator(${callExprStr})`;
+                        callImplementation =
+                            `jspp::AnyValue::from_iterator(${callImplementation})`;
                     }
                 }
                 else if (symbol.features.isAsync) {
-                    callExprStr =
-                        `jspp::AnyValue::from_promise(${callExprStr})`;
+                    callImplementation =
+                        `jspp::AnyValue::from_promise(${callImplementation})`;
                 }
-                code += `${this.indent()}return ${callExprStr};\n`;
+                code += `${this.indent()}return ${callImplementation};\n`;
                 this.indentationLevel--;
                 code += `${this.indent()}})()`;
                 return code;