@ugo-studio/jspp 0.1.3 → 0.1.5

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

@@ -1,64 +1,159 @@
 import ts from "typescript";
 import { CodeGenerator } from "./";
-function visitObjectPropertyName(node, context) {
+export function visitObjectPropertyName(node, context) {
     if (ts.isNumericLiteral(node)) {
-        return node.getText();
+        return context.isBracketNotationPropertyAccess
+            ? node.getText()
+            : `"${node.getText()}"`;
     }
-    else if (ts.isStringLiteral(node)) {
+    if (ts.isStringLiteral(node)) {
         return `"${node.getText().substring(1, node.getText().length - 1) // remove trailing "' from original name
         }"`;
     }
-    else if (ts.isComputedPropertyName(node)) {
-        let name = ts.isIdentifier(node.expression)
-            ? `jspp::Access::deref(${node.expression.getText()},${this.getJsVarName(node.expression)})`
-            : this.visit(node.expression, context);
-        name += ".to_std_string()";
-        return name;
+    if (ts.isComputedPropertyName(node)) {
+        const compExpr = node.expression;
+        let propName = this.visit(compExpr, 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), context, typeInfo);
+        }
+        return propName;
     }
-    else if (context.isPropertyNameAccess) {
+    if (context.isBracketNotationPropertyAccess) {
         return this.visit(node, context);
     }
-    else {
-        return `"${node.getText()}"`;
-    }
+    return `"${node.getText()}"`;
 }
 export function visitObjectLiteralExpression(node, context) {
     const obj = node;
-    let props = "";
+    const objVar = this.generateUniqueName("__obj_", this.getDeclaredSymbols(node));
+    let 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) {
-        // console.log("Property kind:", ts.SyntaxKind[prop.kind]);
         if (ts.isPropertyAssignment(prop)) {
-            const key = visitObjectPropertyName.call(this, prop.name, context);
-            const value = ts.isIdentifier(prop.initializer)
-                ? `jspp::Access::deref(${this.visit(prop.initializer, context)}, ${this.getJsVarName(prop.initializer)})`
-                : this.visit(prop.initializer, context);
-            props += `{${key}, ${value}},`;
+            const key = visitObjectPropertyName.call(this, prop.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const initializer = prop.initializer;
+            let value = this.visit(initializer, context);
+            if (ts.isIdentifier(initializer)) {
+                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), context, typeInfo);
+                }
+            }
+            code +=
+                `${this.indent()}${objVar}.define_data_property(${key}, ${value});\n`;
         }
         else if (ts.isShorthandPropertyAssignment(prop)) {
-            const key = visitObjectPropertyName.call(this, prop.name, context);
-            const value = `jspp::Access::deref(${this.visit(prop.name, context)}, ${this.getJsVarName(prop.name)})`;
-            props += `{${key}, ${value}},`;
+            const key = visitObjectPropertyName.call(this, prop.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const scope = this.getScopeForNode(prop.name);
+            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), context, typeInfo);
+            }
+            code +=
+                `${this.indent()}${objVar}.define_data_property(${key}, ${value});\n`;
+        }
+        else if (ts.isMethodDeclaration(prop)) {
+            const key = visitObjectPropertyName.call(this, prop.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const lambda = this.generateLambda(prop, {
+                ...context,
+                isInsideFunction: true,
+            });
+            code +=
+                `${this.indent()}${objVar}.define_data_property(${key}, ${lambda});\n`;
+        }
+        else if (ts.isGetAccessor(prop)) {
+            const key = visitObjectPropertyName.call(this, prop.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const lambda = this.generateLambda(prop, {
+                ...context,
+                isInsideFunction: true,
+            });
+            code +=
+                `${this.indent()}${objVar}.define_getter(${key}, ${lambda});\n`;
+        }
+        else if (ts.isSetAccessor(prop)) {
+            const key = visitObjectPropertyName.call(this, prop.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const lambda = this.generateLambda(prop, {
+                ...context,
+                isInsideFunction: true,
+            });
+            code +=
+                `${this.indent()}${objVar}.define_setter(${key}, ${lambda});\n`;
         }
     }
-    return `jspp::AnyValue::make_object({${props}})`;
+    this.indentationLevel--;
+    code += `${this.indent()}  return ${objVar};\n${this.indent()}})()`;
+    return code;
 }
 export function visitArrayLiteralExpression(node, context) {
     const elements = node.elements
-        .map((elem) => ts.isIdentifier(elem)
-        ? `jspp::Access::deref(${this.visit(elem, context)}, ${this.getJsVarName(elem)})`
-        : this.visit(elem, context))
-        .join(", ");
-    return `jspp::AnyValue::make_array({${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);
+            }
+        }
+        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"))`;
 }
 export function visitPrefixUnaryExpression(node, context) {
     const prefixUnaryExpr = node;
     const operand = this.visit(prefixUnaryExpr.operand, context);
     const operator = ts.tokenToString(prefixUnaryExpr.operator);
     if (operator === "++" || operator === "--") {
-        return `${operator}(*${operand})`;
+        let target = operand;
+        if (ts.isIdentifier(prefixUnaryExpr.operand)) {
+            const scope = this.getScopeForNode(prefixUnaryExpr.operand);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(prefixUnaryExpr.operand.getText(), scope);
+            if (context.derefBeforeAssignment) {
+                target = this.getDerefCode(operand, operand, context, typeInfo);
+            }
+            else if (typeInfo.needsHeapAllocation) {
+                target = `*${operand}`;
+            }
+        }
+        return `${operator}(${target})`;
     }
     if (operator === "~") {
-        return `${operator}(*${operand})`;
+        let target = operand;
+        if (ts.isIdentifier(prefixUnaryExpr.operand)) {
+            const scope = this.getScopeForNode(prefixUnaryExpr.operand);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(prefixUnaryExpr.operand.getText(), scope);
+            if (context.derefBeforeAssignment) {
+                target = this.getDerefCode(operand, operand, context, typeInfo);
+            }
+            else if (typeInfo.needsHeapAllocation) {
+                target = `*${operand}`;
+            }
+        }
+        return `${operator}(${target})`;
     }
     return `${operator}${operand}`;
 }
@@ -66,7 +161,18 @@ export function visitPostfixUnaryExpression(node, context) {
     const postfixUnaryExpr = node;
     const operand = this.visit(postfixUnaryExpr.operand, context);
     const operator = ts.tokenToString(postfixUnaryExpr.operator);
-    return `(*${operand})${operator}`;
+    let target = operand;
+    if (ts.isIdentifier(postfixUnaryExpr.operand)) {
+        const scope = this.getScopeForNode(postfixUnaryExpr.operand);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(postfixUnaryExpr.operand.getText(), scope);
+        if (context.derefBeforeAssignment) {
+            target = this.getDerefCode(operand, operand, context, typeInfo);
+        }
+        else if (typeInfo.needsHeapAllocation) {
+            target = `*${operand}`;
+        }
+    }
+    return `(${target})${operator}`;
 }
 export function visitParenthesizedExpression(node, context) {
     const parenExpr = node;
@@ -74,6 +180,13 @@ export function visitParenthesizedExpression(node, context) {
 }
 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");
+        }
+        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)}")`;
+    }
     const exprText = this.visit(propAccess.expression, context);
     const propName = propAccess.name.getText();
     const scope = this.getScopeForNode(propAccess.expression);
@@ -82,21 +195,24 @@ export function visitPropertyAccessExpression(node, context) {
         : null;
     if (ts.isIdentifier(propAccess.expression) && !typeInfo &&
         !this.isBuiltinObject(propAccess.expression)) {
-        return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(propAccess.expression)})`;
+        return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(propAccess.expression)})`;
     }
-    let finalExpr = "";
-    if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-        finalExpr = `jspp::Access::deref(${exprText}, ${this.getJsVarName(propAccess.expression)})`;
+    let finalExpr = exprText;
+    if (typeInfo &&
+        !typeInfo.isParameter &&
+        !typeInfo.isBuiltin &&
+        ts.isIdentifier(propAccess.expression)) {
+        finalExpr = this.getDerefCode(exprText, this.getJsVarName(propAccess.expression), context, typeInfo);
     }
-    else {
-        finalExpr = exprText;
+    if (propAccess.questionDotToken) {
+        return `jspp::Access::optional_get_property(${finalExpr}, "${propName}")`;
     }
     return `${finalExpr}.get_own_property("${propName}")`;
 }
 export function visitElementAccessExpression(node, context) {
     const elemAccess = node;
     const exprText = this.visit(elemAccess.expression, context);
-    let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isPropertyNameAccess: true });
+    let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
     // Dereference the expression being accessed
     const exprScope = this.getScopeForNode(elemAccess.expression);
     const exprTypeInfo = ts.isIdentifier(elemAccess.expression)
@@ -104,50 +220,159 @@ export function visitElementAccessExpression(node, context) {
         : null;
     if (ts.isIdentifier(elemAccess.expression) && !exprTypeInfo &&
         !this.isBuiltinObject(elemAccess.expression)) {
-        return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(elemAccess.expression)})`;
+        return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(elemAccess.expression)})`;
+    }
+    let finalExpr = exprText;
+    if (exprTypeInfo &&
+        !exprTypeInfo.isParameter &&
+        !exprTypeInfo.isBuiltin &&
+        ts.isIdentifier(elemAccess.expression)) {
+        finalExpr = this.getDerefCode(exprText, this.getJsVarName(elemAccess.expression), context, exprTypeInfo);
     }
-    const finalExpr = exprTypeInfo && !exprTypeInfo.isParameter && !exprTypeInfo.isBuiltin
-        ? `jspp::Access::deref(${exprText}, ${this.getJsVarName(elemAccess.expression)})`
-        : exprText;
     // Dereference the argument expression if it's an identifier
     if (ts.isIdentifier(elemAccess.argumentExpression)) {
         const argScope = this.getScopeForNode(elemAccess.argumentExpression);
         const argTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.argumentExpression.getText(), argScope);
         if (!argTypeInfo && !this.isBuiltinObject(elemAccess.argumentExpression)) {
-            return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(elemAccess.argumentExpression)})`;
+            return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(elemAccess.argumentExpression)})`;
         }
-        if (argTypeInfo && !argTypeInfo.isParameter && !argTypeInfo.isBuiltin) {
-            argText = `jspp::Access::deref(${argText}, ${this.getJsVarName(elemAccess.argumentExpression)})`;
+        if (argTypeInfo &&
+            !argTypeInfo.isParameter &&
+            !argTypeInfo.isBuiltin) {
+            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) {
     const binExpr = node;
     const opToken = binExpr.operatorToken;
     let op = opToken.getText();
-    if (opToken.kind === ts.SyntaxKind.PlusEqualsToken ||
-        opToken.kind === ts.SyntaxKind.MinusEqualsToken ||
-        opToken.kind === ts.SyntaxKind.AsteriskEqualsToken ||
-        opToken.kind === ts.SyntaxKind.SlashEqualsToken ||
-        opToken.kind === ts.SyntaxKind.PercentEqualsToken) {
+    const assignmentOperators = [
+        ts.SyntaxKind.PlusEqualsToken,
+        ts.SyntaxKind.MinusEqualsToken,
+        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);
-        const rightText = this.visit(binExpr.right, context);
-        return `*${leftText} ${op} ${rightText}`;
+        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), 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, context, typeInfo);
+            }
+            else if (typeInfo.needsHeapAllocation) {
+                target = `*${leftText}`;
+            }
+        }
+        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) {
+                const propName = propAccess.name.getText();
+                let finalRightText = rightText;
+                // Deref right text logic...
+                if (ts.isIdentifier(binExpr.right)) {
+                    const rightScope = this.getScopeForNode(binExpr.right);
+                    const rightTypeInfo = this.typeAnalyzer.scopeManager
+                        .lookupFromScope(binExpr.right.getText(), rightScope);
+                    if (rightTypeInfo &&
+                        !rightTypeInfo.isParameter &&
+                        !rightTypeInfo.isBuiltin) {
+                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, 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 propName = propAccess.name.getText();
-            const scope = this.getScopeForNode(propAccess.expression);
-            const typeInfo = ts.isIdentifier(propAccess.expression)
-                ? this.typeAnalyzer.scopeManager.lookupFromScope(propAccess.expression.getText(), scope)
-                : null;
-            const finalObjExpr = typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin
-                ? `jspp::Access::deref(${objExprText}, ${this.getJsVarName(propAccess.expression)})`
-                : objExprText;
+            let finalObjExpr = objExprText;
+            if (ts.isIdentifier(propAccess.expression)) {
+                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), context, typeInfo);
+                }
+            }
             let finalRightText = rightText;
             if (ts.isIdentifier(binExpr.right)) {
                 const rightScope = this.getScopeForNode(binExpr.right);
@@ -156,23 +381,23 @@ export function visitBinaryExpression(node, context) {
                 if (rightTypeInfo &&
                     !rightTypeInfo.isParameter &&
                     !rightTypeInfo.isBuiltin) {
-                    finalRightText = `jspp::Access::deref(${rightText}, ${this.getJsVarName(binExpr.right)})`;
+                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
                 }
             }
             return `${finalObjExpr}.set_own_property("${propName}", ${finalRightText})`;
-            // return `${finalObjExpr}["${propName}"] = ${finalRightText}`;
         }
         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, isPropertyNameAccess: true });
-            const scope = this.getScopeForNode(elemAccess.expression);
-            const typeInfo = ts.isIdentifier(elemAccess.expression)
-                ? this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.expression.getText(), scope)
-                : null;
-            const finalObjExpr = typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin
-                ? `jspp::Access::deref(${objExprText}, ${this.getJsVarName(elemAccess.expression)})`
-                : objExprText;
+            let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, 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);
+                }
+            }
             if (ts.isIdentifier(elemAccess.argumentExpression)) {
                 const argScope = this.getScopeForNode(elemAccess.argumentExpression);
                 const argTypeInfo = this.typeAnalyzer.scopeManager
@@ -180,7 +405,7 @@ export function visitBinaryExpression(node, context) {
                 if (argTypeInfo &&
                     !argTypeInfo.isParameter &&
                     !argTypeInfo.isBuiltin) {
-                    argText = `jspp::Access::deref(${argText}, ${this.getJsVarName(elemAccess.argumentExpression)})`;
+                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), context, argTypeInfo);
                 }
             }
             let finalRightText = rightText;
@@ -191,65 +416,97 @@ export function visitBinaryExpression(node, context) {
                 if (rightTypeInfo &&
                     !rightTypeInfo.isParameter &&
                     !rightTypeInfo.isBuiltin) {
-                    finalRightText = `jspp::Access::deref(${rightText}, ${this.getJsVarName(binExpr.right)})`;
+                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
                 }
             }
             return `${finalObjExpr}.set_own_property(${argText}, ${finalRightText})`;
-            // return `${finalObjExpr}[${argText}] = ${finalRightText}`;
         }
         const leftText = this.visit(binExpr.left, context);
         const scope = this.getScopeForNode(binExpr.left);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
         if (!typeInfo && !this.isBuiltinObject(binExpr.left)) {
-            return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(binExpr.left)})`;
+            return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(binExpr.left)})`;
         }
         if (typeInfo?.isConst) {
-            return `jspp::RuntimeError::throw_immutable_assignment_error()`;
+            return `jspp::Exception::throw_immutable_assignment()`;
+        }
+        if (ts.isNumericLiteral(binExpr.right)) {
+            rightText = binExpr.right.getText();
         }
-        return `*${leftText} ${op} ${rightText}`;
+        const target = context.derefBeforeAssignment
+            ? this.getDerefCode(leftText, leftText, context, typeInfo)
+            : (typeInfo.needsHeapAllocation ? `*${leftText}` : leftText);
+        return `${target} ${op} ${rightText}`;
     }
     const leftText = this.visit(binExpr.left, context);
     const rightText = this.visit(binExpr.right, context);
-    const leftIsIdentifier = ts.isIdentifier(binExpr.left);
-    const rightIsIdentifier = ts.isIdentifier(binExpr.right);
-    const scope = this.getScopeForNode(node);
-    const leftTypeInfo = leftIsIdentifier
-        ? this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.getText(), scope)
-        : null;
-    const rightTypeInfo = rightIsIdentifier
-        ? this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope)
-        : null;
-    const finalLeft = leftIsIdentifier && leftTypeInfo && !leftTypeInfo.isParameter &&
-        !leftTypeInfo.isBuiltin
-        ? `jspp::Access::deref(${leftText}, ${this.getJsVarName(binExpr.left)})`
-        : leftText;
-    const finalRight = rightIsIdentifier && rightTypeInfo && !rightTypeInfo.isParameter &&
-        !rightTypeInfo.isBuiltin
-        ? `jspp::Access::deref(${rightText}, ${this.getJsVarName(binExpr.right)})`
-        : rightText;
-    if (leftIsIdentifier && !leftTypeInfo &&
-        !this.isBuiltinObject(binExpr.left)) {
-        return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(binExpr.left)})`;
-    }
-    if (rightIsIdentifier && !rightTypeInfo &&
-        !this.isBuiltinObject(binExpr.right)) {
-        return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(binExpr.right)})`;
+    let finalLeft = leftText;
+    if (ts.isIdentifier(binExpr.left)) {
+        const scope = this.getScopeForNode(binExpr.left);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.getText(), scope);
+        if (!typeInfo && !this.isBuiltinObject(binExpr.left)) {
+            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);
+        }
+    }
+    let finalRight = rightText;
+    if (ts.isIdentifier(binExpr.right)) {
+        const scope = this.getScopeForNode(binExpr.right);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope);
+        if (!typeInfo &&
+            !this.isBuiltinObject(binExpr.right)) {
+            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);
+        }
+    }
+    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_primitive(${finalRight})`;
+        return `jspp::is_strictly_equal_to(${finalLeft}, ${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-        return `${finalLeft}.is_equal_to_primitive(${finalRight})`;
+        return `jspp::is_equal_to(${finalLeft}, ${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-        return `${finalLeft}.not_strictly_equal_to_primitive(${finalRight})`;
+        return `jspp::not_strictly_equal_to(${finalLeft}, ${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        return `${finalLeft}.not_equal_to_primitive(${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 === "*" ||
@@ -257,56 +514,159 @@ export function visitBinaryExpression(node, context) {
         op === "%" ||
         op === "^" ||
         op === "&" ||
-        op === "|") {
+        op === "|" ||
+        op === "<<" ||
+        op === ">>") {
         return `(${finalLeft} ${op} ${finalRight})`;
     }
     return `${finalLeft} ${op} ${finalRight}`;
 }
+export function visitConditionalExpression(node, context) {
+    const condExpr = node;
+    const condition = this.visit(condExpr.condition, context);
+    const whenTrueStmt = this.visit(condExpr.whenTrue, {
+        ...context,
+        isFunctionBody: false,
+    });
+    const whenFalseStmt = this.visit(condExpr.whenFalse, {
+        ...context,
+        isFunctionBody: false,
+    });
+    return `is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
+}
 export function visitCallExpression(node, context) {
     const callExpr = node;
     const callee = callExpr.expression;
-    const calleeName = this.escapeString(callee.getText());
-    const args = callExpr.arguments
+    if (callee.kind === ts.SyntaxKind.SuperKeyword) {
+        if (!context.superClassVar) {
+            throw new Error("super() called but no super class variable found in context");
+        }
+        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::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(arg)})`;
+                return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(arg)})`;
             }
-            if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                return `jspp::Access::deref(${argText}, ${this.getJsVarName(arg)})`;
+            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;
+        if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
+            if (!context.superClassVar) {
+                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}").call(${this.globalThisVar}, ${argsSpan}, "${this.escapeString(propName)}")`;
+        }
+        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);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(objExpr.getText(), scope);
+            if (!typeInfo && !this.isBuiltinObject(objExpr)) {
+                return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(objExpr)})`;
+            }
+            if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
+                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)}")`;
+        }
+        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)) {
+        const elemAccess = callee;
+        const objExpr = elemAccess.expression;
+        const objCode = this.visit(objExpr, context);
+        let derefObj = objCode;
+        if (ts.isIdentifier(objExpr)) {
+            const scope = this.getScopeForNode(objExpr);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(objExpr.getText(), scope);
+            if (!typeInfo && !this.isBuiltinObject(objExpr)) {
+                return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(objExpr)})`;
+            }
+            if (typeInfo && !typeInfo.isBuiltin && !typeInfo.isParameter) {
+                derefObj = this.getDerefCode(objCode, this.getJsVarName(objExpr), context, typeInfo);
+            }
+        }
+        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);
+            if (!argTypeInfo &&
+                !this.isBuiltinObject(elemAccess.argumentExpression)) {
+                return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(elemAccess.argumentExpression)})`;
+            }
+            if (argTypeInfo && !argTypeInfo.isParameter &&
+                !argTypeInfo.isBuiltin) {
+                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})`;
+        }
+        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property(${argText}).call(__obj, ${argsSpan}); })()`;
+    }
     const calleeCode = this.visit(callee, context);
-    let derefCallee;
+    let derefCallee = calleeCode;
     if (ts.isIdentifier(callee)) {
         const scope = this.getScopeForNode(callee);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(callee.text, scope);
         if (!typeInfo && !this.isBuiltinObject(callee)) {
-            return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(callee)})`;
+            return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(callee)})`;
         }
         if (typeInfo?.isBuiltin) {
             derefCallee = calleeCode;
         }
-        else {
-            derefCallee = `jspp::Access::deref(${calleeCode}, ${this.getJsVarName(callee)})`;
+        else if (typeInfo) {
+            derefCallee = this.getDerefCode(calleeCode, this.getJsVarName(callee), context, typeInfo);
         }
     }
-    else {
-        derefCallee = calleeCode;
+    let calleeName = "";
+    if (ts.isIdentifier(callee) || ts.isPropertyAccessExpression(callee)) {
+        calleeName = this.escapeString(callee.getText());
+    }
+    else if (ts.isParenthesizedExpression(callee) &&
+        ts.isFunctionExpression(callee.expression)) {
+        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})`;
     }
-    return `${derefCallee}.as_function()->call({${args}})`;
-    // return `${derefCallee}.as_function("${calleeName}")->call({${args}})`;
+    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;
@@ -319,13 +679,12 @@ export function visitTemplateExpression(node, context) {
             const scope = this.getScopeForNode(expr);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
             if (!typeInfo && !this.isBuiltinObject(expr)) {
-                finalExpr =
-                    `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)})`;
+                finalExpr = `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)})`;
             }
             else if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                finalExpr = `jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)})`;
+                finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
         }
         result += ` + (${finalExpr})`;
@@ -335,3 +694,98 @@ export function visitTemplateExpression(node, context) {
     }
     return result;
 }
+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(${name})`;
+        }
+        if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
+            derefExpr = this.getDerefCode(exprText, name, context, typeInfo);
+        }
+    }
+    const argsArray = newExpr.arguments
+        ? newExpr.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)})`;
+                }
+                if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
+                    return this.getDerefCode(argText, this.getJsVarName(arg), 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})`;
+}
+export function visitTypeOfExpression(node, context) {
+    const typeOfExpr = node;
+    const exprText = this.visit(typeOfExpr.expression, context);
+    let derefExpr = exprText;
+    if (ts.isIdentifier(typeOfExpr.expression)) {
+        const scope = this.getScopeForNode(typeOfExpr.expression);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(typeOfExpr.expression.getText(), scope);
+        if (!typeInfo &&
+            !this.isBuiltinObject(typeOfExpr.expression)) {
+            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), context, typeInfo);
+        }
+    }
+    return `jspp::Access::type_of(${derefExpr})`;
+}
+export function visitAwaitExpression(node, context) {
+    const awaitExpr = node;
+    const exprText = this.visit(awaitExpr.expression, context);
+    let derefExpr = exprText;
+    if (ts.isIdentifier(awaitExpr.expression)) {
+        const scope = this.getScopeForNode(awaitExpr.expression);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(awaitExpr.expression.getText(), scope);
+        if (!typeInfo &&
+            !this.isBuiltinObject(awaitExpr.expression)) {
+            // This assumes co_awaiting the result of throw_unresolved_reference (which throws)
+            // But throw_unresolved_reference returns AnyValue (void-ish).
+            // 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::Constants::UNDEFINED)`;
+        }
+        if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
+            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
+}