@ugo-studio/jspp 0.2.8 → 0.3.0

package/dist/core/codegen/helpers.js

@@ -3,15 +3,39 @@ import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope.js";
 import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
 import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
+/**
+ * Checks if an identifier refers to a built-in JavaScript object (e.g., console, Math).
+ *
+ * @param node The identifier node to check.
+ * @returns True if it's a built-in object.
+ */
 export function isBuiltinObject(node) {
     return BUILTIN_OBJECTS.values().some((obj) => obj.name === node.text);
 }
+/**
+ * Collects all symbols declared within a node's subtree.
+ *
+ * @param node The node to scan for declarations.
+ * @returns A set of declared symbol names.
+ */
 export function getDeclaredSymbols(node) {
     const symbols = new Set();
+    const collectNames = (name) => {
+        if (ts.isIdentifier(name)) {
+            symbols.add(name.text);
+        }
+        else {
+            name.elements.forEach((element) => {
+                if (ts.isBindingElement(element)) {
+                    collectNames(element.name);
+                }
+            });
+        }
+    };
     const visitor = (child) => {
         if (ts.isVariableDeclaration(child)) {
             // Handles let, const, var
-            symbols.add(child.name.getText());
+            collectNames(child.name);
         }
         else if (ts.isFunctionDeclaration(child) && child.name) {
             // Handles function declarations
@@ -27,17 +51,24 @@ export function getDeclaredSymbols(node) {
         }
         else if (ts.isParameter(child)) {
             // Handles function parameters
-            symbols.add(child.name.getText());
+            collectNames(child.name);
         }
         else if (ts.isCatchClause(child) && child.variableDeclaration) {
             // Handles catch clause variable
-            symbols.add(child.variableDeclaration.name.getText());
+            collectNames(child.variableDeclaration.name);
         }
         ts.forEachChild(child, visitor);
     };
     visitor(node);
     return symbols;
 }
+/**
+ * Generates a unique name by appending a counter to a prefix, avoiding existing symbols.
+ *
+ * @param prefix The base name for the unique identifier.
+ * @param namesToAvoid Sets or maps of names that should not be used.
+ * @returns A unique identifier string.
+ */
 export function generateUniqueName(prefix, ...namesToAvoid) {
     let name = `${prefix}${this.uniqueNameCounter}`;
     while (namesToAvoid.some((names) => names.has(name))) {
@@ -47,6 +78,13 @@ export function generateUniqueName(prefix, ...namesToAvoid) {
     this.uniqueNameCounter++;
     return name;
 }
+/**
+ * Generates a unique name for a caught exception variable.
+ *
+ * @param exceptionNameToAvoid The name of the exception variable to potentially avoid shadowing.
+ * @param otherNamesToAvoid Additional names to avoid.
+ * @returns A unique identifier string for the exception.
+ */
 export function generateUniqueExceptionName(exceptionNameToAvoid, ...otherNamesToAvoid) {
     let prefix = `__caught_exception_`;
     if (exceptionNameToAvoid) {
@@ -54,6 +92,15 @@ export function generateUniqueExceptionName(exceptionNameToAvoid, ...otherNamesT
     }
     return this.generateUniqueName(prefix, ...otherNamesToAvoid);
 }
+/**
+ * Retrieves the scope associated with a given node.
+ *
+ * Walks up the parent chain until a node with an associated scope is found.
+ *
+ * @param node The node to find the scope for.
+ * @returns The associated Scope.
+ * @throws CompilerError if no scope is found.
+ */
 export function getScopeForNode(node) {
     let current = node;
     while (current) {
@@ -69,9 +116,20 @@ export function getScopeForNode(node) {
     }
     return rootScope;
 }
+/**
+ * Returns a string of spaces representing the current indentation level.
+ *
+ * @returns An indentation string.
+ */
 export function indent() {
     return "  ".repeat(this.indentationLevel);
 }
+/**
+ * Escapes special characters in a string for safe use in C++ string literals.
+ *
+ * @param str The string to escape.
+ * @returns The escaped string.
+ */
 export function escapeString(str) {
     return str
         .replace(/\\/g, "\\\\")
@@ -81,9 +139,27 @@ export function escapeString(str) {
         .replace(/\t/g, "\\t")
         .replace(/\?/g, "\\?");
 }
+/**
+ * Formats a JavaScript variable name as a C++ string literal for error reporting or property access.
+ *
+ * @param node The identifier node.
+ * @returns The variable name wrapped in quotes.
+ */
 export function getJsVarName(node) {
     return `"${node.text}"`;
 }
+/**
+ * Generates C++ code to dereference a variable, handling TDZ and heap allocation.
+ *
+ * If the symbol is not yet initialized, it generates a call to a deref helper
+ * that performs a runtime check.
+ *
+ * @param nodeText The C++ expression for the variable.
+ * @param varName The JavaScript name of the variable.
+ * @param context The current visit context.
+ * @param typeInfo Type information for the variable.
+ * @returns The C++ code for accessing the variable's value.
+ */
 export function getDerefCode(nodeText, varName, context, typeInfo) {
     // Make sure varName is incased in quotes
     if (!varName.startsWith('"'))
@@ -111,6 +187,13 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
         return `jspp::Access::deref_stack(${nodeText}, ${varName})`;
     }
 }
+/**
+ * Marks a symbol as initialized in the provided symbol tables.
+ *
+ * @param name The name of the symbol.
+ * @param topLevel The global symbol table.
+ * @param local The local symbol table.
+ */
 export function markSymbolAsInitialized(name, topLevel, local) {
     if (topLevel.has(name)) {
         topLevel.update(name, {
@@ -123,18 +206,34 @@ export function markSymbolAsInitialized(name, topLevel, local) {
         });
     }
 }
+/**
+ * Determines the appropriate C++ return command (return or co_return) based on context.
+ *
+ * @param context Partial visit context.
+ * @returns "co_return" for generators/async, "return" otherwise.
+ */
 export function getReturnCommand(context) {
     return (context.isInsideGeneratorFunction || context.isInsideAsyncFunction)
         ? "co_return"
         : "return";
 }
+/**
+ * Generates C++ code to hoist a declaration (var, let, const, function, class, enum).
+ *
+ * It registers the symbol and generates the variable declaration, initializing
+ * block-scoped variables to UNINITIALIZED for TDZ support.
+ *
+ * @param decl The declaration node.
+ * @param hoistedSymbols The symbol table to register with.
+ * @param scopeNode The node representing the current scope.
+ * @returns The C++ declaration code.
+ * @throws CompilerError if a duplicate declaration is found.
+ */
 export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
-    const name = decl.name?.getText();
-    if (!name) {
-        return `/* Unknown declaration name: ${ts.SyntaxKind[decl.kind]} */`;
-    }
-    const isLet = (decl.parent.flags & (ts.NodeFlags.Let)) !== 0;
-    const isConst = (decl.parent.flags & (ts.NodeFlags.Const)) !== 0;
+    const isLet = ts.isVariableDeclaration(decl) &&
+        (decl.parent.flags & (ts.NodeFlags.Let)) !== 0;
+    const isConst = ts.isVariableDeclaration(decl) &&
+        (decl.parent.flags & (ts.NodeFlags.Const)) !== 0;
     const declType = isLet
         ? DeclarationType.let
         : isConst
@@ -146,52 +245,89 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                     : ts.isEnumDeclaration(decl)
                         ? DeclarationType.enum
                         : DeclarationType.var;
-    if (hoistedSymbols.has(name)) {
-        const existingSymbol = hoistedSymbols.get(name);
-        // Don't allow multiple declaration of `let`,`const`,`function`, `class` or `enum` variables
-        if (existingSymbol?.type === DeclarationType.let ||
-            existingSymbol?.type === DeclarationType.const ||
-            existingSymbol?.type === DeclarationType.function ||
-            existingSymbol?.type === DeclarationType.class ||
-            existingSymbol?.type === DeclarationType.enum ||
-            existingSymbol?.type !== declType) {
-            throw new CompilerError(`Identifier '${name}' has already been declared.`, decl, "SyntaxError");
-        }
-        // `var` variables can be declared multiple times
-        return "";
-    }
-    else {
-        // Add the symbol to the hoisted symbols
-        if (declType === DeclarationType.function) {
-            const isAsync = this.isAsyncFunction(decl);
-            const isGenerator = this.isGeneratorFunction(decl);
-            hoistedSymbols.add(name, {
-                type: declType,
-                features: { isAsync, isGenerator },
-            });
-            // Don't hoist functions not used as a variable
-            // they will be called with their native lambdas
-            if (!this.isFunctionUsedAsValue(decl, scopeNode) &&
-                !this.isFunctionUsedBeforeDeclaration(name, scopeNode)) {
+    const hoistName = (nameNode) => {
+        if (ts.isIdentifier(nameNode)) {
+            const name = nameNode.text;
+            if (hoistedSymbols.has(name)) {
+                const existingSymbol = hoistedSymbols.get(name);
+                // Don't allow multiple declaration of `let`,`const`,`function`, `class` or `enum` variables
+                if (existingSymbol?.type === DeclarationType.let ||
+                    existingSymbol?.type === DeclarationType.const ||
+                    existingSymbol?.type === DeclarationType.function ||
+                    existingSymbol?.type === DeclarationType.class ||
+                    existingSymbol?.type === DeclarationType.enum ||
+                    existingSymbol?.type !== declType) {
+                    throw new CompilerError(`Identifier '${name}' has already been declared.`, decl, "SyntaxError");
+                }
+                // `var` variables can be declared multiple times
                 return "";
             }
+            else {
+                // Add the symbol to the hoisted symbols
+                if (ts.isFunctionDeclaration(decl) ||
+                    (ts.isVariableDeclaration(decl) && decl.initializer &&
+                        nameNode === decl.name &&
+                        (ts.isArrowFunction(decl.initializer) ||
+                            ts.isFunctionExpression(decl.initializer)))) {
+                    const funcExpr = ts.isVariableDeclaration(decl)
+                        ? decl.initializer
+                        : decl;
+                    const isAsync = this.isAsyncFunction(funcExpr);
+                    const isGenerator = this.isGeneratorFunction(funcExpr);
+                    hoistedSymbols.add(name, {
+                        type: declType,
+                        features: { isAsync, isGenerator },
+                    });
+                    // Don't hoist declarations not used as a variable
+                    // They will be called with their native lambda/value
+                    if (!this.isDeclarationUsedAsValue(decl, scopeNode) &&
+                        !this.isDeclarationUsedBeforeInitialization(name, scopeNode)) {
+                        return "";
+                    }
+                }
+                else {
+                    hoistedSymbols.add(name, { type: declType });
+                }
+            }
+            const scope = this.getScopeForNode(decl);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+            const initializer = isLet || isConst || ts.isClassDeclaration(decl)
+                ? "jspp::Constants::UNINITIALIZED"
+                : "jspp::Constants::UNDEFINED";
+            if (typeInfo.needsHeapAllocation) {
+                return `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+            }
+            else {
+                return `${this.indent()}jspp::AnyValue ${name} = ${initializer};\n`;
+            }
         }
         else {
-            hoistedSymbols.add(name, { type: declType });
+            let code = "";
+            nameNode.elements.forEach((element) => {
+                if (ts.isBindingElement(element)) {
+                    code += hoistName(element.name);
+                }
+            });
+            return code;
         }
-    }
-    const scope = this.getScopeForNode(decl);
-    const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
-    const initializer = isLet || isConst || ts.isClassDeclaration(decl)
-        ? "jspp::Constants::UNINITIALIZED"
-        : "jspp::Constants::UNDEFINED";
-    if (typeInfo.needsHeapAllocation) {
-        return `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+    };
+    if (ts.isVariableDeclaration(decl)) {
+        return hoistName(decl.name);
     }
     else {
-        return `${this.indent()}jspp::AnyValue ${name} = ${initializer};\n`;
+        const nameNode = decl.name;
+        if (!nameNode) {
+            return `/* Unknown declaration name: ${ts.SyntaxKind[decl.kind]} */`;
+        }
+        return hoistName(nameNode);
     }
 }
+/**
+ * Checks if a function node is a generator function.
+ *
+ * @param node The node to check.
+ * @returns True if it's a generator.
+ */
 export function isGeneratorFunction(node) {
     return ((ts.isFunctionDeclaration(node) ||
         ts.isFunctionExpression(node) ||
@@ -199,6 +335,12 @@ export function isGeneratorFunction(node) {
         !!node.asteriskToken // generator indicator
     );
 }
+/**
+ * Checks if a function node is an async function.
+ *
+ * @param node The node to check.
+ * @returns True if it's async.
+ */
 export function isAsyncFunction(node) {
     return ((ts.isFunctionDeclaration(node) ||
         ts.isFunctionExpression(node) ||
@@ -207,10 +349,23 @@ export function isAsyncFunction(node) {
         (ts.getCombinedModifierFlags(node) &
             ts.ModifierFlags.Async) !== 0);
 }
+/**
+ * Combines top-level and local symbol tables for a nested visit.
+ *
+ * @param topLevel Global/outer symbol table.
+ * @param local Local/inner symbol table.
+ * @returns A new DeclaredSymbols instance representing the merged scope.
+ */
 export function prepareScopeSymbolsForVisit(topLevel, local) {
     // Join the top and local scopes
     return new DeclaredSymbols(topLevel, local);
 }
+/**
+ * Determines if a statement should be ignored (e.g., ambient declarations).
+ *
+ * @param stmt The statement to check.
+ * @returns True if the statement should be ignored.
+ */
 export function shouldIgnoreStatement(stmt) {
     // Ignore variable statements with 'declare' modifier
     if (ts.isVariableStatement(stmt)) {
@@ -221,6 +376,13 @@ export function shouldIgnoreStatement(stmt) {
     }
     return false;
 }
+/**
+ * Collects all function-scoped (var) declarations within a node,
+ * respecting function boundaries.
+ *
+ * @param node The root node to scan.
+ * @returns An array of variable declarations.
+ */
 export function collectFunctionScopedDeclarations(node) {
     const decls = [];
     function visit(n) {
@@ -275,6 +437,12 @@ export function collectFunctionScopedDeclarations(node) {
     ts.forEachChild(node, visit);
     return decls;
 }
+/**
+ * Collects block-scoped (let/const) declarations directly within a list of statements.
+ *
+ * @param statements The statements to scan.
+ * @returns An array of variable declarations.
+ */
 export function collectBlockScopedDeclarations(statements) {
     const decls = [];
     for (const stmt of statements) {
@@ -292,10 +460,22 @@ export function collectBlockScopedDeclarations(statements) {
     }
     return decls;
 }
-export function isFunctionUsedAsValue(decl, root) {
-    const name = decl.name?.getText();
-    if (!name)
+/**
+ * Checks if a declaration is used as a value within a given node.
+ *
+ * This is used to determine if a hoisted function declaration needs to be
+ * wrapped in an AnyValue and assigned to a variable, or if it can be
+ * optimized to only use its native lambda.
+ *
+ * @param decl The declaration to check.
+ * @param root The root node to search for usages within.
+ * @returns True if the declaration is used as a value.
+ */
+export function isDeclarationUsedAsValue(decl, root) {
+    const nameNode = decl.name;
+    if (!nameNode || !ts.isIdentifier(nameNode))
         return false;
+    const name = nameNode.text;
     let isUsed = false;
     const visitor = (node) => {
         if (isUsed)
@@ -336,14 +516,62 @@ export function isFunctionUsedAsValue(decl, root) {
     ts.forEachChild(root, visitor);
     return isUsed;
 }
-export function isFunctionUsedBeforeDeclaration(name, root) {
+/**
+ * Checks if a declaration is called as a function (e.g. decl()) within a given node.
+ *
+ * @param decl The declaration to check.
+ * @param root The root node to search for usages within.
+ * @returns True if the declaration is called as a function.
+ */
+export function isDeclarationCalledAsFunction(decl, root) {
+    const nameNode = decl.name;
+    if (!nameNode || !ts.isIdentifier(nameNode))
+        return false;
+    const name = nameNode.text;
+    let isCalled = false;
+    const visitor = (node) => {
+        if (isCalled)
+            return;
+        if (ts.isIdentifier(node) && node.text === name) {
+            const scope = this.getScopeForNode(node);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(node.text, scope);
+            if (typeInfo?.declaration === decl) {
+                const parent = node.parent;
+                if (ts.isCallExpression(parent) && parent.expression === node) {
+                    isCalled = true;
+                }
+            }
+        }
+        if (!isCalled) {
+            ts.forEachChild(node, visitor);
+        }
+    };
+    ts.forEachChild(root, visitor);
+    return isCalled;
+}
+/**
+ * Checks if a declaration is used before it is initialized within a given node.
+ *
+ * This helps determine if a hoisted declaration (like a function or class)
+ * might be accessed before its assignment logic is executed, necessitating
+ * an AnyValue wrapper for TDZ or forward-reference support.
+ *
+ * @param name The name of the declaration to check.
+ * @param root The root node to search for usages within.
+ * @returns True if the declaration is used before initialization.
+ */
+export function isDeclarationUsedBeforeInitialization(name, root) {
     let declPos = -1;
     let foundDecl = false;
-    // Helper to find the function declaration position
+    // Helper to find the declaration position
     function findDecl(node) {
         if (foundDecl)
             return;
-        if (ts.isFunctionDeclaration(node) && node.name?.text === name) {
+        if ((ts.isFunctionDeclaration(node) ||
+            ts.isClassDeclaration(node) ||
+            ts.isVariableDeclaration(node) ||
+            ts.isEnumDeclaration(node)) &&
+            node.name && ts.isIdentifier(node.name) && node.name.text === name) {
             declPos = node.getStart();
             foundDecl = true;
         }
@@ -410,6 +638,14 @@ export function isFunctionUsedBeforeDeclaration(name, root) {
     visit(root);
     return isUsedBefore;
 }
+/**
+ * Validates and filters function parameters, checking for illegal "this"
+ * and correctly positioned rest parameters.
+ *
+ * @param parameters The parameters to validate.
+ * @returns A filtered array of valid parameters.
+ * @throws CompilerError for invalid parameter usage.
+ */
 export function validateFunctionParams(parameters) {
     return parameters.filter((p) => {
         if (p.name.getText() === "this") {

package/dist/core/codegen/index.js

@@ -1,6 +1,7 @@
 import { DeclaredSymbols } from "../../ast/symbols.js";
 import { generateLambdaComponents, generateNativeLambda, generateWrappedLambda, } from "./function-handlers.js";
-import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isFunctionUsedAsValue, isFunctionUsedBeforeDeclaration, isGeneratorFunction, markSymbolAsInitialized, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isDeclarationCalledAsFunction, isDeclarationUsedAsValue, isDeclarationUsedBeforeInitialization, isGeneratorFunction, markSymbolAsInitialized, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
+import { generateDestructuring } from "./destructuring-handlers.js";
 import { visit } from "./visitor.js";
 const MODULE_NAME = "__entry_point__";
 export class CodeGenerator {
@@ -27,9 +28,11 @@ export class CodeGenerator {
     isAsyncFunction = isAsyncFunction;
     prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
     markSymbolAsInitialized = markSymbolAsInitialized;
-    isFunctionUsedAsValue = isFunctionUsedAsValue;
-    isFunctionUsedBeforeDeclaration = isFunctionUsedBeforeDeclaration;
+    isDeclarationCalledAsFunction = isDeclarationCalledAsFunction;
+    isDeclarationUsedAsValue = isDeclarationUsedAsValue;
+    isDeclarationUsedBeforeInitialization = isDeclarationUsedBeforeInitialization;
     validateFunctionParams = validateFunctionParams;
+    generateDestructuring = generateDestructuring;
     // function handlers
     generateLambdaComponents = generateLambdaComponents;
     generateNativeLambda = generateNativeLambda;
@@ -62,7 +65,7 @@ export class CodeGenerator {
         mainCode += `  try {\n`;
         mainCode += `    jspp::setup_process_argv(argc, argv);\n`;
         mainCode += `    auto p = ${MODULE_NAME}();\n`;
-        mainCode += `    p.then(nullptr, [](const jspp::AnyValue& err) {\n`;
+        mainCode += `    p.then(nullptr, [](jspp::AnyValue err) {\n`;
         mainCode +=
             `        auto error = std::make_shared<jspp::AnyValue>(err);\n`;
         mainCode +=

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

@@ -70,11 +70,13 @@ export function visitSourceFile(node, context) {
             noTypeSignature: true,
         });
         // Generate native lambda
-        const nativeLambda = this.generateNativeLambda(lambdaComps);
-        code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+        if (this.isDeclarationCalledAsFunction(stmt, node)) {
+            const nativeLambda = this.generateNativeLambda(lambdaComps);
+            code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+        }
         // Generate AnyValue wrapped lamda
-        if (this.isFunctionUsedAsValue(stmt, node) ||
-            this.isFunctionUsedBeforeDeclaration(funcName, node)) {
+        if (this.isDeclarationUsedAsValue(stmt, node) ||
+            this.isDeclarationUsedBeforeInitialization(funcName, node)) {
             const wrappedLambda = this.generateWrappedLambda(lambdaComps);
             code += `${this.indent()}*${funcName} = ${wrappedLambda};\n`;
         }
@@ -165,11 +167,13 @@ export function visitBlock(node, context) {
             noTypeSignature: true,
         });
         // Generate native lambda
-        const nativeLambda = this.generateNativeLambda(lambdaComps);
-        code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+        if (this.isDeclarationCalledAsFunction(stmt, node)) {
+            const nativeLambda = this.generateNativeLambda(lambdaComps);
+            code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+        }
         // Generate AnyValue wrapped lamda
-        if (this.isFunctionUsedAsValue(stmt, node) ||
-            this.isFunctionUsedBeforeDeclaration(funcName, node)) {
+        if (this.isDeclarationUsedAsValue(stmt, node) ||
+            this.isDeclarationUsedBeforeInitialization(funcName, node)) {
             const wrappedLambda = this.generateWrappedLambda(lambdaComps);
             code += `${this.indent()}*${funcName} = ${wrappedLambda};\n`;
         }
@@ -362,7 +366,7 @@ export function visitExpressionStatement(node, context) {
 export function visitThrowStatement(node, context) {
     const throwStmt = node;
     const expr = this.visit(throwStmt.expression, context);
-    return `${this.indent()}throw jspp::Exception(${expr});
+    return `${this.indent()}throw jspp::Exception(${expr});
 `;
 }
 export function visitTryStatement(node, context) {
@@ -436,10 +440,16 @@ export function visitTryStatement(node, context) {
                 code += `${this.indent()}{\n`; // Block scope
                 this.indentationLevel++;
                 if (tryStmt.catchClause.variableDeclaration) {
-                    const varName = tryStmt.catchClause.variableDeclaration.name
-                        .getText();
-                    code +=
-                        `${this.indent()}jspp::AnyValue ${varName} = ${caughtValVar};\n`;
+                    if (ts.isIdentifier(tryStmt.catchClause.variableDeclaration.name)) {
+                        const varName = tryStmt.catchClause.variableDeclaration
+                            .name
+                            .getText();
+                        code +=
+                            `${this.indent()}jspp::AnyValue ${varName} = ${caughtValVar};\n`;
+                    }
+                    else {
+                        code += this.generateDestructuring(tryStmt.catchClause.variableDeclaration.name, caughtValVar, context) + ";\n";
+                    }
                 }
                 const catchContext = { ...innerContext, exceptionName };
                 code += this.visit(tryStmt.catchClause.block, catchContext);
@@ -519,10 +529,16 @@ export function visitTryStatement(node, context) {
                 code += `${this.indent()}{\n`; // Block scope
                 this.indentationLevel++;
                 if (tryStmt.catchClause.variableDeclaration) {
-                    const varName = tryStmt.catchClause.variableDeclaration.name
-                        .getText();
-                    code +=
-                        `${this.indent()}jspp::AnyValue ${varName} = ${caughtValVar};\n`;
+                    if (ts.isIdentifier(tryStmt.catchClause.variableDeclaration.name)) {
+                        const varName = tryStmt.catchClause.variableDeclaration
+                            .name
+                            .getText();
+                        code +=
+                            `${this.indent()}jspp::AnyValue ${varName} = ${caughtValVar};\n`;
+                    }
+                    else {
+                        code += this.generateDestructuring(tryStmt.catchClause.variableDeclaration.name, caughtValVar, context) + ";\n";
+                    }
                 }
                 code += this.visit(tryStmt.catchClause.block, newContext);
                 this.indentationLevel--;
@@ -635,12 +651,16 @@ export function visitCatchClause(node, context) {
         throw new CompilerError("exceptionName not found in context for CatchClause", node, "CompilerBug");
     }
     if (catchClause.variableDeclaration) {
-        const varName = catchClause.variableDeclaration.name.getText();
         let code = `{\n`;
         this.indentationLevel++;
-        // The JS exception variable is always local to the catch block
-        code +=
-            `${this.indent()}jspp::AnyValue ${varName} = jspp::Exception::exception_to_any_value(${exceptionName});\n`;
+        const exceptionValueCode = `jspp::Exception::exception_to_any_value(${exceptionName})`;
+        if (ts.isIdentifier(catchClause.variableDeclaration.name)) {
+            const varName = catchClause.variableDeclaration.name.text;
+            code += `${this.indent()}jspp::AnyValue ${varName} = ${exceptionValueCode};\n`;
+        }
+        else {
+            code += this.generateDestructuring(catchClause.variableDeclaration.name, exceptionValueCode, context) + ";\n";
+        }
         code += this.visit(catchClause.block, context);
         this.indentationLevel--;
         code += `${this.indent()}}\n`;
@@ -684,11 +704,11 @@ export function visitYieldExpression(node, context) {
             code += `${this.indent()}auto ${iterableRef} = ${exprText};\n`;
             if (context.isInsideAsyncFunction) {
                 code +=
-                    `${this.indent()}auto ${iterator} = jspp::Access::get_async_object_value_iterator(${iterableRef}, ${varName});\n`;
+                    `${this.indent()}auto ${iterator} = jspp::Access::get_object_async_iterator(${iterableRef}, ${varName});\n`;
             }
             else {
                 code +=
-                    `${this.indent()}auto ${iterator} = jspp::Access::get_object_value_iterator(${iterableRef}, ${varName});\n`;
+                    `${this.indent()}auto ${iterator} = jspp::Access::get_object_iterator(${iterableRef}, ${varName});\n`;
             }
             code +=
                 `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("next");\n`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",