@ugo-studio/jspp 0.1.2 → 0.1.4

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

@@ -1,46 +1,122 @@
 import ts from "typescript";
 import { CodeGenerator } from "./";
-function visitObjectPropertyName(node, context) {
+export function visitObjectPropertyName(node, context) {
+    if (ts.isNumericLiteral(node)) {
+        return context.isBracketNotationPropertyAccess
+            ? node.getText()
+            : `"${node.getText()}"`;
+    }
     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), typeInfo);
+        }
+        return propName;
+    }
+    if (context.isBracketNotationPropertyAccess) {
+        return this.visit(node, context);
     }
-    return context.isPropertyNameAccess
-        ? node.getText()
-        : `"${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({});\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), 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), 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))
+        .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), typeInfo);
+            }
+        }
+        return elemText;
+    })
         .join(", ");
     return `jspp::AnyValue::make_array({${elements}})`;
 }
@@ -49,10 +125,32 @@ export function visitPrefixUnaryExpression(node, context) {
     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, 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, typeInfo);
+            }
+            else if (typeInfo.needsHeapAllocation) {
+                target = `*${operand}`;
+            }
+        }
+        return `${operator}(${target})`;
     }
     return `${operator}${operand}`;
 }
@@ -60,7 +158,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, typeInfo);
+        }
+        else if (typeInfo.needsHeapAllocation) {
+            target = `*${operand}`;
+        }
+    }
+    return `(${target})${operator}`;
 }
 export function visitParenthesizedExpression(node, context) {
     const parenExpr = node;
@@ -68,6 +177,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);
@@ -76,22 +192,21 @@ 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)})`;
-    }
-    else {
-        finalExpr = exprText;
+    let finalExpr = exprText;
+    if (typeInfo &&
+        !typeInfo.isParameter &&
+        !typeInfo.isBuiltin &&
+        ts.isIdentifier(propAccess.expression)) {
+        finalExpr = this.getDerefCode(exprText, this.getJsVarName(propAccess.expression), typeInfo);
     }
     return `${finalExpr}.get_own_property("${propName}")`;
-    // return `${finalExpr}["${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)
@@ -99,51 +214,93 @@ 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), 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), argTypeInfo);
         }
     }
     return `${finalExpr}.get_own_property(${argText})`;
-    // return `${finalExpr}[${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,
+    ];
+    if (assignmentOperators.includes(opToken.kind)) {
         const leftText = this.visit(binExpr.left, context);
-        const rightText = this.visit(binExpr.right, context);
-        return `*${leftText} ${op} ${rightText}`;
+        let rightText = 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);
+        }
+        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);
+            }
+            else if (typeInfo.needsHeapAllocation) {
+                target = `*${leftText}`;
+            }
+        }
+        return `${target} ${op} ${rightText}`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsToken) {
         const 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), 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), typeInfo);
+                }
+            }
             let finalRightText = rightText;
             if (ts.isIdentifier(binExpr.right)) {
                 const rightScope = this.getScopeForNode(binExpr.right);
@@ -152,23 +309,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), 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), typeInfo);
+                }
+            }
             if (ts.isIdentifier(elemAccess.argumentExpression)) {
                 const argScope = this.getScopeForNode(elemAccess.argumentExpression);
                 const argTypeInfo = this.typeAnalyzer.scopeManager
@@ -176,7 +333,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), argTypeInfo);
                 }
             }
             let finalRightText = rightText;
@@ -187,61 +344,61 @@ 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), 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()`;
         }
-        return `*${leftText} ${op} ${rightText}`;
+        const target = context.derefBeforeAssignment
+            ? this.getDerefCode(leftText, leftText, 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), 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), typeInfo);
+        }
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-        return `${finalLeft}.is_strictly_equal_to_primitive(${finalRight})`;
+        return `${finalLeft}.is_strictly_equal_to(${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-        return `${finalLeft}.is_equal_to_primitive(${finalRight})`;
+        return `${finalLeft}.is_equal_to(${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-        return `${finalLeft}.not_strictly_equal_to_primitive(${finalRight})`;
+        return `${finalLeft}.not_strictly_equal_to(${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        return `${finalLeft}.not_equal_to_primitive(${finalRight})`;
+        return `${finalLeft}.not_equal_to(${finalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskToken) {
         return `jspp::pow(${finalLeft}, ${finalRight})`;
@@ -258,10 +415,30 @@ export function visitBinaryExpression(node, context) {
     }
     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 `(${condition}).is_truthy() ? ${whenTrueStmt} : ${whenFalseStmt}`;
+}
 export function visitCallExpression(node, context) {
     const callExpr = node;
     const callee = callExpr.expression;
-    const calleeName = this.escapeString(callee.getText());
+    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}).as_function("super")->call(${this.globalThisVar}, {${args}})`;
+    }
     const args = callExpr.arguments
         .map((arg) => {
         const argText = this.visit(arg, context);
@@ -269,35 +446,100 @@ export function visitCallExpression(node, context) {
             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)})`;
+                return this.getDerefCode(argText, this.getJsVarName(arg), typeInfo);
             }
         }
         return argText;
     })
         .join(", ");
+    // 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}").as_function("${this.escapeString(propName)}")->call(${this.globalThisVar}, {${args}})`;
+        }
+        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), typeInfo);
+            }
+        }
+        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property("${propName}").as_function("${this.escapeString(propName)}")->call(__obj, {${args}}); })()`;
+    }
+    // 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), 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), argTypeInfo);
+            }
+        }
+        return `([&](){ auto __obj = ${derefObj}; return __obj.get_own_property(${argText}).as_function()->call(__obj, {${args}}); })()`;
+    }
     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), typeInfo);
         }
     }
-    else {
-        derefCallee = calleeCode;
+    let calleeName = "";
+    if (ts.isIdentifier(callee) || ts.isPropertyAccessExpression(callee)) {
+        calleeName = this.escapeString(callee.getText());
     }
-    return `${derefCallee}.as_function()->call({${args}})`;
-    // return `${derefCallee}.as_function("${calleeName}")->call({${args}})`;
+    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
+    return `${derefCallee}.as_function("${calleeName}")->call(jspp::AnyValue::make_undefined(), {${args}})`;
 }
 export function visitVoidExpression(node, context) {
     const voidExpr = node;
@@ -315,13 +557,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), typeInfo);
             }
         }
         result += ` + (${finalExpr})`;
@@ -331,3 +572,78 @@ 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;
+    if (ts.isIdentifier(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)})`;
+        }
+        if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
+            derefExpr = this.getDerefCode(exprText, this.getJsVarName(newExpr.expression), typeInfo);
+        }
+    }
+    const args = 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), typeInfo);
+                }
+            }
+            return argText;
+        })
+            .join(", ")
+        : "";
+    return `${derefExpr}.construct({${args}})`;
+}
+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), typeInfo);
+        }
+    }
+    return `jspp::Access::typeof(${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::AnyValue::make_undefined())`;
+        }
+        if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
+            derefExpr = this.getDerefCode(exprText, this.getJsVarName(awaitExpr.expression), typeInfo);
+        }
+    }
+    return `co_await ${derefExpr}`;
+}