@ugo-studio/jspp 0.1.4 → 0.1.5

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

@@ -11,6 +11,8 @@ export function visitVariableDeclaration(node, context) {
     const name = varDecl.name.getText();
     const scope = this.getScopeForNode(varDecl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+    // Mark the symbol as checked
+    this.markSymbolAsChecked(name, context.topLevelScopeSymbols, context.localScopeSymbols);
     let initializer = "";
     if (varDecl.initializer) {
         const initExpr = varDecl.initializer;
@@ -18,7 +20,9 @@ export function visitVariableDeclaration(node, context) {
             ...context,
             lambdaName: ts.isArrowFunction(initExpr) ? name : undefined, // Pass the variable name for arrow functions
         };
-        let initText = this.visit(initExpr, initContext);
+        let initText = ts.isNumericLiteral(initExpr)
+            ? initExpr.getText()
+            : this.visit(initExpr, initContext);
         if (ts.isIdentifier(initExpr)) {
             const initScope = this.getScopeForNode(initExpr);
             const initTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, initScope);
@@ -26,21 +30,21 @@ export function visitVariableDeclaration(node, context) {
             if (initTypeInfo &&
                 !initTypeInfo.isParameter &&
                 !initTypeInfo.isBuiltin) {
-                initText = this.getDerefCode(initText, varName, initTypeInfo);
+                initText = this.getDerefCode(initText, varName, initContext, initTypeInfo);
             }
         }
         initializer = " = " + initText;
     }
     const isLetOrConst = (varDecl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
     const shouldDeref = context.derefBeforeAssignment &&
-        (!context.currentScopeSymbols.has(name));
+        (!context.localScopeSymbols.has(name));
     const assignmentTarget = shouldDeref
-        ? this.getDerefCode(name, name, typeInfo)
+        ? this.getDerefCode(name, name, context, typeInfo)
         : (typeInfo.needsHeapAllocation ? `*${name}` : name);
     if (isLetOrConst) {
         // If there's no initializer, it should be assigned undefined.
         if (!initializer) {
-            return `${assignmentTarget} = jspp::AnyValue::make_undefined()`;
+            return `${assignmentTarget} = jspp::Constants::UNDEFINED`;
         }
         return `${assignmentTarget}${initializer}`;
     }
@@ -55,7 +59,7 @@ export function visitVariableDeclaration(node, context) {
         // but is kept for safety.
         const initValue = initializer
             ? initializer.substring(3)
-            : "jspp::AnyValue::make_undefined()";
+            : "jspp::Constants::UNDEFINED";
         if (typeInfo.needsHeapAllocation) {
             return `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
         }

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

@@ -16,7 +16,7 @@ export function visitObjectPropertyName(node, context) {
         if (ts.isIdentifier(compExpr)) {
             const scope = this.getScopeForNode(compExpr);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(compExpr.getText(), scope);
-            propName = this.getDerefCode(propName, this.getJsVarName(compExpr), typeInfo);
+            propName = this.getDerefCode(propName, this.getJsVarName(compExpr), context, typeInfo);
         }
         return propName;
     }
@@ -29,7 +29,7 @@ export function visitObjectLiteralExpression(node, context) {
     const obj = node;
     const objVar = this.generateUniqueName("__obj_", this.getDeclaredSymbols(node));
     let code = `([&]() {
-${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object({});\n`;
+${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"));\n`;
     this.indentationLevel++;
     for (const prop of obj.properties) {
         if (ts.isPropertyAssignment(prop)) {
@@ -43,7 +43,7 @@ ${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object({});\n`;
                 const scope = this.getScopeForNode(initializer);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initializer.text, scope);
                 if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
-                    value = this.getDerefCode(value, this.getJsVarName(initializer), typeInfo);
+                    value = this.getDerefCode(value, this.getJsVarName(initializer), context, typeInfo);
                 }
             }
             code +=
@@ -58,7 +58,7 @@ ${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object({});\n`;
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(prop.name.text, scope);
             let value = this.visit(prop.name, context);
             if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
-                value = this.getDerefCode(value, this.getJsVarName(prop.name), typeInfo);
+                value = this.getDerefCode(value, this.getJsVarName(prop.name), context, typeInfo);
             }
             code +=
                 `${this.indent()}${objVar}.define_data_property(${key}, ${value});\n`;
@@ -112,13 +112,16 @@ export function visitArrayLiteralExpression(node, context) {
             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), typeInfo);
+                elemText = this.getDerefCode(elemText, this.getJsVarName(elem), context, typeInfo);
             }
         }
         return elemText;
-    })
-        .join(", ");
-    return `jspp::AnyValue::make_array({${elements}})`;
+    });
+    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"))`;
 }
 export function visitPrefixUnaryExpression(node, context) {
     const prefixUnaryExpr = node;
@@ -130,7 +133,7 @@ export function visitPrefixUnaryExpression(node, context) {
             const scope = this.getScopeForNode(prefixUnaryExpr.operand);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(prefixUnaryExpr.operand.getText(), scope);
             if (context.derefBeforeAssignment) {
-                target = this.getDerefCode(operand, operand, typeInfo);
+                target = this.getDerefCode(operand, operand, context, typeInfo);
             }
             else if (typeInfo.needsHeapAllocation) {
                 target = `*${operand}`;
@@ -144,7 +147,7 @@ export function visitPrefixUnaryExpression(node, context) {
             const scope = this.getScopeForNode(prefixUnaryExpr.operand);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(prefixUnaryExpr.operand.getText(), scope);
             if (context.derefBeforeAssignment) {
-                target = this.getDerefCode(operand, operand, typeInfo);
+                target = this.getDerefCode(operand, operand, context, typeInfo);
             }
             else if (typeInfo.needsHeapAllocation) {
                 target = `*${operand}`;
@@ -163,7 +166,7 @@ export function visitPostfixUnaryExpression(node, context) {
         const scope = this.getScopeForNode(postfixUnaryExpr.operand);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(postfixUnaryExpr.operand.getText(), scope);
         if (context.derefBeforeAssignment) {
-            target = this.getDerefCode(operand, operand, typeInfo);
+            target = this.getDerefCode(operand, operand, context, typeInfo);
         }
         else if (typeInfo.needsHeapAllocation) {
             target = `*${operand}`;
@@ -199,7 +202,10 @@ export function visitPropertyAccessExpression(node, context) {
         !typeInfo.isParameter &&
         !typeInfo.isBuiltin &&
         ts.isIdentifier(propAccess.expression)) {
-        finalExpr = this.getDerefCode(exprText, this.getJsVarName(propAccess.expression), typeInfo);
+        finalExpr = this.getDerefCode(exprText, this.getJsVarName(propAccess.expression), context, typeInfo);
+    }
+    if (propAccess.questionDotToken) {
+        return `jspp::Access::optional_get_property(${finalExpr}, "${propName}")`;
     }
     return `${finalExpr}.get_own_property("${propName}")`;
 }
@@ -221,7 +227,7 @@ export function visitElementAccessExpression(node, context) {
         !exprTypeInfo.isParameter &&
         !exprTypeInfo.isBuiltin &&
         ts.isIdentifier(elemAccess.expression)) {
-        finalExpr = this.getDerefCode(exprText, this.getJsVarName(elemAccess.expression), exprTypeInfo);
+        finalExpr = this.getDerefCode(exprText, this.getJsVarName(elemAccess.expression), context, exprTypeInfo);
     }
     // Dereference the argument expression if it's an identifier
     if (ts.isIdentifier(elemAccess.argumentExpression)) {
@@ -233,9 +239,12 @@ export function visitElementAccessExpression(node, context) {
         if (argTypeInfo &&
             !argTypeInfo.isParameter &&
             !argTypeInfo.isBuiltin) {
-            argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), argTypeInfo);
+            argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), context, argTypeInfo);
         }
     }
+    if (elemAccess.questionDotToken) {
+        return `jspp::Access::optional_get_element(${finalExpr}, ${argText})`;
+    }
     return `${finalExpr}.get_own_property(${argText})`;
 }
 export function visitBinaryExpression(node, context) {
@@ -248,21 +257,84 @@ export function visitBinaryExpression(node, context) {
         ts.SyntaxKind.AsteriskEqualsToken,
         ts.SyntaxKind.SlashEqualsToken,
         ts.SyntaxKind.PercentEqualsToken,
+        ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+        ts.SyntaxKind.LessThanLessThanEqualsToken,
+        ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+        ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+        ts.SyntaxKind.AmpersandEqualsToken,
+        ts.SyntaxKind.BarEqualsToken,
+        ts.SyntaxKind.CaretEqualsToken,
+        ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+        ts.SyntaxKind.BarBarEqualsToken,
+        ts.SyntaxKind.QuestionQuestionEqualsToken,
     ];
     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);
+            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::unsigned_right_shift(${target}, ${rightText})`;
+            }
+        }
+        if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
+            const leftText = this.visit(binExpr.left, context);
+            const rightText = this.visit(binExpr.right, context);
+            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})`;
+            }
+            // 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, context);
+            const rightText = this.visit(binExpr.right, context);
+            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;
+                if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
+                    return `jspp::logical_and_assign(${target}, ${rightText})`;
+                }
+                else if (opToken.kind === ts.SyntaxKind.BarBarEqualsToken) {
+                    return `jspp::logical_or_assign(${target}, ${rightText})`;
+                }
+                else {
+                    return `jspp::nullish_coalesce_assign(${target}, ${rightText})`;
+                }
+            }
+        }
         const leftText = this.visit(binExpr.left, context);
-        let rightText = this.visit(binExpr.right, context);
+        let rightText = ts.isNumericLiteral(binExpr.right)
+            ? binExpr.right.getText()
+            : this.visit(binExpr.right, context);
         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), typeInfo);
+            rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, 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, typeInfo);
+                target = this.getDerefCode(leftText, leftText, context, typeInfo);
             }
             else if (typeInfo.needsHeapAllocation) {
                 target = `*${leftText}`;
@@ -271,7 +343,7 @@ export function visitBinaryExpression(node, context) {
         return `${target} ${op} ${rightText}`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsToken) {
-        const rightText = this.visit(binExpr.right, context);
+        let rightText = this.visit(binExpr.right, context);
         if (ts.isPropertyAccessExpression(binExpr.left)) {
             const propAccess = binExpr.left;
             if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
@@ -285,7 +357,7 @@ export function visitBinaryExpression(node, context) {
                     if (rightTypeInfo &&
                         !rightTypeInfo.isParameter &&
                         !rightTypeInfo.isBuiltin) {
-                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), rightTypeInfo);
+                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
                     }
                 }
                 // Approximate super assignment as setting property on 'this'
@@ -298,7 +370,7 @@ export function visitBinaryExpression(node, context) {
                 const scope = this.getScopeForNode(propAccess.expression);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(propAccess.expression.getText(), scope);
                 if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(propAccess.expression), typeInfo);
+                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(propAccess.expression), context, typeInfo);
                 }
             }
             let finalRightText = rightText;
@@ -309,7 +381,7 @@ export function visitBinaryExpression(node, context) {
                 if (rightTypeInfo &&
                     !rightTypeInfo.isParameter &&
                     !rightTypeInfo.isBuiltin) {
-                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), rightTypeInfo);
+                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
                 }
             }
             return `${finalObjExpr}.set_own_property("${propName}", ${finalRightText})`;
@@ -323,7 +395,7 @@ export function visitBinaryExpression(node, context) {
                 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), typeInfo);
+                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(elemAccess.expression), context, typeInfo);
                 }
             }
             if (ts.isIdentifier(elemAccess.argumentExpression)) {
@@ -333,7 +405,7 @@ export function visitBinaryExpression(node, context) {
                 if (argTypeInfo &&
                     !argTypeInfo.isParameter &&
                     !argTypeInfo.isBuiltin) {
-                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), argTypeInfo);
+                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), context, argTypeInfo);
                 }
             }
             let finalRightText = rightText;
@@ -344,7 +416,7 @@ export function visitBinaryExpression(node, context) {
                 if (rightTypeInfo &&
                     !rightTypeInfo.isParameter &&
                     !rightTypeInfo.isBuiltin) {
-                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), rightTypeInfo);
+                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
                 }
             }
             return `${finalObjExpr}.set_own_property(${argText}, ${finalRightText})`;
@@ -358,8 +430,11 @@ export function visitBinaryExpression(node, context) {
         if (typeInfo?.isConst) {
             return `jspp::Exception::throw_immutable_assignment()`;
         }
+        if (ts.isNumericLiteral(binExpr.right)) {
+            rightText = binExpr.right.getText();
+        }
         const target = context.derefBeforeAssignment
-            ? this.getDerefCode(leftText, leftText, typeInfo)
+            ? this.getDerefCode(leftText, leftText, context, typeInfo)
             : (typeInfo.needsHeapAllocation ? `*${leftText}` : leftText);
         return `${target} ${op} ${rightText}`;
     }
@@ -373,7 +448,7 @@ 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), typeInfo);
+            finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), context, typeInfo);
         }
     }
     let finalRight = rightText;
@@ -385,24 +460,53 @@ 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), typeInfo);
+            finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, typeInfo);
         }
     }
+    if (opToken.kind === ts.SyntaxKind.InKeyword) {
+        return `jspp::Access::in(${finalLeft}, ${finalRight})`;
+    }
+    if (opToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
+        return `jspp::Access::instance_of(${finalLeft}, ${finalRight})`;
+    }
+    if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        return `jspp::logical_and(${finalLeft}, ${finalRight})`;
+    }
+    if (opToken.kind === ts.SyntaxKind.BarBarToken) {
+        return `jspp::logical_or(${finalLeft}, ${finalRight})`;
+    }
+    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();
+    }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-        return `${finalLeft}.is_strictly_equal_to(${finalRight})`;
+        return `jspp::is_strictly_equal_to(${finalLeft}, ${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-        return `${finalLeft}.is_equal_to(${finalRight})`;
+        return `jspp::is_equal_to(${finalLeft}, ${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-        return `${finalLeft}.not_strictly_equal_to(${finalRight})`;
+        return `jspp::not_strictly_equal_to(${finalLeft}, ${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        return `${finalLeft}.not_equal_to(${finalRight})`;
+        return `jspp::not_equal_to(${finalLeft}, ${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskToken) {
         return `jspp::pow(${finalLeft}, ${finalRight})`;
     }
+    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 === "*" ||
@@ -410,7 +514,9 @@ export function visitBinaryExpression(node, context) {
         op === "%" ||
         op === "^" ||
         op === "&" ||
-        op === "|") {
+        op === "|" ||
+        op === "<<" ||
+        op === ">>") {
         return `(${finalLeft} ${op} ${finalRight})`;
     }
     return `${finalLeft} ${op} ${finalRight}`;
@@ -426,7 +532,7 @@ export function visitConditionalExpression(node, context) {
         ...context,
         isFunctionBody: false,
     });
-    return `(${condition}).is_truthy() ? ${whenTrueStmt} : ${whenFalseStmt}`;
+    return `is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
 }
 export function visitCallExpression(node, context) {
     const callExpr = node;
@@ -437,9 +543,9 @@ export function visitCallExpression(node, context) {
         }
         const args = callExpr.arguments.map((arg) => this.visit(arg, context))
             .join(", ");
-        return `(${context.superClassVar}).as_function("super")->call(${this.globalThisVar}, {${args}})`;
+        return `(${context.superClassVar}).call(${this.globalThisVar}, (const jspp::AnyValue[]){${args}}, "super")`;
     }
-    const args = callExpr.arguments
+    const argsArray = callExpr.arguments
         .map((arg) => {
         const argText = this.visit(arg, context);
         if (ts.isIdentifier(arg)) {
@@ -448,13 +554,17 @@ export function visitCallExpression(node, context) {
             if (!typeInfo) {
                 return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(arg)})`;
             }
-            if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                return this.getDerefCode(argText, this.getJsVarName(arg), typeInfo);
+            if (typeInfo && !typeInfo.isBuiltin) {
+                return this.getDerefCode(argText, this.getJsVarName(arg), context, typeInfo);
             }
         }
         return argText;
-    })
-        .join(", ");
+    });
+    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'
     if (ts.isPropertyAccessExpression(callee)) {
         const propAccess = callee;
@@ -463,7 +573,7 @@ export function visitCallExpression(node, context) {
                 throw new Error("super.method() called but no super class variable found in context");
             }
             const propName = propAccess.name.getText();
-            return `(${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}").as_function("${this.escapeString(propName)}")->call(${this.globalThisVar}, {${args}})`;
+            return `(${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}").call(${this.globalThisVar}, ${argsSpan}, "${this.escapeString(propName)}")`;
         }
         const objExpr = propAccess.expression;
         const propName = propAccess.name.getText();
@@ -477,10 +587,13 @@ export function visitCallExpression(node, context) {
                 return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(objExpr)})`;
             }
             if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
-                derefObj = this.getDerefCode(objCode, this.getJsVarName(objExpr), typeInfo);
+                derefObj = this.getDerefCode(objCode, this.getJsVarName(objExpr), context, typeInfo);
             }
         }
-        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property("${propName}").as_function("${this.escapeString(propName)}")->call(__obj, {${args}}); })()`;
+        if (callExpr.questionDotToken) {
+            return `jspp::Access::optional_call(${derefObj}.get_own_property("${propName}"), ${derefObj}, ${argsSpan}, "${this.escapeString(propName)}")`;
+        }
+        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property("${propName}").call(__obj, ${argsSpan}, "${this.escapeString(propName)}"); })()`;
     }
     // Handle obj[method]() -> pass obj as 'this'
     if (ts.isElementAccessExpression(callee)) {
@@ -495,7 +608,7 @@ export function visitCallExpression(node, context) {
                 return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(objExpr)})`;
             }
             if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
-                derefObj = this.getDerefCode(objCode, this.getJsVarName(objExpr), typeInfo);
+                derefObj = this.getDerefCode(objCode, this.getJsVarName(objExpr), context, typeInfo);
             }
         }
         let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
@@ -509,10 +622,13 @@ export function visitCallExpression(node, context) {
             }
             if (argTypeInfo && !argTypeInfo.isParameter &&
                 !argTypeInfo.isBuiltin) {
-                argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), argTypeInfo);
+                argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), context, argTypeInfo);
             }
         }
-        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property(${argText}).as_function()->call(__obj, {${args}}); })()`;
+        if (callExpr.questionDotToken) {
+            return `jspp::Access::optional_call(${derefObj}.get_own_property(${argText}), ${derefObj}, ${argsSpan})`;
+        }
+        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property(${argText}).call(__obj, ${argsSpan}); })()`;
     }
     const calleeCode = this.visit(callee, context);
     let derefCallee = calleeCode;
@@ -526,7 +642,7 @@ export function visitCallExpression(node, context) {
             derefCallee = calleeCode;
         }
         else if (typeInfo) {
-            derefCallee = this.getDerefCode(calleeCode, this.getJsVarName(callee), typeInfo);
+            derefCallee = this.getDerefCode(calleeCode, this.getJsVarName(callee), context, typeInfo);
         }
     }
     let calleeName = "";
@@ -539,12 +655,18 @@ export function visitCallExpression(node, context) {
         calleeName = this.escapeString(funcExpr.name?.getText() || "");
     }
     // Pass undefined as 'this' for normal function calls
-    return `${derefCallee}.as_function("${calleeName}")->call(jspp::AnyValue::make_undefined(), {${args}})`;
+    const calleeNamePart = calleeName && calleeName.length > 0
+        ? `, "${calleeName}"`
+        : "";
+    if (callExpr.questionDotToken) {
+        return `jspp::Access::optional_call(${derefCallee}, jspp::Constants::UNDEFINED, ${argsSpan}${calleeNamePart})`;
+    }
+    return `${derefCallee}.call(jspp::Constants::UNDEFINED, ${argsSpan}${calleeNamePart})`;
 }
 export function visitVoidExpression(node, context) {
     const voidExpr = node;
     const exprText = this.visit(voidExpr.expression, context);
-    return `(${exprText}, jspp::AnyValue::make_undefined())`;
+    return `(${exprText}, jspp::Constants::UNDEFINED)`;
 }
 export function visitTemplateExpression(node, context) {
     const templateExpr = node;
@@ -562,7 +684,7 @@ export function visitTemplateExpression(node, context) {
             else if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), typeInfo);
+                finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
         }
         result += ` + (${finalExpr})`;
@@ -576,18 +698,20 @@ export function visitNewExpression(node, context) {
     const newExpr = node;
     const exprText = this.visit(newExpr.expression, context);
     let derefExpr = exprText;
+    let name = `"${exprText}"`;
     if (ts.isIdentifier(newExpr.expression)) {
+        name = this.getJsVarName(newExpr.expression);
         const scope = this.getScopeForNode(newExpr.expression);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(newExpr.expression.getText(), scope);
         if (!typeInfo &&
             !this.isBuiltinObject(newExpr.expression)) {
-            return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(newExpr.expression)})`;
+            return `jspp::Exception::throw_unresolved_reference(${name})`;
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            derefExpr = this.getDerefCode(exprText, this.getJsVarName(newExpr.expression), typeInfo);
+            derefExpr = this.getDerefCode(exprText, name, context, typeInfo);
         }
     }
-    const args = newExpr.arguments
+    const argsArray = newExpr.arguments
         ? newExpr.arguments
             .map((arg) => {
             const argText = this.visit(arg, context);
@@ -599,14 +723,18 @@ export function visitNewExpression(node, context) {
                     return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(arg)})`;
                 }
                 if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                    return this.getDerefCode(argText, this.getJsVarName(arg), typeInfo);
+                    return this.getDerefCode(argText, this.getJsVarName(arg), context, typeInfo);
                 }
             }
             return argText;
         })
-            .join(", ")
-        : "";
-    return `${derefExpr}.construct({${args}})`;
+        : [];
+    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})`;
 }
 export function visitTypeOfExpression(node, context) {
     const typeOfExpr = node;
@@ -620,10 +748,10 @@ export function visitTypeOfExpression(node, context) {
             derefExpr = `/* undeclared variable: ${this.getJsVarName(typeOfExpr.expression)} */`; // typeof undeclared variable is 'undefined'
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            derefExpr = this.getDerefCode(exprText, this.getJsVarName(typeOfExpr.expression), typeInfo);
+            derefExpr = this.getDerefCode(exprText, this.getJsVarName(typeOfExpr.expression), context, typeInfo);
         }
     }
-    return `jspp::Access::typeof(${derefExpr})`;
+    return `jspp::Access::type_of(${derefExpr})`;
 }
 export function visitAwaitExpression(node, context) {
     const awaitExpr = node;
@@ -639,11 +767,25 @@ export function visitAwaitExpression(node, context) {
             // We can just throw before co_await.
             // But we need to return a string expression.
             // Using comma operator: (throw..., AnyValue())
-            return `(jspp::Exception::throw_unresolved_reference(${this.getJsVarName(awaitExpr.expression)}), co_await jspp::AnyValue::make_undefined())`;
+            return `(jspp::Exception::throw_unresolved_reference(${this.getJsVarName(awaitExpr.expression)}), co_await jspp::Constants::UNDEFINED)`;
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            derefExpr = this.getDerefCode(exprText, this.getJsVarName(awaitExpr.expression), typeInfo);
+            derefExpr = this.getDerefCode(exprText, this.getJsVarName(awaitExpr.expression), context, typeInfo);
         }
     }
     return `co_await ${derefExpr}`;
 }
+export function visitDeleteExpression(node, context) {
+    const expr = node.expression;
+    if (ts.isPropertyAccessExpression(expr)) {
+        const obj = this.visit(expr.expression, context);
+        const prop = `jspp::AnyValue::make_string("${expr.name.getText()}")`;
+        return `jspp::Access::delete_property(${obj}, ${prop})`;
+    }
+    else if (ts.isElementAccessExpression(expr)) {
+        const obj = this.visit(expr.expression, context);
+        const prop = this.visit(expr.argumentExpression, context);
+        return `jspp::Access::delete_property(${obj}, ${prop})`;
+    }
+    return "jspp::Constants::TRUE"; // delete on non-property is true in JS
+}