@ugo-studio/jspp 0.2.9 → 0.3.1

package/LICENSE

@@ -1,25 +1,25 @@
-# License
-
-JSPP is licensed under the [MIT License](#mit-license).
-
-## MIT License
-
-Copyright (c) 2025 Emmanuel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+# License
+
+JSPP is licensed under the [MIT License](#mit-license).
+
+## MIT License
+
+Copyright (c) 2025 Emmanuel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -11,7 +11,11 @@ The primary goal of this project is to achieve a near-perfect translation of Jav
 
 JavaScript is flexible and dynamic; C++ is performant and type-safe. JSPP aims to offer the best of both worlds. By transpiling JS/TS to C++, we can potentially run JavaScript logic in environments where C++ is native, with significant performance gains and opportunities for low-level interoperability.
 
-This project serves as a deep dive into compiler design, language semantics, and the expressive power of modern C++. The current implementation translates an entire JavaScript/TypeScript file into a single C++ `main` function, cleverly using `std::shared_ptr<std::any>` (and custom wrappers) to replicate JavaScript's dynamic typing, garbage-collection-like memory management, and complex features like closures.
+This project serves as a deep dive into compiler design, language semantics, and the expressive power of modern C++. The architecture is designed for performance, utilizing:
+- **Fast Runtime Library:** Core JavaScript logic is implemented in a static C++ library (`libjspp.a`), precompiled for speed.
+- **Precompiled Headers (PCH):** Common headers are precompiled to drastically reduce the front-end parsing time of the C++ compiler.
+- **NaN-Boxing:** An efficient 64-bit value representation (NaN-boxing) is used to replicate JavaScript's dynamic typing with minimal overhead.
+- **Modern C++23:** Leverages the latest language features, including coroutines for `async/await` and generators.
 
 ## Features
 
@@ -67,8 +71,10 @@ To contribute to JSPP or run its test suite, follow these steps:
 ### Prerequisites
 
 - **Bun:** This project uses [Bun](https://bun.sh/) for package management, script execution, and testing.
-- **C++ Compiler:** A compiler with support for C++23 is required. This project is tested with `g++`.
-  - `g++` (MinGW on Windows, or available via build-essentials on Linux)
+- **C++ Compiler:** A compiler with support for C++23 is required (e.g., `g++` 13+ or `clang` 17+).
+  - **Windows:** [MSYS2](https://www.msys2.org/) with `mingw-w64-x86_64-gcc` is recommended.
+  - **Linux:** `g++-14` or equivalent.
+  - **macOS:** `brew install gcc`.
 
 ### Setup
 
@@ -76,10 +82,11 @@ To contribute to JSPP or run its test suite, follow these steps:
     ```sh
     git clone https://github.com/ugo-studio/jspp.git
     ```
-2.  Install dependencies:
+2.  Install dependencies and build the runtime:
     ```sh
     bun install
     ```
+    *Note: The `postinstall` script will automatically check for your C++ compiler and precompile the runtime headers and library.*
 
 ## Usage
 
@@ -99,11 +106,9 @@ 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).
 
-You can also run the test suite:
+### Timing and Reports
 
-```sh
-bun test
-```
+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
 
@@ -115,7 +120,7 @@ This project is ambitious, and there is a long and exciting road ahead. Here is
 
 This phase focuses on building a solid foundation that correctly models JavaScript's core runtime behavior.
 
-- [x] Dynamic Variables & Primitives
+- [x] Dynamic Variables & Primitives (NaN-boxing)
 - [x] Function Declarations & Arrow Functions
 - [x] Correct Hoisting for Variables and Functions
 - [x] Closures & Lexical Scoping
@@ -139,16 +144,19 @@ This phase broadens the range of supported JavaScript syntax and features.
 
 This phase focuses on building out the standard library and enabling modular code.
 
-- [ ] **JS Standard Library:** Implementation of common built-in objects. (Currently supports: `Math`, `Symbol`, `Error`, `String`, `Array`, `Object`, `Timer`). **Pending:** `Date`, `Temporal`, `Map`, `Set`, `JSON`, etc.
-- [x] **Asynchronous Operations:** Event loop, `Promise`, `async/await`, and timers (`setTimeout`).
+- [x] **JS Standard Library:** Core implementation of `Math`, `Symbol`, `Error`, `String`, `Array`, `Object`, `Timer`.
+- [ ] **Expanded Library:** `Date`, `Temporal`, `Map`, `Set`, `JSON`, `RegExp`.
+- [x] **Asynchronous Operations:** Event loop, `Promise`, `async/await`.
 - [ ] **Module System:** Support for `import` and `export` to transpile multi-file projects.
 
 ### **Phase 4: Optimization & Advanced Features**
 
 With a feature-complete transpiler, the focus will shift to performance and advanced capabilities.
 
+- [x] **Architecture Optimization:** Static library runtime and Precompiled Headers.
 - [ ] **Performance Benchmarking:** Create a suite to compare transpiled C++ performance against V8.
-- [ ] **C++ Interoperability:** Define a clear API for calling C++ functions from the transpiled JavaScript and vice-versa.
+- [ ] **Linker Optimization:** Support for `LLD` or `Mold` linkers.
+- [ ] **C++ Interoperability:** Define a clear API for calling C++ functions from JavaScript.
 
 ## Contributing
 

package/dist/analysis/scope.js

@@ -7,6 +7,9 @@ export const RESERVED_KEYWORDS = new Set([
     "co_return",
     "co_await",
 ]);
+export const RESERVED_VAR_NAMES_FOR_STRICT_MODE = new Set([
+    "arguments",
+]);
 export const BUILTIN_OBJECTS = new Set([
     { name: "undefined", isConst: true },
     { name: "null", isConst: true },
@@ -57,7 +60,6 @@ export class Scope {
 export class ScopeManager {
     currentScope;
     allScopes = []; // Array to store all created scopes
-    reservedKeywords = new Set(RESERVED_KEYWORDS);
     constructor() {
         const rootScope = new Scope(null, null); // The global scope
         this.currentScope = rootScope;
@@ -86,7 +88,7 @@ export class ScopeManager {
     // Defines a variable in the current scope.
     define(name, type) {
         // if (name === "named" || name === "letVal") console.log("Defining", name, "in scope. isBuiltin:", type.isBuiltin, " type:", type.type);
-        if (this.reservedKeywords.has(name) && !type.isBuiltin) {
+        if (RESERVED_KEYWORDS.has(name) && !type.isBuiltin) {
             if (type.declaration) {
                 throw new CompilerError(`Unexpected reserved word "${name}"`, type.declaration, "SyntaxError");
             }
@@ -96,7 +98,7 @@ export class ScopeManager {
     }
     // Defines a `var` variable (hoisted to function or global scope).
     defineVar(name, type) {
-        if (this.reservedKeywords.has(name) && !type.isBuiltin) {
+        if (RESERVED_KEYWORDS.has(name) && !type.isBuiltin) {
             if (type.declaration) {
                 throw new CompilerError(`Unexpected reserved word "${name}"`, type.declaration, "SyntaxError");
             }

package/dist/analysis/typeAnalyzer.js

@@ -47,6 +47,22 @@ export class TypeAnalyzer {
     labelStack = [];
     loopDepth = 0;
     switchDepth = 0;
+    defineParameter(nameNode, p, type) {
+        if (ts.isIdentifier(nameNode)) {
+            this.scopeManager.define(nameNode.text, {
+                type: type || getParameterType(p),
+                isParameter: true,
+                declaration: p,
+            });
+        }
+        else {
+            nameNode.elements.forEach((element) => {
+                if (ts.isBindingElement(element)) {
+                    this.defineParameter(element.name, p, type);
+                }
+            });
+        }
+    }
     analyze(ast) {
         this.nodeToScope.set(ast, this.scopeManager.currentScope);
         const crossScopeModificationVisitor = (node) => {
@@ -246,11 +262,7 @@ export class TypeAnalyzer {
                             if (p.getText() == "this") { // Catch invalid parameters
                                 throw new CompilerError("Cannot use 'this' as a parameter name.", p, "SyntaxError");
                             }
-                            this.scopeManager.define(p.name.getText(), {
-                                type: getParameterType(p),
-                                isParameter: true,
-                                declaration: p,
-                            });
+                            this.defineParameter(p.name, p);
                         });
                         this.functionStack.push(node);
                     }
@@ -284,11 +296,7 @@ export class TypeAnalyzer {
                             if (p.getText() == "this") { // Catch invalid parameters
                                 throw new CompilerError("Cannot use 'this' as a parameter name.", p, "SyntaxError");
                             }
-                            this.scopeManager.define(p.name.getText(), {
-                                type: getParameterType(p),
-                                isParameter: true,
-                                declaration: p,
-                            });
+                            this.defineParameter(p.name, p);
                         });
                         this.functionStack.push(node);
                     }
@@ -323,11 +331,7 @@ export class TypeAnalyzer {
                             if (p.getText() == "this") { // Catch invalid parameters
                                 throw new CompilerError("Cannot use 'this' as a parameter name.", p, "SyntaxError");
                             }
-                            this.scopeManager.define(p.name.getText(), {
-                                type: getParameterType(p),
-                                isParameter: true,
-                                declaration: p,
-                            });
+                            this.defineParameter(p.name, p);
                         });
                         this.functionStack.push(node);
                     }
@@ -394,11 +398,7 @@ export class TypeAnalyzer {
                         this.functionTypeInfo.set(node, funcType);
                         this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
-                        node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
-                            type: "auto",
-                            isParameter: true,
-                            declaration: p,
-                        }));
+                        node.parameters.forEach((p) => this.defineParameter(p.name, p, "auto"));
                         this.functionStack.push(node);
                     }
                 },
@@ -422,11 +422,7 @@ export class TypeAnalyzer {
                         this.functionTypeInfo.set(node, funcType);
                         this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
-                        node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
-                            type: "auto",
-                            isParameter: true,
-                            declaration: p,
-                        }));
+                        node.parameters.forEach((p) => this.defineParameter(p.name, p, "auto"));
                         this.functionStack.push(node); // Constructor acts like a function
                     }
                 },

package/dist/cli/index.js

@@ -7,8 +7,8 @@ import { CompilerError } from "../core/error.js";
 import { Interpreter } from "../index.js";
 import { parseArgs } from "./args.js";
 import { COLORS } from "./colors.js";
-import { getLatestMtime } from "./file-utils.js";
 import { Spinner } from "./spinner.js";
+import { getLatestMtime, msToHumanReadable } from "./utils.js";
 const pkgDir = path.dirname(path.dirname(import.meta.dirname));
 async function main() {
     const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
@@ -30,7 +30,7 @@ async function main() {
     const mode = isRelease ? "release" : "debug";
     console.log(`${COLORS.bold}JSPP Compiler${COLORS.reset} ${COLORS.dim}v${pkg.version}${COLORS.reset}`);
     console.log(`Mode: ${isRelease ? COLORS.green : COLORS.yellow}${mode.toUpperCase()}${COLORS.reset}\n`);
-    const flags = isRelease ? ["-O3", "-DNDEBUG"] : ["-O0"];
+    const flags = isRelease ? ["-O3", "-DNDEBUG"] : ["-Og", "-ftime-report"];
     if (process.platform === "win32") {
         flags.push("-Wa,-mbig-obj");
     }
@@ -51,7 +51,8 @@ async function main() {
         // 2. Precompiled Header Check
         spinner.text = "Checking precompiled headers...";
         spinner.start();
-        const pchFile = path.join(pchDir, "index.hpp.gch");
+        const pchFile = path.join(pchDir, "jspp.hpp.gch");
+        const runtimeLibPath = path.join(pchDir, "libjspp.a");
         let shouldRebuild = false;
         try {
             const pchStats = await fs.stat(pchFile);
@@ -96,10 +97,15 @@ async function main() {
         spinner.start();
         // Ensure output directory exists
         await fs.mkdir(path.dirname(exeFilePath), { recursive: true });
+        const compileStartTime = performance.now();
         const compile = spawn("g++", [
             "-std=c++23",
             ...flags,
+            "-Winvalid-pch",
+            "-include",
+            "jspp.hpp",
             cppFilePath,
+            runtimeLibPath,
             "-o",
             exeFilePath,
             "-I",
@@ -122,7 +128,11 @@ async function main() {
             console.error(stderr);
             process.exit(1);
         }
-        spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset}`);
+        const compileEndTime = performance.now();
+        const compileTime = msToHumanReadable(compileEndTime - compileStartTime);
+        spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset} in ${COLORS.dim}${COLORS.bold}${compileTime}${COLORS.reset}`);
+        // const stderr = Buffer.concat(compileStderrChunks).toString();
+        // console.log(stderr);
         // Clean up C++ file if not requested to keep
         if (!keepCpp) {
             try {

package/dist/cli/utils.js

@@ -0,0 +1,61 @@
+import fs from "fs/promises";
+import path from "path";
+export async function getLatestMtime(dirPath) {
+    let maxMtime = 0;
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            const nestedMtime = await getLatestMtime(fullPath);
+            if (nestedMtime > maxMtime)
+                maxMtime = nestedMtime;
+        }
+        else {
+            const stats = await fs.stat(fullPath);
+            if (stats.mtimeMs > maxMtime)
+                maxMtime = stats.mtimeMs;
+        }
+    }
+    return maxMtime;
+}
+/**
+ * Converts milliseconds to a human-readable format.
+ * @param ms - The time in milliseconds
+ * @returns A formatted string (e.g., "2 hours, 1 minute, 4 seconds")
+ */
+export function msToHumanReadable(ms) {
+    if (ms < 0) {
+        throw new Error("Time cannot be negative");
+    }
+    if (ms === 0) {
+        return "0 seconds";
+    }
+    // Define time constants in milliseconds
+    const MS_PER_SECOND = 1000;
+    const MS_PER_MINUTE = 60 * MS_PER_SECOND;
+    const MS_PER_HOUR = 60 * MS_PER_MINUTE;
+    const MS_PER_DAY = 24 * MS_PER_HOUR;
+    // Calculate each unit
+    const days = Math.floor(ms / MS_PER_DAY);
+    const hours = Math.floor((ms % MS_PER_DAY) / MS_PER_HOUR);
+    const minutes = Math.floor((ms % MS_PER_HOUR) / MS_PER_MINUTE);
+    const seconds = Math.floor((ms % MS_PER_MINUTE) / MS_PER_SECOND);
+    // Array to hold the formatted parts
+    const parts = [];
+    // Helper function to handle pluralization
+    const addPart = (value, unit) => {
+        if (value > 0) {
+            parts.push(`${value} ${unit}${value > 1 ? "s" : ""}`);
+        }
+    };
+    addPart(days, "day");
+    addPart(hours, "hour");
+    addPart(minutes, "minute");
+    addPart(seconds, "second");
+    // If the time was less than 1 second, it will be empty
+    if (parts.length === 0) {
+        return `${ms} millisecond${ms > 1 ? "s" : ""}`;
+    }
+    // Join the parts with a comma and space
+    return parts.join(", ");
+}

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

@@ -42,16 +42,16 @@ export function visitClassDeclaration(node, context) {
         // Default constructor
         if (parentName) {
             constructorLambda =
-                `jspp::AnyValue::make_class([=](jspp::AnyValue ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
-                 auto __parent = ${parentName};
-                 __parent.call(${this.globalThisVar}, args, "super");
-                 return jspp::Constants::UNDEFINED;
+                `jspp::AnyValue::make_class([=](jspp::AnyValue ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
+                 auto __parent = ${parentName};
+                 __parent.call(${this.globalThisVar}, args, "super");
+                 return jspp::Constants::UNDEFINED;
              }, "${className}")`;
         }
         else {
             constructorLambda =
-                `jspp::AnyValue::make_class([=](jspp::AnyValue ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
-                 return jspp::Constants::UNDEFINED;
+                `jspp::AnyValue::make_class([=](jspp::AnyValue ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
+                 return jspp::Constants::UNDEFINED;
              }, "${className}")`;
         }
     }

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

@@ -50,7 +50,7 @@ export function visitForStatement(node, context) {
                         type: declType,
                         checks: { initialized: true },
                     });
-                    if (typeInfo.needsHeapAllocation) {
+                    if (typeInfo?.needsHeapAllocation) {
                         initializerCode =
                             `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
                     }
@@ -124,7 +124,7 @@ export function visitForInStatement(node, context) {
             varName = decl.name.getText();
             const scope = this.getScopeForNode(decl);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(varName, scope);
-            if (typeInfo.needsHeapAllocation) {
+            if (typeInfo?.needsHeapAllocation) {
                 code +=
                     `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 assignmentTarget = `*${varName}`;
@@ -140,7 +140,7 @@ export function visitForInStatement(node, context) {
         varName = forIn.initializer.getText();
         const scope = this.getScopeForNode(forIn.initializer);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(varName, scope);
-        assignmentTarget = typeInfo.needsHeapAllocation
+        assignmentTarget = typeInfo?.needsHeapAllocation
             ? `*${varName}`
             : varName;
     }
@@ -154,11 +154,10 @@ export function visitForInStatement(node, context) {
     }
     const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
     code +=
-        `${this.indent()}std::vector<std::string> ${keysVar} = jspp::Access::get_object_keys(${derefExpr});\n`;
-    code += `${this.indent()}for (const auto& ${varName}_str : ${keysVar}) {\n`;
+        `${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} = jspp::AnyValue::make_string(${varName}_str);\n`;
+    code += `${this.indent()}${assignmentTarget} = ${varName}_val;\n`;
     code += this.visit(forIn.statement, {
         ...context,
         currentLabel: undefined,
@@ -196,7 +195,7 @@ export function visitForOfStatement(node, context) {
             elemName = decl.name.getText();
             const scope = this.getScopeForNode(decl);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemName, scope);
-            if (typeInfo.needsHeapAllocation) {
+            if (typeInfo?.needsHeapAllocation) {
                 code +=
                     `${this.indent()}auto ${elemName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 assignmentTarget = `*${elemName}`;
@@ -212,7 +211,7 @@ export function visitForOfStatement(node, context) {
         elemName = forOf.initializer.getText();
         const scope = this.getScopeForNode(forOf.initializer);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemName, scope);
-        assignmentTarget = typeInfo.needsHeapAllocation
+        assignmentTarget = typeInfo?.needsHeapAllocation
             ? `*${elemName}`
             : elemName;
     }
@@ -440,12 +439,14 @@ export function visitSwitchStatement(node, context) {
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
         // Generate native name
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        const argumentKeywordIsUsed = this.isVariableUsedWithoutDeclaration("arguments", stmt.body);
         hoistedSymbols.update(funcName, {
             features: {
                 native: {
                     type: "lambda",
                     name: nativeName,
                     parameters: this.validateFunctionParams(stmt.parameters),
+                    argumentKeywordIsUsed,
                 },
             },
         });

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

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { RESERVED_VAR_NAMES_FOR_STRICT_MODE } from "../../analysis/scope.js";
 import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function visitVariableDeclarationList(node, context) {
@@ -17,6 +18,9 @@ export function visitVariableDeclaration(node, context) {
         return this.generateDestructuring(varDecl.name, rhsCode, context);
     }
     const name = varDecl.name.getText();
+    if (RESERVED_VAR_NAMES_FOR_STRICT_MODE.has(name)) {
+        throw new CompilerError(`Cannot declare a variable named '${name}' in strict mode.`, varDecl.name, "SyntaxError");
+    }
     const scope = this.getScopeForNode(varDecl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
     // Mark the symbol as checked
@@ -34,7 +38,7 @@ export function visitVariableDeclaration(node, context) {
             const initTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, initScope);
             const varName = this.getJsVarName(initExpr);
             // Check if both target and initializer are heap allocated
-            if (typeInfo.needsHeapAllocation &&
+            if (typeInfo?.needsHeapAllocation &&
                 initTypeInfo?.needsHeapAllocation) {
                 shouldSkipDeref = true;
             }
@@ -55,6 +59,8 @@ export function visitVariableDeclaration(node, context) {
             const scopeNode = ts.isVariableDeclarationList(varDecl.parent)
                 ? varDecl.parent.parent.parent
                 : varDecl.parent;
+            const argumentKeywordIsUsed = ts.isFunctionExpression(initExpr) &&
+                this.isVariableUsedWithoutDeclaration("arguments", initExpr.body);
             // Mark before further visits
             context.localScopeSymbols.update(name, {
                 features: {
@@ -62,6 +68,7 @@ export function visitVariableDeclaration(node, context) {
                         type: "lambda",
                         name: nativeName,
                         parameters: this.validateFunctionParams(initExpr.parameters),
+                        argumentKeywordIsUsed,
                     },
                 },
             });
@@ -92,7 +99,7 @@ export function visitVariableDeclaration(node, context) {
         (!context.localScopeSymbols.has(name));
     const assignmentTarget = shouldDeref
         ? this.getDerefCode(name, name, context, typeInfo)
-        : (typeInfo.needsHeapAllocation && !shouldSkipDeref
+        : (typeInfo?.needsHeapAllocation && !shouldSkipDeref
             ? `*${name}`
             : name);
     if (nativeLambdaCode)
@@ -123,7 +130,7 @@ export function visitVariableDeclaration(node, context) {
         const initValue = initializer
             ? initializer.substring(3)
             : "jspp::Constants::UNDEFINED";
-        if (typeInfo.needsHeapAllocation) {
+        if (typeInfo?.needsHeapAllocation) {
             return `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
         }
         else {

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

@@ -1,4 +1,6 @@
 import ts from "typescript";
+import { RESERVED_VAR_NAMES_FOR_STRICT_MODE } from "../../analysis/scope.js";
+import { CompilerError } from "../error.js";
 import { visitObjectPropertyName } from "./expression-handlers.js";
 import { CodeGenerator } from "./index.js";
 import {} from "./visitor.js";
@@ -11,6 +13,9 @@ export function generateDestructuring(lhs, rhsCode, context) {
     const genAssignment = (pattern, valueCode) => {
         if (ts.isIdentifier(pattern)) {
             const name = pattern.text;
+            if (RESERVED_VAR_NAMES_FOR_STRICT_MODE.has(name)) {
+                throw new CompilerError(`Cannot destructure to a variable named '${name}' in strict mode.`, pattern, "SyntaxError");
+            }
             const scope = this.getScopeForNode(pattern);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
             // Mark initialized if it's a declaration
@@ -103,7 +108,7 @@ export function generateDestructuring(lhs, rhsCode, context) {
             });
             // Call the return method to clean resources
             innerCode +=
-                `${this.indent()}jspp::Access::call_optional_property_with_optional_call(${iterVar}, "return", {}, "return");\n`;
+                `${this.indent()}jspp::Access::call_optional_property_with_optional_call(${iterVar}, "return", {});\n`;
             return innerCode;
         }
         else if (ts.isObjectBindingPattern(pattern) ||
@@ -150,9 +155,9 @@ export function generateDestructuring(lhs, rhsCode, context) {
                 }
                 if (isRest) {
                     const keysArray = `{${seenKeys.map((k) => k.startsWith('"') && k.endsWith('"')
-                        ? k
-                        : `(${k}).to_property_key()`).join(", ")}}`;
-                    const restValueCode = `jspp::Access::get_rest_object(${valueCode}, std::vector<std::string>${keysArray})`;
+                        ? `jspp::AnyValue::make_string(${k})`
+                        : `(${k})`).join(", ")}}`;
+                    const restValueCode = `jspp::Access::get_rest_object(${valueCode}, std::vector<jspp::AnyValue>${keysArray})`;
                     innerCode += genAssignment(target, restValueCode);
                 }
                 else {