@ugo-studio/jspp 0.2.5 → 0.2.7

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

@@ -1,5 +1,55 @@
 import ts from "typescript";
+import { constants } from "../constants.js";
+import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
+/**
+ * Helper to recursively flatten static spread elements in arrays or call arguments.
+ */
+function flattenArrayElements(elements) {
+    const flattened = [];
+    for (const elem of elements) {
+        if (elem && ts.isSpreadElement(elem)) {
+            const expr = elem.expression;
+            if (ts.isArrayLiteralExpression(expr)) {
+                flattened.push(...flattenArrayElements(expr.elements));
+            }
+            else if (ts.isStringLiteral(expr) ||
+                ts.isNoSubstitutionTemplateLiteral(expr)) {
+                for (const char of expr.text) {
+                    flattened.push(ts.factory.createStringLiteral(char));
+                }
+            }
+            else {
+                flattened.push({ dynamicSpread: expr });
+            }
+        }
+        else {
+            flattened.push(elem);
+        }
+    }
+    return flattened;
+}
+/**
+ * Helper to recursively flatten static spread assignments in object literals.
+ */
+function flattenObjectProperties(properties) {
+    const flattened = [];
+    for (const prop of properties) {
+        if (ts.isSpreadAssignment(prop)) {
+            const expr = prop.expression;
+            if (ts.isObjectLiteralExpression(expr)) {
+                flattened.push(...flattenObjectProperties(expr.properties));
+            }
+            else {
+                flattened.push(prop);
+            }
+        }
+        else {
+            flattened.push(prop);
+        }
+    }
+    return flattened;
+}
 export function visitObjectPropertyName(node, context) {
     if (ts.isNumericLiteral(node)) {
         return context.isBracketNotationPropertyAccess
@@ -27,11 +77,12 @@ export function visitObjectPropertyName(node, context) {
 }
 export function visitObjectLiteralExpression(node, context) {
     const obj = node;
+    const properties = flattenObjectProperties(obj.properties);
     const objVar = this.generateUniqueName("__obj_", this.getDeclaredSymbols(node));
-    if (!obj.properties.some((prop) => ts.isPropertyAssignment(prop) ||
+    if (!properties.some((prop) => ts.isPropertyAssignment(prop) ||
         ts.isShorthandPropertyAssignment(prop) ||
         ts.isMethodDeclaration(prop) || ts.isGetAccessor(prop) ||
-        ts.isSetAccessor(prop))) {
+        ts.isSetAccessor(prop) || ts.isSpreadAssignment(prop))) {
         // Empty object
         return `jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"))`;
     }
@@ -39,7 +90,7 @@ export function visitObjectLiteralExpression(node, context) {
     code +=
         `${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"));\n`;
     this.indentationLevel++;
-    for (const prop of obj.properties) {
+    for (const prop of properties) {
         if (ts.isPropertyAssignment(prop)) {
             const key = visitObjectPropertyName.call(this, prop.name, {
                 ...context,
@@ -76,10 +127,10 @@ export function visitObjectLiteralExpression(node, context) {
                 ...context,
                 isObjectLiteralExpression: true,
             });
-            const lambda = this.generateLambda(prop, {
+            const lambda = this.generateWrappedLambda(this.generateLambdaComponents(prop, {
                 ...context,
                 isInsideFunction: true,
-            });
+            }));
             code +=
                 `${this.indent()}${objVar}.define_data_property(${key}, ${lambda});\n`;
         }
@@ -88,10 +139,10 @@ export function visitObjectLiteralExpression(node, context) {
                 ...context,
                 isObjectLiteralExpression: true,
             });
-            const lambda = this.generateLambda(prop, {
+            const lambda = this.generateWrappedLambda(this.generateLambdaComponents(prop, {
                 ...context,
                 isInsideFunction: true,
-            });
+            }));
             code +=
                 `${this.indent()}${objVar}.define_getter(${key}, ${lambda});\n`;
         }
@@ -100,36 +151,96 @@ export function visitObjectLiteralExpression(node, context) {
                 ...context,
                 isObjectLiteralExpression: true,
             });
-            const lambda = this.generateLambda(prop, {
+            const lambda = this.generateWrappedLambda(this.generateLambdaComponents(prop, {
                 ...context,
                 isInsideFunction: true,
-            });
+            }));
             code +=
                 `${this.indent()}${objVar}.define_setter(${key}, ${lambda});\n`;
         }
+        else if (ts.isSpreadAssignment(prop)) {
+            let spreadExpr = this.visit(prop.expression, context);
+            if (ts.isIdentifier(prop.expression)) {
+                const scope = this.getScopeForNode(prop.expression);
+                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(prop.expression.text, scope);
+                if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
+                    spreadExpr = this.getDerefCode(spreadExpr, this.getJsVarName(prop.expression), context, typeInfo);
+                }
+            }
+            code +=
+                `${this.indent()}jspp::Access::spread_object(${objVar}, ${spreadExpr});\n`;
+        }
     }
     this.indentationLevel--;
     code += `${this.indent()}  return ${objVar};\n${this.indent()}})()`;
     return code;
 }
 export function visitArrayLiteralExpression(node, context) {
-    const elements = node.elements
-        .map((elem) => {
-        let elemText = this.visit(elem, context);
-        if (ts.isIdentifier(elem)) {
-            const scope = this.getScopeForNode(elem);
-            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elem.text, scope);
-            if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
-                elemText = this.getDerefCode(elemText, this.getJsVarName(elem), context, typeInfo);
+    const flattened = flattenArrayElements(node.elements);
+    const hasSpread = flattened.some((e) => typeof e === "object" && "dynamicSpread" in e);
+    if (!hasSpread) {
+        const elements = flattened
+            .map((elem) => {
+            const expr = elem;
+            let elemText = this.visit(expr, context);
+            if (ts.isIdentifier(expr)) {
+                const scope = this.getScopeForNode(expr);
+                const typeInfo = this.typeAnalyzer.scopeManager
+                    .lookupFromScope(expr.text, scope);
+                if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
+                    elemText = this.getDerefCode(elemText, this.getJsVarName(expr), context, typeInfo);
+                }
+            }
+            if (ts.isOmittedExpression(expr)) {
+                elemText = "jspp::Constants::UNINITIALIZED";
+            }
+            return elemText;
+        });
+        const elementsJoined = elements.join(", ");
+        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"))`;
+    }
+    const arrVar = this.generateUniqueName("__arr_", this.getDeclaredSymbols(node));
+    let code = `([&]() {\n`;
+    code += `${this.indent()}  std::vector<jspp::AnyValue> ${arrVar};\n`;
+    this.indentationLevel++;
+    for (const elem of flattened) {
+        if (typeof elem === "object" && "dynamicSpread" in elem) {
+            const spreadExprSource = elem.dynamicSpread;
+            let spreadExpr = this.visit(spreadExprSource, context);
+            if (ts.isIdentifier(spreadExprSource)) {
+                const scope = this.getScopeForNode(spreadExprSource);
+                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(spreadExprSource.text, scope);
+                if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
+                    spreadExpr = this.getDerefCode(spreadExpr, this.getJsVarName(spreadExprSource), context, typeInfo);
+                }
+            }
+            code +=
+                `${this.indent()}jspp::Access::spread_array(${arrVar}, ${spreadExpr});\n`;
+        }
+        else {
+            const expr = elem;
+            let elemText = this.visit(expr, context);
+            if (ts.isIdentifier(expr)) {
+                const scope = this.getScopeForNode(expr);
+                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
+                if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
+                    elemText = this.getDerefCode(elemText, this.getJsVarName(expr), context, typeInfo);
+                }
+            }
+            if (ts.isOmittedExpression(expr)) {
+                elemText = "jspp::Constants::UNINITIALIZED";
             }
+            code += `${this.indent()}${arrVar}.push_back(${elemText});\n`;
         }
-        return elemText;
-    });
-    const elementsJoined = elements.join(", ");
-    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"))`;
+    }
+    this.indentationLevel--;
+    code +=
+        `${this.indent()}  return jspp::AnyValue::make_array_with_proto(std::move(${arrVar}), ::Array.get_own_property("prototype"));\n`;
+    code += `${this.indent()}})()`;
+    return code;
 }
 export function visitPrefixUnaryExpression(node, context) {
     const prefixUnaryExpr = node;
@@ -149,6 +260,15 @@ export function visitPrefixUnaryExpression(node, context) {
         }
         return `${operator}(${target})`;
     }
+    if (operator === "+") {
+        return `jspp::plus(${operand})`;
+    }
+    if (operator === "-") {
+        return `jspp::negate(${operand})`;
+    }
+    if (operator === "!") {
+        return `jspp::logical_not(${operand})`;
+    }
     if (operator === "~") {
         let target = operand;
         if (ts.isIdentifier(prefixUnaryExpr.operand)) {
@@ -161,7 +281,7 @@ export function visitPrefixUnaryExpression(node, context) {
                 target = `*${operand}`;
             }
         }
-        return `${operator}(${target})`;
+        return `jspp::bitwise_not(${target})`;
     }
     return `${operator}${operand}`;
 }
@@ -190,7 +310,7 @@ export function visitPropertyAccessExpression(node, context) {
     const propAccess = node;
     if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
         if (!context.superClassVar) {
-            throw new Error("super.prop accessed but no super class variable found in context");
+            throw new CompilerError("super.prop accessed but no super class variable found in context", propAccess.expression, "SyntaxError");
         }
         const propName = propAccess.name.getText();
         return `jspp::AnyValue::resolve_property_for_read((${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}"), ${this.globalThisVar}, "${this.escapeString(propName)}")`;
@@ -213,7 +333,7 @@ export function visitPropertyAccessExpression(node, context) {
         finalExpr = this.getDerefCode(exprText, this.getJsVarName(propAccess.expression), context, typeInfo);
     }
     if (propAccess.questionDotToken) {
-        return `jspp::Access::optional_get_property(${finalExpr}, "${propName}")`;
+        return `jspp::Access::get_optional_property(${finalExpr}, "${propName}")`;
     }
     return `${finalExpr}.get_own_property("${propName}")`;
 }
@@ -251,14 +371,18 @@ export function visitElementAccessExpression(node, context) {
         }
     }
     if (elemAccess.questionDotToken) {
-        return `jspp::Access::optional_get_element(${finalExpr}, ${argText})`;
+        return `jspp::Access::get_optional_element(${finalExpr}, ${argText})`;
     }
     return `${finalExpr}.get_own_property(${argText})`;
 }
 export function visitBinaryExpression(node, context) {
     const binExpr = node;
     const opToken = binExpr.operatorToken;
-    let op = opToken.getText();
+    const op = opToken.getText();
+    const visitContext = {
+        ...context,
+        supportedNativeLiterals: undefined,
+    };
     const assignmentOperators = [
         ts.SyntaxKind.PlusEqualsToken,
         ts.SyntaxKind.MinusEqualsToken,
@@ -279,8 +403,8 @@ export function visitBinaryExpression(node, context) {
     if (assignmentOperators.includes(opToken.kind)) {
         if (opToken.kind ===
             ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            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);
@@ -292,8 +416,8 @@ export function visitBinaryExpression(node, context) {
             }
         }
         if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            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);
@@ -308,8 +432,8 @@ export function visitBinaryExpression(node, context) {
         if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
             opToken.kind === ts.SyntaxKind.BarBarEqualsToken ||
             opToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            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);
@@ -328,21 +452,21 @@ export function visitBinaryExpression(node, context) {
                 }
             }
         }
-        const leftText = this.visit(binExpr.left, context);
+        const leftText = this.visit(binExpr.left, visitContext);
         let rightText = ts.isNumericLiteral(binExpr.right)
             ? binExpr.right.getText()
-            : this.visit(binExpr.right, context);
+            : this.visit(binExpr.right, visitContext);
         if (ts.isIdentifier(binExpr.right)) {
             const scope = this.getScopeForNode(binExpr.right);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope);
-            rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, typeInfo);
+            rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
         let target = leftText;
         if (ts.isIdentifier(binExpr.left)) {
             const scope = this.getScopeForNode(binExpr.left);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.getText(), scope);
             if (context.derefBeforeAssignment) {
-                target = this.getDerefCode(leftText, leftText, context, typeInfo);
+                target = this.getDerefCode(leftText, leftText, visitContext, typeInfo);
             }
             else if (typeInfo.needsHeapAllocation) {
                 target = `*${leftText}`;
@@ -350,8 +474,9 @@ export function visitBinaryExpression(node, context) {
         }
         return `${target} ${op} ${rightText}`;
     }
+    // Assignment expression `a = 1`
     if (opToken.kind === ts.SyntaxKind.EqualsToken) {
-        let rightText = this.visit(binExpr.right, context);
+        let rightText = this.visit(binExpr.right, visitContext);
         if (ts.isPropertyAccessExpression(binExpr.left)) {
             const propAccess = binExpr.left;
             if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
@@ -365,13 +490,13 @@ export function visitBinaryExpression(node, context) {
                     if (rightTypeInfo &&
                         !rightTypeInfo.isParameter &&
                         !rightTypeInfo.isBuiltin) {
-                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
+                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, rightTypeInfo);
                     }
                 }
                 // Approximate super assignment as setting property on 'this'
                 return `(${this.globalThisVar}).set_own_property("${propName}", ${finalRightText})`;
             }
-            const objExprText = this.visit(propAccess.expression, context);
+            const objExprText = this.visit(propAccess.expression, visitContext);
             const propName = propAccess.name.getText();
             let finalObjExpr = objExprText;
             if (ts.isIdentifier(propAccess.expression)) {
@@ -396,14 +521,14 @@ export function visitBinaryExpression(node, context) {
         }
         else if (ts.isElementAccessExpression(binExpr.left)) {
             const elemAccess = binExpr.left;
-            const objExprText = this.visit(elemAccess.expression, context);
-            let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            const objExprText = this.visit(elemAccess.expression, visitContext);
+            let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...visitContext, isBracketNotationPropertyAccess: true });
             let finalObjExpr = objExprText;
             if (ts.isIdentifier(elemAccess.expression)) {
                 const scope = this.getScopeForNode(elemAccess.expression);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.expression.getText(), scope);
                 if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(elemAccess.expression), context, typeInfo);
+                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(elemAccess.expression), visitContext, typeInfo);
                 }
             }
             if (ts.isIdentifier(elemAccess.argumentExpression)) {
@@ -413,7 +538,7 @@ export function visitBinaryExpression(node, context) {
                 if (argTypeInfo &&
                     !argTypeInfo.isParameter &&
                     !argTypeInfo.isBuiltin) {
-                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), context, argTypeInfo);
+                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), visitContext, argTypeInfo);
                 }
             }
             let finalRightText = rightText;
@@ -424,12 +549,12 @@ export function visitBinaryExpression(node, context) {
                 if (rightTypeInfo &&
                     !rightTypeInfo.isParameter &&
                     !rightTypeInfo.isBuiltin) {
-                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
+                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, rightTypeInfo);
                 }
             }
             return `${finalObjExpr}.set_own_property(${argText}, ${finalRightText})`;
         }
-        const leftText = this.visit(binExpr.left, context);
+        const leftText = this.visit(binExpr.left, visitContext);
         const scope = this.getScopeForNode(binExpr.left);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
         if (!typeInfo && !this.isBuiltinObject(binExpr.left)) {
@@ -442,27 +567,29 @@ export function visitBinaryExpression(node, context) {
             rightText = binExpr.right.getText();
         }
         const target = context.derefBeforeAssignment
-            ? this.getDerefCode(leftText, leftText, context, typeInfo)
+            ? this.getDerefCode(leftText, leftText, visitContext, typeInfo)
             : (typeInfo.needsHeapAllocation ? `*${leftText}` : leftText);
         // Update scope symbols on variable re-assignment
+        // Reset features
         if (ts.isIdentifier(binExpr.left)) {
             if (!ts.isFunctionDeclaration(binExpr.right)) {
                 if (context.localScopeSymbols.has(binExpr.left.text)) {
-                    context.localScopeSymbols.update(binExpr.left.text, {
-                        func: null,
+                    context.localScopeSymbols.set(binExpr.left.text, {
+                        features: {},
                     });
                 }
                 else if (context.globalScopeSymbols.has(binExpr.left.text)) {
-                    context.globalScopeSymbols.update(binExpr.left.text, {
-                        func: null,
+                    context.globalScopeSymbols.set(binExpr.left.text, {
+                        features: {},
                     });
                 }
             }
         }
         return `${target} ${op} ${rightText}`;
     }
-    const leftText = this.visit(binExpr.left, context);
-    const rightText = this.visit(binExpr.right, context);
+    const leftText = this.visit(binExpr.left, visitContext);
+    const rightText = this.visit(binExpr.right, visitContext);
+    // Generate lhs and rhs code
     let finalLeft = leftText;
     if (ts.isIdentifier(binExpr.left)) {
         const scope = this.getScopeForNode(binExpr.left);
@@ -471,7 +598,11 @@ export function visitBinaryExpression(node, context) {
             return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(binExpr.left)})`;
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), context, typeInfo);
+            finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), visitContext, typeInfo);
+        }
+        // Number optimizations
+        if (typeInfo && typeInfo.type === "number") {
+            finalLeft = `${finalLeft}.as_double()`;
         }
     }
     let finalRight = rightText;
@@ -483,7 +614,11 @@ export function visitBinaryExpression(node, context) {
             return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(binExpr.right)})`;
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, typeInfo);
+            finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
+        }
+        // Number optimizations
+        if (typeInfo && typeInfo.type === "number") {
+            finalRight = `${finalRight}.as_double()`;
         }
     }
     if (opToken.kind === ts.SyntaxKind.InKeyword) {
@@ -501,52 +636,111 @@ export function visitBinaryExpression(node, context) {
     if (opToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
         return `jspp::nullish_coalesce(${finalLeft}, ${finalRight})`;
     }
-    // Optimizations to prevent calling make_number multiple times
-    if (ts.isNumericLiteral(binExpr.left)) {
-        finalLeft = binExpr.left.getText();
-    }
-    if (ts.isNumericLiteral(binExpr.right)) {
-        finalRight = binExpr.right.getText();
+    const isLiteral = (n) => ts.isNumericLiteral(n);
+    const supportsNativeBoolean = context.supportedNativeLiterals?.includes("boolean") || false;
+    // Native values for lhs and rhs
+    const literalLeft = isLiteral(binExpr.left)
+        ? binExpr.left.getText()
+        : finalLeft;
+    const literalRight = isLiteral(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";
+        }
+        // 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})`;
     }
+    // Return boxed value
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-        return `jspp::is_strictly_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::is_strictly_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-        return `jspp::is_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::is_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-        return `jspp::not_strictly_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::not_strictly_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        return `jspp::not_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::not_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskToken) {
-        return `jspp::pow(${finalLeft}, ${finalRight})`;
+        return `jspp::pow(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken) {
-        return `jspp::unsigned_right_shift(${finalLeft}, ${finalRight})`;
-    }
-    // Optimizations to prevent calling make_number multiple times
-    if (ts.isNumericLiteral(binExpr.left) && ts.isNumericLiteral(binExpr.right)) {
-        return `jspp::AnyValue::make_number(${finalLeft} ${op} ${finalRight})`;
-    }
-    if (op === "+" ||
-        op === "-" ||
-        op === "*" ||
-        op === "/" ||
-        op === "%" ||
-        op === "^" ||
-        op === "&" ||
-        op === "|" ||
-        op === "<<" ||
-        op === ">>") {
-        return `(${finalLeft} ${op} ${finalRight})`;
-    }
-    return `${finalLeft} ${op} ${finalRight}`;
+        return `jspp::unsigned_right_shift(${literalLeft}, ${literalRight})`;
+    }
+    // For other arithmetic and bitwise operations, use native operations if possible
+    switch (op) {
+        case "+":
+            return `jspp::add(${literalLeft}, ${literalRight})`;
+        case "-":
+            return `jspp::sub(${literalLeft}, ${literalRight})`;
+        case "*":
+            return `jspp::mul(${literalLeft}, ${literalRight})`;
+        case "/":
+            return `jspp::div(${literalLeft}, ${literalRight})`;
+        case "%":
+            return `jspp::mod(${literalLeft}, ${literalRight})`;
+        case "^":
+            return `jspp::bitwise_xor(${literalLeft}, ${literalRight})`;
+        case "&":
+            return `jspp::bitwise_and(${literalLeft}, ${literalRight})`;
+        case "|":
+            return `jspp::bitwise_or(${literalLeft}, ${literalRight})`;
+        case "<<":
+            return `jspp::left_shift(${literalLeft}, ${literalRight})`;
+        case ">>":
+            return `jspp::right_shift(${literalLeft}, ${literalRight})`;
+        case "<":
+            return `jspp::less_than(${literalLeft}, ${literalRight})`;
+        case ">":
+            return `jspp::greater_than(${literalLeft}, ${literalRight})`;
+        case "<=":
+            return `jspp::less_than_or_equal(${literalLeft}, ${literalRight})`;
+        case ">=":
+            return `jspp::greater_than_or_equal(${literalLeft}, ${literalRight})`;
+    }
+    return `/* Unhandled Operator: ${finalLeft} ${op} ${finalRight} */`; // Default fallback
 }
 export function visitConditionalExpression(node, context) {
     const condExpr = node;
-    const condition = this.visit(condExpr.condition, context);
+    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 whenTrueStmt = this.visit(condExpr.whenTrue, {
         ...context,
         isFunctionBody: false,
@@ -555,53 +749,147 @@ export function visitConditionalExpression(node, context) {
         ...context,
         isFunctionBody: false,
     });
+    if (isBinaryExpression) {
+        return `${condition} ? ${whenTrueStmt} : ${whenFalseStmt}`;
+    }
     return `jspp::is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
 }
 export function visitCallExpression(node, context) {
     const callExpr = node;
     const callee = callExpr.expression;
+    const flattened = flattenArrayElements(callExpr.arguments);
+    const hasSpread = flattened.some((e) => typeof e === "object" && "dynamicSpread" in e);
     if (callee.kind === ts.SyntaxKind.SuperKeyword) {
         if (!context.superClassVar) {
-            throw new Error("super() called but no super class variable found in context");
+            throw new CompilerError("super() called but no super class variable found in context", callee, "SyntaxError");
+        }
+        if (!hasSpread) {
+            const args = flattened.map((arg) => this.visit(arg, context))
+                .join(", ");
+            return `(${context.superClassVar}).call(${this.globalThisVar}, (const jspp::AnyValue[]){${args}}, "super")`;
+        }
+        else {
+            const argsVar = this.generateUniqueName("__args_", this.getDeclaredSymbols(node));
+            let code = `([&]() {\n`;
+            code +=
+                `${this.indent()}  std::vector<jspp::AnyValue> ${argsVar};\n`;
+            this.indentationLevel++;
+            for (const arg of flattened) {
+                if (typeof arg === "object" && "dynamicSpread" in arg) {
+                    const spreadExprSource = arg.dynamicSpread;
+                    let spreadExpr = this.visit(spreadExprSource, context);
+                    if (ts.isIdentifier(spreadExprSource)) {
+                        const scope = this.getScopeForNode(spreadExprSource);
+                        const typeInfo = this.typeAnalyzer.scopeManager
+                            .lookupFromScope(spreadExprSource.text, scope);
+                        spreadExpr = this.getDerefCode(spreadExpr, this.getJsVarName(spreadExprSource), context, typeInfo);
+                    }
+                    code +=
+                        `${this.indent()}jspp::Access::spread_array(${argsVar}, ${spreadExpr});\n`;
+                }
+                else {
+                    const expr = arg;
+                    let argText = this.visit(expr, context);
+                    if (ts.isIdentifier(expr)) {
+                        const scope = this.getScopeForNode(expr);
+                        const typeInfo = this.typeAnalyzer.scopeManager
+                            .lookupFromScope(expr.text, scope);
+                        argText = this.getDerefCode(argText, this.getJsVarName(expr), context, typeInfo);
+                    }
+                    code +=
+                        `${this.indent()}${argsVar}.push_back(${argText});\n`;
+                }
+            }
+            code +=
+                `${this.indent()}  return (${context.superClassVar}).call(${this.globalThisVar}, ${argsVar}, "super");\n`;
+            this.indentationLevel--;
+            code += `${this.indent()}})()`;
+            return code;
         }
-        const args = callExpr.arguments.map((arg) => this.visit(arg, context))
-            .join(", ");
-        return `(${context.superClassVar}).call(${this.globalThisVar}, (const jspp::AnyValue[]){${args}}, "super")`;
     }
-    const argsArray = callExpr.arguments
-        .map((arg) => {
-        const argText = this.visit(arg, context);
-        if (ts.isIdentifier(arg)) {
-            const scope = this.getScopeForNode(arg);
-            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(arg.text, scope);
-            if (!typeInfo) {
-                return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(arg)})`;
+    const generateArgsSpan = (args) => {
+        const argsArray = args
+            .map((arg) => {
+            const expr = arg;
+            const argText = this.visit(expr, context);
+            if (ts.isIdentifier(expr)) {
+                const scope = this.getScopeForNode(expr);
+                const typeInfo = this.typeAnalyzer.scopeManager
+                    .lookupFromScope(expr.text, scope);
+                if (!typeInfo) {
+                    return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)})`;
+                }
+                if (typeInfo && !typeInfo.isBuiltin) {
+                    return this.getDerefCode(argText, this.getJsVarName(expr), context, typeInfo);
+                }
+            }
+            return argText;
+        });
+        const argsJoined = argsArray.join(", ");
+        const argsCount = argsArray.length;
+        return argsCount > 0
+            ? `std::span<const jspp::AnyValue>((const jspp::AnyValue[]){${argsJoined}}, ${argsCount})`
+            : "std::span<const jspp::AnyValue>{}";
+    };
+    const generateArgsVectorBuilder = (args, argsVar) => {
+        let code = `${this.indent()}std::vector<jspp::AnyValue> ${argsVar};\n`;
+        for (const arg of args) {
+            if (typeof arg === "object" && "dynamicSpread" in arg) {
+                const spreadExprSource = arg.dynamicSpread;
+                let spreadExpr = this.visit(spreadExprSource, context);
+                if (ts.isIdentifier(spreadExprSource)) {
+                    const scope = this.getScopeForNode(spreadExprSource);
+                    const typeInfo = this.typeAnalyzer.scopeManager
+                        .lookupFromScope(spreadExprSource.text, scope);
+                    if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
+                        spreadExpr = this.getDerefCode(spreadExpr, this.getJsVarName(spreadExprSource), context, typeInfo);
+                    }
+                }
+                code +=
+                    `${this.indent()}jspp::Access::spread_array(${argsVar}, ${spreadExpr});\n`;
             }
-            if (typeInfo && !typeInfo.isBuiltin) {
-                return this.getDerefCode(argText, this.getJsVarName(arg), context, typeInfo);
+            else {
+                const expr = arg;
+                let argText = this.visit(expr, context);
+                if (ts.isIdentifier(expr)) {
+                    const scope = this.getScopeForNode(expr);
+                    const typeInfo = this.typeAnalyzer.scopeManager
+                        .lookupFromScope(expr.text, scope);
+                    if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
+                        argText = this.getDerefCode(argText, this.getJsVarName(expr), context, typeInfo);
+                    }
+                }
+                code += `${this.indent()}${argsVar}.push_back(${argText});\n`;
             }
         }
-        return argText;
-    });
-    const args = argsArray.join(", ");
-    const argsCount = argsArray.length;
-    const argsSpan = argsCount > 0
-        ? `std::span<const jspp::AnyValue>((const jspp::AnyValue[]){${args}}, ${argsCount})`
-        : "std::span<const jspp::AnyValue>{}";
-    // Handle obj.method() -> pass obj as 'this'
+        return code;
+    };
     if (ts.isPropertyAccessExpression(callee)) {
         const propAccess = callee;
         if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
             if (!context.superClassVar) {
-                throw new Error("super.method() called but no super class variable found in context");
+                throw new CompilerError("super.method() called but no super class variable found in context", propAccess.expression, "SyntaxError");
             }
             const propName = propAccess.name.getText();
-            return `(${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}").call(${this.globalThisVar}, ${argsSpan}, "${this.escapeString(propName)}")`;
+            if (!hasSpread) {
+                const argsSpan = generateArgsSpan(flattened);
+                return `(${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}").call(${this.globalThisVar}, ${argsSpan}, "${this.escapeString(propName)}")`;
+            }
+            else {
+                const argsVar = this.generateUniqueName("__args_", this.getDeclaredSymbols(node));
+                let code = `([&]() {\n`;
+                this.indentationLevel++;
+                code += generateArgsVectorBuilder(flattened, argsVar);
+                code +=
+                    `${this.indent}return (${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}").call(${this.globalThisVar}, ${argsVar}, "${this.escapeString(propName)}");\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}})()`;
+                return code;
+            }
         }
         const objExpr = propAccess.expression;
         const propName = propAccess.name.getText();
         const objCode = this.visit(objExpr, context);
-        // We need to dereference the object expression if it's a variable
         let derefObj = objCode;
         if (ts.isIdentifier(objExpr)) {
             const scope = this.getScopeForNode(objExpr);
@@ -613,12 +901,37 @@ export function visitCallExpression(node, context) {
                 derefObj = this.getDerefCode(objCode, this.getJsVarName(objExpr), context, typeInfo);
             }
         }
-        if (callExpr.questionDotToken) {
-            return `jspp::Access::optional_call(${derefObj}.get_own_property("${propName}"), ${derefObj}, ${argsSpan}, "${this.escapeString(propName)}")`;
+        if (!hasSpread) {
+            const argsSpan = generateArgsSpan(flattened);
+            if (propAccess.questionDotToken) {
+                const method = callExpr.questionDotToken
+                    ? "jspp::Access::call_optional_property_with_optional_call"
+                    : "jspp::Access::call_optional_property";
+                return `${method}(${derefObj}, "${propName}", ${argsSpan}, "${this.escapeString(propName)}")`;
+            }
+            return `${derefObj}.call_own_property("${propName}", ${argsSpan})`;
+        }
+        else {
+            const argsVar = this.generateUniqueName("__args_", this.getDeclaredSymbols(node));
+            let code = `([&]() {\n`;
+            this.indentationLevel++;
+            code += generateArgsVectorBuilder(flattened, argsVar);
+            if (propAccess.questionDotToken) {
+                const method = callExpr.questionDotToken
+                    ? "jspp::Access::call_optional_property_with_optional_call"
+                    : "jspp::Access::call_optional_property";
+                code +=
+                    `${this.indent()}return ${method}(${derefObj}, "${propName}", ${argsVar}, "${this.escapeString(propName)}");\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}return ${derefObj}.call_own_property("${propName}", ${argsVar});\n`;
+            }
+            this.indentationLevel--;
+            code += `${this.indent()}})()`;
+            return code;
         }
-        return `${derefObj}.call_own_property("${propName}", ${argsSpan})`;
     }
-    // Handle obj[method]() -> pass obj as 'this'
     if (ts.isElementAccessExpression(callee)) {
         const elemAccess = callee;
         const objExpr = elemAccess.expression;
@@ -635,7 +948,6 @@ export function visitCallExpression(node, context) {
             }
         }
         let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
-        // Dereference argument if needed (logic copied from visitElementAccessExpression)
         if (ts.isIdentifier(elemAccess.argumentExpression)) {
             const argScope = this.getScopeForNode(elemAccess.argumentExpression);
             const argTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.argumentExpression.getText(), argScope);
@@ -648,39 +960,135 @@ export function visitCallExpression(node, context) {
                 argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), context, argTypeInfo);
             }
         }
-        if (callExpr.questionDotToken) {
-            return `jspp::Access::optional_call(${derefObj}.get_own_property(${argText}), ${derefObj}, ${argsSpan})`;
+        if (!hasSpread) {
+            const argsSpan = generateArgsSpan(flattened);
+            if (elemAccess.questionDotToken) {
+                const method = callExpr.questionDotToken
+                    ? "jspp::Access::call_optional_property_with_optional_call"
+                    : "jspp::Access::call_optional_property";
+                return `${method}(${derefObj}, ${argText}, ${argsSpan})`;
+            }
+            return `${derefObj}.call_own_property(${argText}, ${argsSpan})`;
+        }
+        else {
+            const argsVar = this.generateUniqueName("__args_", this.getDeclaredSymbols(node));
+            let code = `([&]() {\n`;
+            this.indentationLevel++;
+            code += generateArgsVectorBuilder(flattened, argsVar);
+            if (elemAccess.questionDotToken) {
+                const method = callExpr.questionDotToken
+                    ? "jspp::Access::call_optional_property_with_optional_call"
+                    : "jspp::Access::call_optional_property";
+                code +=
+                    `${this.indent()}return ${method}(${derefObj}, ${argText}, ${argsVar});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}return ${derefObj}.call_own_property(${argText}, ${argsVar});\n`;
+            }
+            this.indentationLevel--;
+            code += `${this.indent()}})()`;
+            return code;
         }
-        return `${derefObj}.call_own_property(${argText}, ${argsSpan})`;
     }
     const calleeCode = this.visit(callee, context);
     let derefCallee = calleeCode;
+    let calleeTypeInfo = null;
     if (ts.isIdentifier(callee)) {
         const scope = this.getScopeForNode(callee);
-        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(callee.text, scope);
-        if (!typeInfo && !this.isBuiltinObject(callee)) {
+        calleeTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(callee.text, scope);
+        if (!calleeTypeInfo && !this.isBuiltinObject(callee)) {
             return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(callee)})`;
         }
-        if (typeInfo?.isBuiltin) {
+        if (calleeTypeInfo?.isBuiltin) {
             derefCallee = calleeCode;
         }
-        else if (typeInfo) {
-            const name = callee.getText();
-            const symbol = context.localScopeSymbols.get(name) ??
-                context.globalScopeSymbols.get(name);
-            // Optimization: Direct lambda call
-            if (symbol && symbol.func?.nativeName) {
-                const callExpr = `${symbol.func.nativeName}(jspp::Constants::UNDEFINED, ${argsSpan})`;
-                if (symbol.func.isGenerator) {
-                    if (symbol.func.isAsync) {
-                        return `jspp::AnyValue::from_async_iterator(${callExpr})`;
+        else if (calleeTypeInfo) {
+            derefCallee = this.getDerefCode(calleeCode, this.getJsVarName(callee), context, calleeTypeInfo);
+        }
+    }
+    // Direct native lamda if available
+    if (ts.isIdentifier(callee) && calleeTypeInfo) {
+        const name = callee.getText();
+        const symbol = context.localScopeSymbols.get(name) ??
+            context.globalScopeSymbols.get(name);
+        const nativeFeature = symbol?.features?.native;
+        if (nativeFeature && nativeFeature.type === "lambda") {
+            const nativeName = nativeFeature.name;
+            const parameters = nativeFeature.parameters || [];
+            if (!hasSpread) {
+                let argsPart = "";
+                if (parameters) {
+                    const argsArray = flattened.map((arg) => {
+                        const expr = arg;
+                        let argText = this.visit(expr, context);
+                        if (ts.isIdentifier(expr)) {
+                            const scope = this.getScopeForNode(expr);
+                            const typeInfo = this.typeAnalyzer.scopeManager
+                                .lookupFromScope(expr.text, scope);
+                            argText = this.getDerefCode(argText, this.getJsVarName(expr), context, typeInfo);
+                        }
+                        return argText;
+                    });
+                    const argsText = argsArray.slice(0, parameters.length)
+                        .filter((_, i) => !parameters[i]?.dotDotDotToken).join(", ");
+                    if (argsText)
+                        argsPart += `, ${argsText}`;
+                    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}`;
+                    }
+                }
+                const callImplementation = `${nativeName}(jspp::Constants::UNDEFINED${argsPart})`;
+                if (symbol.features.isGenerator) {
+                    if (symbol.features.isAsync) {
+                        return `jspp::AnyValue::from_async_iterator(${callImplementation})`;
                     }
-                    return `jspp::AnyValue::from_iterator(${callExpr})`;
+                    return `jspp::AnyValue::from_iterator(${callImplementation})`;
                 }
-                return callExpr;
+                if (symbol.features.isAsync) {
+                    return `jspp::AnyValue::from_promise(${callImplementation})`;
+                }
+                return callImplementation;
+            }
+            else {
+                const argsVar = this.generateUniqueName("__args_", this.getDeclaredSymbols(node));
+                let code = `([&]() {\n`;
+                this.indentationLevel++;
+                code += generateArgsVectorBuilder(flattened, argsVar);
+                const callArgs = [];
+                for (let i = 0; i < parameters.length; i++) {
+                    const p = parameters[i];
+                    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()))`);
+                    }
+                    else {
+                        callArgs.push(`(${argsVar}.size() > ${i} ? ${argsVar}[${i}] : jspp::Constants::UNDEFINED)`);
+                    }
+                }
+                let callExprStr = `${nativeName}(jspp::Constants::UNDEFINED${callArgs.length > 0 ? ", " + callArgs.join(", ") : ""})`;
+                if (symbol.features.isGenerator) {
+                    if (symbol.features.isAsync) {
+                        callExprStr =
+                            `jspp::AnyValue::from_async_iterator(${callExprStr})`;
+                    }
+                    else {
+                        callExprStr =
+                            `jspp::AnyValue::from_iterator(${callExprStr})`;
+                    }
+                }
+                else if (symbol.features.isAsync) {
+                    callExprStr =
+                        `jspp::AnyValue::from_promise(${callExprStr})`;
+                }
+                code += `${this.indent()}return ${callExprStr};\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}})()`;
+                return code;
             }
-            // AnyValue function call
-            derefCallee = this.getDerefCode(calleeCode, this.getJsVarName(callee), context, typeInfo);
         }
     }
     let calleeName = "";
@@ -692,14 +1100,33 @@ export function visitCallExpression(node, context) {
         const funcExpr = callee.expression;
         calleeName = this.escapeString(funcExpr.name?.getText() || "");
     }
-    // Pass undefined as 'this' for normal function calls
     const calleeNamePart = calleeName && calleeName.length > 0
         ? `, "${calleeName}"`
         : "";
-    if (callExpr.questionDotToken) {
-        return `jspp::Access::optional_call(${derefCallee}, jspp::Constants::UNDEFINED, ${argsSpan}${calleeNamePart})`;
+    if (!hasSpread) {
+        const argsSpan = generateArgsSpan(flattened);
+        if (callExpr.questionDotToken) {
+            return `${derefCallee}.optional_call(jspp::Constants::UNDEFINED, ${argsSpan}${calleeNamePart})`;
+        }
+        return `${derefCallee}.call(jspp::Constants::UNDEFINED, ${argsSpan}${calleeNamePart})`;
+    }
+    else {
+        const argsVar = this.generateUniqueName("__args_", this.getDeclaredSymbols(node));
+        let code = `([&]() {\n`;
+        this.indentationLevel++;
+        code += generateArgsVectorBuilder(flattened, argsVar);
+        if (callExpr.questionDotToken) {
+            code +=
+                `${this.indent()}return ${derefCallee}.optional_call(jspp::Constants::UNDEFINED, ${argsVar}${calleeNamePart});\n`;
+        }
+        else {
+            code +=
+                `${this.indent()}return ${derefCallee}.call(jspp::Constants::UNDEFINED, ${argsVar}${calleeNamePart});\n`;
+        }
+        this.indentationLevel--;
+        code += `${this.indent()}})()`;
+        return code;
     }
-    return `${derefCallee}.call(jspp::Constants::UNDEFINED, ${argsSpan}${calleeNamePart})`;
 }
 export function visitVoidExpression(node, context) {
     const voidExpr = node;
@@ -725,9 +1152,9 @@ export function visitTemplateExpression(node, context) {
                 finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
         }
-        result += ` + (${finalExpr})`;
+        result = `jspp::add(${result}, ${finalExpr})`;
         if (span.literal.text) {
-            result += ` + jspp::AnyValue::make_string("${this.escapeString(span.literal.text)}")`;
+            result = `jspp::add(${result}, jspp::AnyValue::make_string("${this.escapeString(span.literal.text)}"))`;
         }
     }
     return result;
@@ -735,6 +1162,8 @@ export function visitTemplateExpression(node, context) {
 export function visitNewExpression(node, context) {
     const newExpr = node;
     const exprText = this.visit(newExpr.expression, context);
+    const flattened = flattenArrayElements(newExpr.arguments || []);
+    const hasSpread = flattened.some((e) => typeof e === "object" && "dynamicSpread" in e);
     let derefExpr = exprText;
     let name = `"${exprText}"`;
     if (ts.isIdentifier(newExpr.expression)) {
@@ -749,30 +1178,77 @@ export function visitNewExpression(node, context) {
             derefExpr = this.getDerefCode(exprText, name, context, typeInfo);
         }
     }
-    const argsArray = newExpr.arguments
-        ? newExpr.arguments
+    if (!hasSpread) {
+        const argsArray = flattened
             .map((arg) => {
-            const argText = this.visit(arg, context);
-            if (ts.isIdentifier(arg)) {
-                const scope = this.getScopeForNode(arg);
+            const expr = arg;
+            const argText = this.visit(expr, context);
+            if (ts.isIdentifier(expr)) {
+                const scope = this.getScopeForNode(expr);
                 const typeInfo = this.typeAnalyzer.scopeManager
-                    .lookupFromScope(arg.text, scope);
+                    .lookupFromScope(expr.text, scope);
                 if (!typeInfo) {
-                    return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(arg)})`;
+                    return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)})`;
                 }
-                if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                    return this.getDerefCode(argText, this.getJsVarName(arg), context, typeInfo);
+                if (typeInfo && !typeInfo.isParameter &&
+                    !typeInfo.isBuiltin) {
+                    return this.getDerefCode(argText, this.getJsVarName(expr), context, typeInfo);
                 }
             }
             return argText;
-        })
-        : [];
-    const args = argsArray.join(", ");
-    const argsCount = argsArray.length;
-    const argsSpan = argsCount > 0
-        ? `std::span<const jspp::AnyValue>((const jspp::AnyValue[]){${args}}, ${argsCount})`
-        : "std::span<const jspp::AnyValue>{}";
-    return `${derefExpr}.construct(${argsSpan}, ${name})`;
+        });
+        const args = argsArray.join(", ");
+        const argsCount = argsArray.length;
+        const argsSpan = argsCount > 0
+            ? `std::span<const jspp::AnyValue>((const jspp::AnyValue[]){${args}}, ${argsCount})`
+            : "std::span<const jspp::AnyValue>{}";
+        return `${derefExpr}.construct(${argsSpan}, ${name})`;
+    }
+    else {
+        const argsVar = this.generateUniqueName("__args_", this.getDeclaredSymbols(node));
+        let code = `([&]() {\n`;
+        this.indentationLevel++;
+        code += `${this.indent()}std::vector<jspp::AnyValue> ${argsVar};\n`;
+        if (newExpr.arguments) {
+            for (const arg of flattened) {
+                if (typeof arg === "object" && "dynamicSpread" in arg) {
+                    const spreadExprSource = arg.dynamicSpread;
+                    let spreadExpr = this.visit(spreadExprSource, context);
+                    if (ts.isIdentifier(spreadExprSource)) {
+                        const scope = this.getScopeForNode(spreadExprSource);
+                        const typeInfo = this.typeAnalyzer.scopeManager
+                            .lookupFromScope(spreadExprSource.text, scope);
+                        if (typeInfo && !typeInfo.isBuiltin &&
+                            !typeInfo.isParameter) {
+                            spreadExpr = this.getDerefCode(spreadExpr, this.getJsVarName(spreadExprSource), context, typeInfo);
+                        }
+                    }
+                    code +=
+                        `${this.indent()}jspp::Access::spread_array(${argsVar}, ${spreadExpr});\n`;
+                }
+                else {
+                    const expr = arg;
+                    let argText = this.visit(expr, context);
+                    if (ts.isIdentifier(expr)) {
+                        const scope = this.getScopeForNode(expr);
+                        const typeInfo = this.typeAnalyzer.scopeManager
+                            .lookupFromScope(expr.text, scope);
+                        if (typeInfo && !typeInfo.isBuiltin &&
+                            !typeInfo.isParameter) {
+                            argText = this.getDerefCode(argText, this.getJsVarName(expr), context, typeInfo);
+                        }
+                    }
+                    code +=
+                        `${this.indent()}${argsVar}.push_back(${argText});\n`;
+                }
+            }
+        }
+        code +=
+            `${this.indent()}  return ${derefExpr}.construct(${argsVar}, ${name});\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}})()`;
+        return code;
+    }
 }
 export function visitTypeOfExpression(node, context) {
     const typeOfExpr = node;
@@ -827,3 +1303,15 @@ export function visitDeleteExpression(node, context) {
     }
     return "jspp::Constants::TRUE"; // delete on non-property is true in JS
 }
+export function visitAsExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitTypeAssertionExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitNonNullExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitSatisfiesExpression(node, context) {
+    return this.visit(node.expression, context);
+}