@ugo-studio/jspp 0.3.2 → 0.3.4

package/README.md

@@ -61,7 +61,7 @@ Using these keywords as variable names will result in a `SyntaxError`.
 To use JSPP as a command-line tool, install it globally via npm:
 
 ```sh
-npm i @ugo-studio/jspp -g
+npm i @ugo-studio/jspp@latest -g
 ```
 
 ## For Developers
@@ -86,7 +86,7 @@ To contribute to JSPP or run its test suite, follow these steps:
     ```sh
     bun install
     ```
-    *Note: The `postinstall` script will automatically check for your C++ compiler and precompile the runtime headers and library.*
+    *Note: The `postinstall` script will automatically check for your C++ compiler and setup emsdk for wasm support.*
 
 ## Usage
 
@@ -106,10 +106,6 @@ jspp my-code/test.ts
 
 The transpiled C++ file and executable will be generated in the same directory as the input file and cleaned up after execution (unless `--keep-cpp` is used).
 
-### Timing and Reports
-
-In debug mode (default), JSPP provides a compilation time report using GCC's `-ftime-report`. This helps track the performance of the transpilation and compilation phases.
-
 ## Roadmap
 
 This project is ambitious, and there is a long and exciting road ahead. Here is a high-level overview of the planned features and the project's current standing.

package/dist/cli/args.js

@@ -5,6 +5,7 @@ export function parseArgs(rawArgs) {
     let jsFilePathArg = null;
     let isRelease = false;
     let keepCpp = false;
+    let shouldRunOutput = false;
     let outputExePath = null;
     let scriptArgs = [];
     let target = "native";
@@ -22,6 +23,9 @@ export function parseArgs(rawArgs) {
         else if (arg === "--keep-cpp") {
             keepCpp = true;
         }
+        else if (arg === "--run-output") {
+            shouldRunOutput = true;
+        }
         else if (arg === "-t" || arg === "--target") {
             if (i + 1 < rawArgs.length) {
                 const targetValue = rawArgs[i + 1]?.toLowerCase();
@@ -72,6 +76,7 @@ export function parseArgs(rawArgs) {
         jsFilePath: path.resolve(process.cwd(), jsFilePathArg),
         isRelease,
         keepCpp,
+        shouldRunOutput,
         outputExePath: outputExePath
             ? path.resolve(process.cwd(), outputExePath)
             : null,

package/dist/cli/compiler.js

@@ -49,5 +49,5 @@ export async function compileCpp(cppFilePath, exeFilePath, pchDir, preludePath,
     }
     const compileEndTime = performance.now();
     const compileTime = msToHumanReadable(compileEndTime - compileStartTime);
-    spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset} ${COLORS.dim}[${compileTime}]${COLORS.reset}`);
+    spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${exeFilePath}${COLORS.reset} ${COLORS.dim}[${compileTime}]${COLORS.reset}`);
 }

package/dist/cli/index.js

@@ -17,7 +17,7 @@ const emsdkEnv = {
     PATH: `${path.join(pkgDir, ".emsdk")}${path.delimiter}${path.join(pkgDir, ".emsdk", "upstream", "emscripten")}${path.delimiter}${process.env.PATH}`,
 };
 async function main() {
-    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs, target, } = parseArgs(process.argv.slice(2));
+    const { jsFilePath, isRelease, keepCpp, shouldRunOutput, outputExePath, scriptArgs, target, } = parseArgs(process.argv.slice(2));
     const isWasm = target === "wasm";
     const ext = path.extname(jsFilePath);
     const jsFileName = path.basename(jsFilePath, ext);
@@ -80,7 +80,9 @@ async function main() {
             }
         }
         // 4. Execution Phase
-        await runOutput(exeFilePath, scriptArgs, isWasm);
+        if (shouldRunOutput) {
+            await runOutput(exeFilePath, scriptArgs, isWasm);
+        }
     }
     catch (error) {
         if (error instanceof CompilerError) {

package/dist/interpreter/analysis/typeAnalyzer.js

@@ -568,7 +568,7 @@ export class TypeAnalyzer {
         };
         const visitor = {
             // Enter new scope for any block-like structure
-            Block: {
+            [ts.SyntaxKind.Block]: {
                 enter: (node, parent) => {
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
                         null;
@@ -591,7 +591,7 @@ export class TypeAnalyzer {
                 },
                 exit: () => this.scopeManager.exitScope(),
             },
-            ForStatement: {
+            [ts.SyntaxKind.ForStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -604,7 +604,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            ForOfStatement: {
+            [ts.SyntaxKind.ForOfStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -617,7 +617,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            ForInStatement: {
+            [ts.SyntaxKind.ForInStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -649,7 +649,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            WhileStatement: {
+            [ts.SyntaxKind.WhileStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -662,7 +662,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            DoStatement: {
+            [ts.SyntaxKind.DoStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -675,7 +675,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            SwitchStatement: {
+            [ts.SyntaxKind.SwitchStatement]: {
                 enter: (node) => {
                     this.switchDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -688,7 +688,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            LabeledStatement: {
+            [ts.SyntaxKind.LabeledStatement]: {
                 enter: (node) => {
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                     this.labelStack.push(node.label.text);
@@ -697,7 +697,7 @@ export class TypeAnalyzer {
                     this.labelStack.pop();
                 },
             },
-            BreakStatement: {
+            [ts.SyntaxKind.BreakStatement]: {
                 enter: (node) => {
                     const breakNode = node;
                     if (breakNode.label) {
@@ -712,7 +712,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            ContinueStatement: {
+            [ts.SyntaxKind.ContinueStatement]: {
                 enter: (node) => {
                     const continueNode = node;
                     if (continueNode.label) {
@@ -729,7 +729,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            ArrowFunction: {
+            [ts.SyntaxKind.ArrowFunction]: {
                 enter: (node) => {
                     if (ts.isArrowFunction(node)) {
                         const funcType = {
@@ -760,7 +760,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            FunctionExpression: {
+            [ts.SyntaxKind.FunctionExpression]: {
                 enter: (node) => {
                     if (ts.isFunctionExpression(node)) {
                         const funcType = {
@@ -795,7 +795,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            FunctionDeclaration: {
+            [ts.SyntaxKind.FunctionDeclaration]: {
                 enter: (node) => {
                     if (ts.isFunctionDeclaration(node)) {
                         // Define the function in the current scope.
@@ -831,7 +831,44 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            ClassDeclaration: {
+            [ts.SyntaxKind.GetAccessor]: {
+                enter: (node) => {
+                    if (ts.isGetAccessorDeclaration(node)) {
+                        this.scopeManager.enterScope(node);
+                        this.nodeToScope.set(node, this.scopeManager.currentScope);
+                        this.functionStack.push(node);
+                    }
+                },
+                exit: (node) => {
+                    if (ts.isGetAccessorDeclaration(node)) {
+                        this.functionStack.pop();
+                    }
+                    this.scopeManager.exitScope();
+                },
+            },
+            [ts.SyntaxKind.SetAccessor]: {
+                enter: (node) => {
+                    if (ts.isSetAccessorDeclaration(node)) {
+                        this.scopeManager.enterScope(node);
+                        this.nodeToScope.set(node, this.scopeManager.currentScope);
+                        // Define parameters in the new scope
+                        node.parameters.forEach((p) => {
+                            if (p.getText() == "this") { // Catch invalid parameters
+                                throw new CompilerError("Cannot use 'this' as a parameter name.", p, "SyntaxError");
+                            }
+                            this.defineParameter(p.name, p);
+                        });
+                        this.functionStack.push(node);
+                    }
+                },
+                exit: (node) => {
+                    if (ts.isSetAccessorDeclaration(node)) {
+                        this.functionStack.pop();
+                    }
+                    this.scopeManager.exitScope();
+                },
+            },
+            [ts.SyntaxKind.ClassDeclaration]: {
                 enter: (node) => {
                     const classNode = node;
                     if (classNode.name) {
@@ -853,7 +890,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            EnumDeclaration: {
+            [ts.SyntaxKind.EnumDeclaration]: {
                 enter: (node) => {
                     const enumNode = node;
                     if (enumNode.name) {
@@ -872,7 +909,7 @@ export class TypeAnalyzer {
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
             },
-            MethodDeclaration: {
+            [ts.SyntaxKind.MethodDeclaration]: {
                 enter: (node) => {
                     if (ts.isMethodDeclaration(node)) {
                         const funcType = {
@@ -898,7 +935,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            Constructor: {
+            [ts.SyntaxKind.Constructor]: {
                 enter: (node) => {
                     if (ts.isConstructorDeclaration(node)) {
                         const funcType = {
@@ -923,7 +960,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            VariableDeclaration: {
+            [ts.SyntaxKind.VariableDeclaration]: {
                 enter: (node) => {
                     if (ts.isVariableDeclaration(node)) {
                         // Check if it is an ambient declaration (declare var/let/const ...)
@@ -990,8 +1027,8 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            Identifier: {
-                enter: (node, parent) => {
+            [ts.SyntaxKind.Identifier]: {
+                enter: (node) => {
                     if (ts.isIdentifier(node)) {
                         if (isBuiltinObject.call(this, node))
                             return;
@@ -1027,7 +1064,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            BinaryExpression: {
+            [ts.SyntaxKind.BinaryExpression]: {
                 enter: (node) => {
                     if (ts.isBinaryExpression(node)) {
                         const isAssignment = node.operatorToken.kind >=
@@ -1050,7 +1087,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            CallExpression: {
+            [ts.SyntaxKind.CallExpression]: {
                 enter: (node) => {
                     if (ts.isCallExpression(node)) {
                         const callee = node.expression;
@@ -1070,7 +1107,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            ReturnStatement: {
+            [ts.SyntaxKind.ReturnStatement]: {
                 enter: (node) => {
                     if (ts.isReturnStatement(node) && node.expression) {
                         const currentFuncNode = this.functionStack[this.functionStack.length - 1];
@@ -1086,14 +1123,14 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            PostfixUnaryExpression: {
+            [ts.SyntaxKind.PostfixUnaryExpression]: {
                 enter: (node) => {
                     if (ts.isPostfixUnaryExpression(node)) {
                         crossScopeModificationVisitor(node.operand);
                     }
                 },
             },
-            PrefixUnaryExpression: {
+            [ts.SyntaxKind.PrefixUnaryExpression]: {
                 enter: (node) => {
                     if (ts.isPrefixUnaryExpression(node)) {
                         const op = node.operator;

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

@@ -153,16 +153,19 @@ export function visitForInStatement(node, context) {
         derefExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
     }
     const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
+    const visitContext = {
+        ...context,
+        globalScopeSymbols: this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols),
+        localScopeSymbols: new DeclaredSymbols(),
+        currentLabel: undefined,
+        isFunctionBody: false,
+    };
     code +=
         `${this.indent()}std::vector<jspp::AnyValue> ${keysVar} = jspp::Access::get_object_keys(${derefExpr});\n`;
     code += `${this.indent()}for (const auto& ${varName}_val : ${keysVar}) {\n`;
     this.indentationLevel++;
     code += `${this.indent()}${assignmentTarget} = ${varName}_val;\n`;
-    code += this.visit(forIn.statement, {
-        ...context,
-        currentLabel: undefined,
-        isFunctionBody: false,
-    });
+    code += this.visit(forIn.statement, visitContext);
     this.indentationLevel--;
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}_continue:;\n`;
@@ -188,6 +191,7 @@ export function visitForOfStatement(node, context) {
     this.indentationLevel++; // Enter a new scope for the for-of loop
     let elemName = "";
     let assignmentTarget = "";
+    let declarationType = DeclarationType.const;
     code += `${this.indent()}{\n`;
     if (ts.isVariableDeclarationList(forOf.initializer)) {
         const decl = forOf.initializer.declarations[0];
@@ -205,6 +209,11 @@ export function visitForOfStatement(node, context) {
                     `${this.indent()}jspp::AnyValue ${elemName} = jspp::Constants::UNDEFINED;\n`;
                 assignmentTarget = elemName;
             }
+            declarationType = (decl.parent.flags & (ts.NodeFlags.Let)) !== 0
+                ? DeclarationType.let
+                : (decl.parent.flags & (ts.NodeFlags.Const)) !== 0
+                    ? DeclarationType.const
+                    : DeclarationType.var;
         }
     }
     else if (ts.isIdentifier(forOf.initializer)) {
@@ -214,6 +223,12 @@ export function visitForOfStatement(node, context) {
         assignmentTarget = typeInfo?.needsHeapAllocation
             ? `*${elemName}`
             : elemName;
+        declarationType =
+            (forOf.initializer.parent.flags & (ts.NodeFlags.Let)) !== 0
+                ? DeclarationType.let
+                : (forOf.initializer.parent.flags & (ts.NodeFlags.Const)) !== 0
+                    ? DeclarationType.const
+                    : DeclarationType.var;
     }
     const iterableExpr = this.visit(forOf.expression, context);
     let derefIterable = iterableExpr;
@@ -230,6 +245,19 @@ export function visitForOfStatement(node, context) {
     const nextRes = this.generateUniqueName("__next_res", declaredSymbols);
     const isAwait = forOf.awaitModifier !== undefined;
     const varName = this.getJsVarName(forOf.expression);
+    const visitContext = {
+        ...context,
+        globalScopeSymbols: this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols),
+        localScopeSymbols: new DeclaredSymbols(),
+        currentLabel: undefined,
+        isFunctionBody: false,
+    };
+    if (elemName) {
+        visitContext.localScopeSymbols.add(elemName, {
+            type: declarationType,
+            checks: { initialized: true },
+        });
+    }
     code += `${this.indent()}auto ${iterableRef} = ${derefIterable};\n`;
     if (isAwait) {
         code +=
@@ -254,11 +282,7 @@ export function visitForOfStatement(node, context) {
     this.indentationLevel++;
     code +=
         `${this.indent()}${assignmentTarget} = ${nextRes}.get_own_property("value");\n`;
-    code += this.visit(forOf.statement, {
-        ...context,
-        currentLabel: undefined,
-        isFunctionBody: false,
-    });
+    code += this.visit(forOf.statement, visitContext);
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}_continue:;\n`;
     }

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

@@ -247,6 +247,17 @@ export function visitPrefixUnaryExpression(node, context) {
     const operand = this.visit(prefixUnaryExpr.operand, context);
     const operator = ts.tokenToString(prefixUnaryExpr.operator);
     if (operator === "++" || operator === "--") {
+        const opFunc = operator === "++" ? "add" : "sub";
+        if (ts.isPropertyAccessExpression(prefixUnaryExpr.operand)) {
+            const obj = this.visit(prefixUnaryExpr.operand.expression, context);
+            const prop = visitObjectPropertyName.call(this, prefixUnaryExpr.operand.name, context);
+            return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), 1.0))`;
+        }
+        else if (ts.isElementAccessExpression(prefixUnaryExpr.operand)) {
+            const obj = this.visit(prefixUnaryExpr.operand.expression, context);
+            const prop = visitObjectPropertyName.call(this, prefixUnaryExpr.operand.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), 1.0))`;
+        }
         let target = operand;
         if (ts.isIdentifier(prefixUnaryExpr.operand)) {
             const scope = this.getScopeForNode(prefixUnaryExpr.operand);
@@ -289,6 +300,20 @@ export function visitPostfixUnaryExpression(node, context) {
     const postfixUnaryExpr = node;
     const operand = this.visit(postfixUnaryExpr.operand, context);
     const operator = ts.tokenToString(postfixUnaryExpr.operator);
+    if (ts.isPropertyAccessExpression(postfixUnaryExpr.operand)) {
+        const obj = this.visit(postfixUnaryExpr.operand.expression, context);
+        const prop = visitObjectPropertyName.call(this, postfixUnaryExpr.operand.name, context);
+        const opFunc = operator === "++" ? "add" : "sub";
+        // Postfix needs IILE to return old value
+        return `([&]() { auto oldVal = ${obj}.get_own_property(${prop}); ${obj}.set_own_property(${prop}, jspp::${opFunc}(oldVal, 1.0)); return oldVal; })()`;
+    }
+    else if (ts.isElementAccessExpression(postfixUnaryExpr.operand)) {
+        const obj = this.visit(postfixUnaryExpr.operand.expression, context);
+        const prop = visitObjectPropertyName.call(this, postfixUnaryExpr.operand.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+        const opFunc = operator === "++" ? "add" : "sub";
+        // Postfix needs IILE to return old value
+        return `([&]() { auto oldVal = ${obj}.get_own_property(${prop}); ${obj}.set_own_property(${prop}, jspp::${opFunc}(oldVal, 1.0)); return oldVal; })()`;
+    }
     let target = operand;
     if (ts.isIdentifier(postfixUnaryExpr.operand)) {
         const scope = this.getScopeForNode(postfixUnaryExpr.operand);
@@ -402,42 +427,36 @@ export function visitBinaryExpression(node, context) {
     if (assignmentOperators.includes(opToken.kind)) {
         if (opToken.kind ===
             ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
-            const leftText = this.visit(binExpr.left, visitContext);
             const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
+                const leftText = this.visit(binExpr.left, visitContext);
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
+                const target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
-                return `${target} = jspp::unsigned_right_shift(${target}, ${rightText})`;
+                return `jspp::unsigned_right_shift_assign(${target}, ${rightText})`;
             }
-        }
-        if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
-            const leftText = this.visit(binExpr.left, visitContext);
-            const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
-            if (ts.isIdentifier(binExpr.left)) {
-                const scope = this.getScopeForNode(binExpr.left);
-                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
-                    ? `*${leftText}`
-                    : leftText;
-                return `${target} = jspp::pow(${target}, ${rightText})`;
+            else if (ts.isPropertyAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+                return `${obj}.set_own_property(${prop}, jspp::unsigned_right_shift(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else if (ts.isElementAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+                return `${obj}.set_own_property(${prop}, jspp::unsigned_right_shift(${obj}.get_own_property(${prop}), ${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, visitContext);
             const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
+                const leftText = this.visit(binExpr.left, visitContext);
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
+                const target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
@@ -450,6 +469,29 @@ export function visitBinaryExpression(node, context) {
                     return `jspp::nullish_coalesce_assign(${target}, ${rightText})`;
                 }
             }
+            else if (ts.isPropertyAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+                const func = opToken.kind ===
+                    ts.SyntaxKind.AmpersandAmpersandEqualsToken
+                    ? "logical_and"
+                    : (opToken.kind === ts.SyntaxKind.BarBarEqualsToken
+                        ? "logical_or"
+                        : "nullish_coalesce");
+                // Logical assignments return newVal, set_own_property returns newVal.
+                return `${obj}.set_own_property(${prop}, jspp::${func}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else if (ts.isElementAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+                const func = opToken.kind ===
+                    ts.SyntaxKind.AmpersandAmpersandEqualsToken
+                    ? "logical_and"
+                    : (opToken.kind === ts.SyntaxKind.BarBarEqualsToken
+                        ? "logical_or"
+                        : "nullish_coalesce");
+                return `${obj}.set_own_property(${prop}, jspp::${func}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
         }
         const leftText = this.visit(binExpr.left, visitContext);
         let rightText = ts.isNumericLiteral(binExpr.right)
@@ -460,6 +502,35 @@ export function visitBinaryExpression(node, context) {
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope);
             rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
+        if (ts.isPropertyAccessExpression(binExpr.left)) {
+            const obj = this.visit(binExpr.left.expression, context);
+            const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+            const opBase = op.slice(0, -1); // "+=", "-=" -> "+", "-"
+            const opFunc = opBase === "+" ? "add" : (opBase === "-" ? "sub" : (opBase === "*" ? "mul" : (opBase === "/" ? "div" : (opBase === "%" ? "mod" : (opBase === "&" ? "bitwise_and" : (opBase === "|" ? "bitwise_or" : (opBase === "^" ? "bitwise_xor" : (opBase === "<<" ? "left_shift" : (opBase === ">>"
+                ? "right_shift"
+                : "")))))))));
+            if (opFunc) {
+                return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else {
+                // Fallback to IILE if we don't have an opFunc mapping
+                return `([&]() { auto val = ${obj}.get_own_property(${prop}); val ${op} ${rightText}; ${obj}.set_own_property(${prop}, val); return val; })()`;
+            }
+        }
+        else if (ts.isElementAccessExpression(binExpr.left)) {
+            const obj = this.visit(binExpr.left.expression, context);
+            const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            const opBase = op.slice(0, -1);
+            const opFunc = opBase === "+" ? "add" : (opBase === "-" ? "sub" : (opBase === "*" ? "mul" : (opBase === "/" ? "div" : (opBase === "%" ? "mod" : (opBase === "&" ? "bitwise_and" : (opBase === "|" ? "bitwise_or" : (opBase === "^" ? "bitwise_xor" : (opBase === "<<" ? "left_shift" : (opBase === ">>"
+                ? "right_shift"
+                : "")))))))));
+            if (opFunc) {
+                return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else {
+                return `([&]() { auto val = ${obj}.get_own_property(${prop}); val ${op} ${rightText}; ${obj}.set_own_property(${prop}, val); return val; })()`;
+            }
+        }
         let target = leftText;
         if (ts.isIdentifier(binExpr.left)) {
             const scope = this.getScopeForNode(binExpr.left);
@@ -1266,7 +1337,7 @@ export function visitTypeOfExpression(node, context) {
             derefExpr = this.getDerefCode(exprText, this.getJsVarName(typeOfExpr.expression), context, typeInfo);
         }
     }
-    return `jspp::Access::type_of(${derefExpr})`;
+    return `jspp::type_of(${derefExpr})`;
 }
 export function visitAwaitExpression(node, context) {
     const awaitExpr = node;

package/dist/interpreter/core/codegen/function-handlers.js

@@ -123,7 +123,7 @@ export function generateLambdaComponents(node, context, options) {
         }
     });
     // Extract lambda parameters from arguments span/vector
-    const generateParamsBuilder = () => {
+    const wrappedFuncParamsBuilder = () => {
         let paramsCode = "";
         this.validateFunctionParams(node.parameters).forEach((p, i) => {
             if (ts.isIdentifier(p.name)) {
@@ -152,14 +152,19 @@ export function generateLambdaComponents(node, context, options) {
                     return;
                 }
                 // Normal parameter
-                const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
-                if (typeInfo?.needsHeapAllocation) {
-                    paramsCode +=
-                        `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
-                }
-                else {
-                    paramsCode +=
-                        `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
+                const isUsedInFuncBody = !!p.initializer ||
+                    this.isDeclarationUsedAsValue(p, node) ||
+                    this.isDeclarationCalledAsFunction(p, node);
+                if (isUsedInFuncBody) {
+                    const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
+                    if (typeInfo?.needsHeapAllocation) {
+                        paramsCode +=
+                            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
+                    }
+                    else {
+                        paramsCode +=
+                            `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
+                    }
                 }
             }
             else {
@@ -225,7 +230,7 @@ export function generateLambdaComponents(node, context, options) {
                 }
             });
             this.indentationLevel++;
-            paramsContent += generateParamsBuilder();
+            paramsContent += wrappedFuncParamsBuilder();
             this.indentationLevel--;
             // The block visitor already adds braces, so we need to remove the opening brace to inject the preamble and param extraction.
             const properIndentationLevel = this.indentationLevel;
@@ -250,7 +255,7 @@ export function generateLambdaComponents(node, context, options) {
         }
         else {
             this.indentationLevel++;
-            paramsContent += generateParamsBuilder();
+            paramsContent += wrappedFuncParamsBuilder();
             const properIndentationLevel = this.indentationLevel;
             const nodeBody = node.body;
             getBlockContentWithoutOpeningBrace = (isInsideNativeLambda) => {

package/dist/interpreter/core/codegen/helpers.js

@@ -799,7 +799,11 @@ export function findEnclosingFunctionDeclarationFromReturnStatement(node) {
     let current = node;
     let foundReturn = false;
     while (current) {
-        if (ts.isFunctionDeclaration(current)) {
+        if (ts.isFunctionDeclaration(current) ||
+            ts.isFunctionExpression(current) ||
+            ts.isArrowFunction(current) ||
+            ts.isMethodDeclaration(current) ||
+            ts.isConstructorDeclaration(current)) {
             if (foundReturn) {
                 return current;
             }