lt-script 1.0.0

package/dist/compiler/codegen/LuaEmitter.js

@@ -0,0 +1,748 @@
+import * as AST from '../parser/AST.js';
+/**
+ * LT → Lua Code Emitter
+ * Generates clean, readable Lua 5.4 code
+ */
+export class LuaEmitter {
+    indent = 0;
+    output = [];
+    tempId = 0;
+    usedVars = new Set();
+    nextTemp(prefix = '_v') {
+        return `${prefix}${++this.tempId}`;
+    }
+    emit(program) {
+        this.analyzeUsages(program);
+        for (const stmt of program.body) {
+            this.emitStatement(stmt);
+        }
+        return this.output.join('\n');
+    }
+    analyzeUsages(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (Array.isArray(node)) {
+            node.forEach(n => this.analyzeUsages(n));
+            return;
+        }
+        switch (node.kind) {
+            case AST.NodeType.Identifier:
+                this.usedVars.add(node.name);
+                break;
+            case AST.NodeType.VariableDecl:
+                if (node.values)
+                    node.values.forEach((v) => this.analyzeUsages(v));
+                break;
+            case AST.NodeType.AssignmentStmt:
+                if (node.values)
+                    node.values.forEach((v) => this.analyzeUsages(v));
+                node.targets.forEach((t) => this.analyzeUsages(t));
+                break;
+            case AST.NodeType.ReturnStmt:
+                if (node.values)
+                    node.values.forEach((v) => this.analyzeUsages(v));
+                break;
+            case AST.NodeType.FunctionDecl:
+                this.analyzeUsages(node.body);
+                if (node.params) {
+                    node.params.forEach((p) => {
+                        if (p.defaultValue)
+                            this.analyzeUsages(p.defaultValue);
+                    });
+                }
+                break;
+            case AST.NodeType.MemberExpr:
+            case AST.NodeType.OptionalChainExpr:
+                this.analyzeUsages(node.object);
+                if (node.computed)
+                    this.analyzeUsages(node.property);
+                break;
+            case AST.NodeType.TableLiteral:
+                node.fields.forEach((f) => {
+                    if (f.key && f.key.kind !== AST.NodeType.Identifier)
+                        this.analyzeUsages(f.key);
+                    this.analyzeUsages(f.value);
+                });
+                break;
+            default:
+                for (const key in node) {
+                    if (Object.prototype.hasOwnProperty.call(node, key)) {
+                        const val = node[key];
+                        if (val && typeof val === 'object')
+                            this.analyzeUsages(val);
+                    }
+                }
+        }
+    }
+    emitStatement(stmt) {
+        switch (stmt.kind) {
+            case AST.NodeType.VariableDecl:
+                this.emitVariableDecl(stmt);
+                break;
+            case AST.NodeType.AssignmentStmt:
+                this.emitAssignment(stmt);
+                break;
+            case AST.NodeType.CompoundAssignment:
+                this.emitCompoundAssignment(stmt);
+                break;
+            case AST.NodeType.IfStmt:
+                this.emitIfStmt(stmt);
+                break;
+            case AST.NodeType.ForStmt:
+                this.emitForStmt(stmt);
+                break;
+            case AST.NodeType.RangeForStmt:
+                this.emitRangeForStmt(stmt);
+                break;
+            case AST.NodeType.WhileStmt:
+                this.emitWhileStmt(stmt);
+                break;
+            case AST.NodeType.ReturnStmt:
+                this.emitReturnStmt(stmt);
+                break;
+            case AST.NodeType.BreakStmt:
+                this.line('break');
+                break;
+            case AST.NodeType.ContinueStmt:
+                this.line('goto continue');
+                break;
+            case AST.NodeType.GuardStmt:
+                this.emitGuardStmt(stmt);
+                break;
+            case AST.NodeType.SafeCallStmt:
+                this.emitSafeCall(stmt);
+                break;
+            case AST.NodeType.ThreadStmt:
+                this.emitThreadStmt(stmt);
+                break;
+            case AST.NodeType.LoopStmt:
+                this.emitLoopStmt(stmt);
+                break;
+            case AST.NodeType.WaitStmt:
+                this.emitWaitStmt(stmt);
+                break;
+            case AST.NodeType.TimeoutStmt:
+                this.emitTimeoutStmt(stmt);
+                break;
+            case AST.NodeType.IntervalStmt:
+                this.emitIntervalStmt(stmt);
+                break;
+            case AST.NodeType.TryCatchStmt:
+                this.emitTryCatch(stmt);
+                break;
+            case AST.NodeType.EmitStmt:
+                this.emitEmitStmt(stmt);
+                break;
+            case AST.NodeType.EventHandler:
+                this.emitEventHandler(stmt);
+                break;
+            case AST.NodeType.FunctionDecl:
+                this.emitFunctionDecl(stmt);
+                break;
+            case AST.NodeType.SwitchStmt:
+                this.emitSwitchStmt(stmt);
+                break;
+            case AST.NodeType.ExportDecl:
+                this.emitExportDecl(stmt);
+                break;
+            case AST.NodeType.CommandStmt:
+                this.emitCommandStmt(stmt);
+                break;
+            default:
+                // Expression statement
+                // Optimize UpdateExpr used as statement (i++)
+                {
+                    const expr = stmt;
+                    if (expr.kind === AST.NodeType.UpdateExpr) {
+                        const update = expr;
+                        const arg = this.emitExpr(update.argument);
+                        const op = update.operator === '++' ? '+' : '-';
+                        this.line(`${arg} = ${arg} ${op} 1`);
+                        return;
+                    }
+                }
+                this.line(this.emitExpr(stmt));
+        }
+    }
+    emitVariableDecl(decl) {
+        const prefix = decl.scope === 'var' ? '' : 'local ';
+        const globalConst = decl.scope === 'const' ? ' <const>' : '';
+        // Single Name Case (supports destructuring)
+        if (decl.names.length === 1) {
+            const name = decl.names[0];
+            const valEmitted = (decl.values && decl.values[0]) ? this.emitExpr(decl.values[0]) : 'nil';
+            if (name.kind === AST.NodeType.Identifier) {
+                const id = name;
+                const attr = id.attribute ? ` <${id.attribute}>` : globalConst;
+                this.line(`${prefix}${id.name}${attr} = ${valEmitted}`);
+                return;
+            }
+            if (name.kind === AST.NodeType.ObjectDestructure) {
+                const obj = name;
+                const tempVar = this.nextTemp('_obj');
+                this.line(`local ${tempVar} = ${valEmitted}`);
+                obj.properties.forEach(p => {
+                    this.line(`${prefix}${p.name}${globalConst} = ${tempVar}.${p.name}`);
+                });
+                return;
+            }
+            if (name.kind === AST.NodeType.ArrayDestructure) {
+                const arr = name;
+                const tempVar = this.nextTemp('_t');
+                this.line(`local ${tempVar} = ${valEmitted}`);
+                arr.elements.forEach((el, i) => {
+                    this.line(`${prefix}${el.name}${globalConst} = ${tempVar}[${i + 1}]`);
+                });
+                return;
+            }
+        }
+        // Multiple Names (Standard Lua / Multiple variable LT)
+        const namesEmitted = decl.names.map(n => {
+            const id = n;
+            const attr = id.attribute ? ` <${id.attribute}>` : globalConst;
+            return id.name + attr;
+        }).join(', ');
+        // Dead Code Elimination
+        if (decl.names.length === 1 && decl.scope !== 'var' && !this.usedVars.has(decl.names[0].name)) {
+            const val = (decl.values && decl.values[0]);
+            if (val && this.hasSideEffects(val)) {
+                this.line(`${this.emitExpr(val)} -- dead code(unused)`);
+            }
+            return;
+        }
+        const valsEmitted = decl.values && decl.values.length > 0
+            ? ` = ${decl.values.map(v => this.emitExpr(v)).join(', ')}`
+            : '';
+        this.line(`${prefix}${namesEmitted}${valsEmitted}`);
+    }
+    hasSideEffects(node) {
+        switch (node.kind) {
+            case AST.NodeType.CallExpr:
+                return true;
+            case AST.NodeType.BinaryExpr:
+                return this.hasSideEffects(node.left) || this.hasSideEffects(node.right);
+            case AST.NodeType.UnaryExpr:
+                return this.hasSideEffects(node.operand);
+            case AST.NodeType.CallExpr:
+                return true; // Calls ALWAYS have side effects
+            case AST.NodeType.TableLiteral:
+                return node.fields.some(f => this.hasSideEffects(f.value) || (f.key && f.key.kind !== AST.NodeType.Identifier && this.hasSideEffects(f.key)));
+            case AST.NodeType.VectorLiteral:
+                return node.components.some(c => this.hasSideEffects(c));
+            case AST.NodeType.SpreadExpr:
+                return this.hasSideEffects(node.argument);
+            default:
+                return false;
+        }
+    }
+    emitArrayLiteral(expr) {
+        const elements = expr.fields.map(f => this.emitExpr(f.value));
+        return `{ ${elements.join(', ')} }`;
+    }
+    emitAssignment(stmt) {
+        const targets = stmt.targets.map(t => this.emitExpr(t)).join(', ');
+        const values = stmt.values.map(v => this.emitExpr(v)).join(', ');
+        this.line(`${targets} = ${values}`);
+    }
+    emitCompoundAssignment(stmt) {
+        const target = this.emitExpr(stmt.target);
+        const opMap = {
+            '+=': '+', '-=': '-', '*=': '*', '/=': '/', '%=': '%', '..=': '..'
+        };
+        this.line(`${target} = ${target} ${opMap[stmt.operator]} ${this.emitExpr(stmt.value)}`);
+    }
+    emitIfStmt(stmt) {
+        this.line(`if ${this.emitExpr(stmt.condition)} then`);
+        this.emitBlock(stmt.thenBody);
+        for (const elseIf of stmt.elseIfClauses || []) {
+            this.line(`elseif ${this.emitExpr(elseIf.condition)} then`);
+            this.emitBlock(elseIf.body);
+        }
+        if (stmt.elseBody) {
+            this.line('else');
+            this.emitBlock(stmt.elseBody);
+        }
+        this.line('end');
+    }
+    emitForStmt(stmt) {
+        const iterators = stmt.iterators.map(i => i.name).join(', ');
+        const iterable = this.emitExpr(stmt.iterable);
+        this.line(`for ${iterators} in ${iterable} do`);
+        this.emitBlock(stmt.body);
+        this.line('end');
+    }
+    emitRangeForStmt(stmt) {
+        const step = stmt.step ? `, ${this.emitExpr(stmt.step)}` : '';
+        this.line(`for ${stmt.counter.name} = ${this.emitExpr(stmt.start)}, ${this.emitExpr(stmt.end)}${step} do`);
+        this.emitBlockWithContinue(stmt.body);
+        this.line('end');
+    }
+    emitWhileStmt(stmt) {
+        this.line(`while ${this.emitExpr(stmt.condition)} do`);
+        this.emitBlockWithContinue(stmt.body);
+        this.line('end');
+    }
+    emitReturnStmt(stmt) {
+        if (stmt.values && stmt.values.length > 0) {
+            const values = stmt.values.map(v => this.emitExpr(v)).join(', ');
+            this.line(`return ${values}`);
+        }
+        else {
+            this.line('return');
+        }
+    }
+    emitGuardStmt(stmt) {
+        this.line(`if not (${this.emitExpr(stmt.condition)}) then`);
+        this.indent++;
+        if (stmt.elseBody) {
+            for (const s of stmt.elseBody) {
+                this.emitStatement(s);
+            }
+        }
+        this.line('return');
+        this.indent--;
+        this.line('end');
+    }
+    emitSafeCall(stmt) {
+        const call = stmt.call;
+        const callee = this.emitExpr(call.callee);
+        const args = call.args.map(a => this.emitExpr(a)).join(', ');
+        this.line(`pcall(${callee}, ${args})`);
+    }
+    emitThreadStmt(stmt) {
+        this.line('Citizen.CreateThread(function()');
+        this.emitBlock(stmt.body);
+        this.line('end)');
+    }
+    emitLoopStmt(stmt) {
+        const conds = stmt.conditions.map(c => this.emitExpr(c)).join(' and ');
+        this.line(`while ${conds} do`);
+        this.emitBlockWithContinue(stmt.body);
+        this.line('end');
+    }
+    emitWaitStmt(stmt) {
+        this.line(`Citizen.Wait(${this.emitExpr(stmt.time)})`);
+    }
+    emitTimeoutStmt(stmt) {
+        this.line(`Citizen.SetTimeout(${this.emitExpr(stmt.delay)}, function()`);
+        this.emitBlock(stmt.body);
+        this.line('end)');
+    }
+    emitIntervalStmt(stmt) {
+        this.line('Citizen.CreateThread(function()');
+        this.indent++;
+        this.line('while true do');
+        this.indent++;
+        this.line(`Citizen.Wait(${this.emitExpr(stmt.interval)})`);
+        for (const s of stmt.body.statements) {
+            this.emitStatement(s);
+        }
+        this.indent--;
+        this.line('end');
+        this.indent--;
+        this.line('end)');
+    }
+    emitTryCatch(stmt) {
+        this.line('local _ok, _err = pcall(function()');
+        this.emitBlock(stmt.tryBody);
+        this.line('end)');
+        this.line('if not _ok then');
+        this.indent++;
+        this.line(`local ${stmt.catchParam.name} = _err`);
+        for (const s of stmt.catchBody.statements) {
+            this.emitStatement(s);
+        }
+        this.indent--;
+        this.line('end');
+    }
+    emitEmitStmt(stmt) {
+        const fnName = stmt.emitType === 'emit' ? 'TriggerEvent' :
+            stmt.emitType === 'emitClient' ? 'TriggerClientEvent' : 'TriggerServerEvent';
+        const args = [this.emitExpr(stmt.eventName), ...stmt.args.map(a => this.emitExpr(a))].join(', ');
+        this.line(`${fnName}(${args})`);
+    }
+    emitEventHandler(stmt) {
+        const eventName = this.emitExpr(stmt.eventName);
+        const params = stmt.params.map(p => p.name.name).join(', ');
+        if (stmt.isNet) {
+            this.line(`RegisterNetEvent(${eventName})`);
+        }
+        this.line(`AddEventHandler(${eventName}, function(${params})`);
+        this.emitBlock(stmt.body);
+        this.line('end)');
+    }
+    emitFunctionDecl(stmt) {
+        const params = stmt.params.map(p => p.name.name).join(', ');
+        const prefix = stmt.isLocal ? 'local ' : '';
+        const name = stmt.name ? this.emitExpr(stmt.name) : '';
+        this.line(`${prefix}function ${name}(${params})`);
+        this.indent++;
+        // Default Values
+        for (const p of stmt.params) {
+            if (p.defaultValue) {
+                const pname = p.name.name;
+                const val = this.emitExpr(p.defaultValue);
+                this.line(`if ${pname} == nil then ${pname} = ${val} end`);
+            }
+        }
+        // Explicitly call emitStatement for each to avoid redundant indent++ if we use emitBlock
+        for (const s of stmt.body.statements) {
+            this.emitStatement(s);
+        }
+        this.indent--;
+        this.line('end');
+    }
+    emitSwitchStmt(stmt) {
+        // Generate temp variable for discriminant to evaluate only once
+        const tempVar = this.nextTemp('_s');
+        this.line(`local ${tempVar} = ${this.emitExpr(stmt.discriminant)}`);
+        let first = true;
+        for (const caseClause of stmt.cases) {
+            const conditions = caseClause.values.map(v => `${tempVar} == ${this.emitExpr(v)}`).join(' or ');
+            if (first) {
+                this.line(`if ${conditions} then`);
+                first = false;
+            }
+            else {
+                this.line(`elseif ${conditions} then`);
+            }
+            this.emitBlock(caseClause.body);
+        }
+        if (stmt.defaultCase) {
+            if (first) {
+                // Only default case
+                this.emitBlock(stmt.defaultCase);
+            }
+            else {
+                this.line('else');
+                this.emitBlock(stmt.defaultCase);
+            }
+        }
+        if (!first) {
+            this.line('end');
+        }
+    }
+    emitExportDecl(stmt) {
+        const decl = stmt.declaration;
+        const nameStr = decl.name ? this.emitExpr(decl.name) : 'anonymous';
+        const params = decl.params.map(p => p.name.name).join(', ');
+        this.line(`exports(${nameStr.startsWith('"') ? nameStr : `"${nameStr}"`}, function(${params})`);
+        this.emitBlock(decl.body);
+        this.line('end)');
+    }
+    emitCommandStmt(stmt) {
+        const name = stmt.commandName;
+        const params = stmt.params.map(p => p.name.name).join(', ');
+        this.line(`RegisterCommand("${name}", function(${params})`);
+        this.emitBlock(stmt.body);
+        this.line('end, false)');
+    }
+    // ============ Expression Emission ============
+    emitExpr(expr) {
+        switch (expr.kind) {
+            case AST.NodeType.NumberLiteral:
+                return String(expr.value);
+            case AST.NodeType.StringLiteral: {
+                const str = expr;
+                if (str.isLong)
+                    return `[[${str.value}]]`;
+                // Use original quote type for FiveM Lua compatibility
+                const quote = str.quote || '"';
+                return `${quote}${str.value}${quote}`;
+            }
+            case AST.NodeType.InterpolatedString:
+                return this.emitInterpolatedString(expr);
+            case AST.NodeType.BooleanLiteral:
+                return expr.value ? 'true' : 'false';
+            case AST.NodeType.NilLiteral:
+                return 'nil';
+            case AST.NodeType.Identifier:
+                return expr.name;
+            case AST.NodeType.BinaryExpr:
+                return this.emitBinaryExpr(expr);
+            case AST.NodeType.UnaryExpr:
+                return this.emitUnaryExpr(expr);
+            case AST.NodeType.CallExpr:
+                return this.emitCallExpr(expr);
+            case AST.NodeType.MemberExpr:
+                return this.emitMemberExpr(expr);
+            case AST.NodeType.OptionalChainExpr:
+                return this.emitOptionalChain(expr);
+            case AST.NodeType.NullCoalesceExpr:
+                return this.emitNullCoalesce(expr);
+            case AST.NodeType.ArrowFunc:
+                return this.emitArrowFunc(expr);
+            case AST.NodeType.TableLiteral:
+                return this.emitTableLiteral(expr);
+            case AST.NodeType.VectorLiteral:
+                return this.emitVectorLiteral(expr);
+            case AST.NodeType.UpdateExpr:
+                return this.emitUpdateExpr(expr);
+            case AST.NodeType.ConditionalExpr:
+                return this.emitConditionalExpr(expr);
+            case AST.NodeType.SpreadExpr:
+                return `unpack(${this.emitExpr(expr.argument)})`;
+            case AST.NodeType.FunctionDecl:
+                return this.emitFunctionExpr(expr);
+            default:
+                return `--[[ unknown: ${expr.kind} ]]`;
+        }
+    }
+    emitInterpolatedString(str) {
+        const quote = str.quote || '"';
+        const parts = str.parts.map(p => {
+            if (typeof p === 'string')
+                return `${quote}${p}${quote}`;
+            const expr = p;
+            const emitted = this.emitExpr(expr);
+            // Optimize: No need to tostring literals or already-string expressions
+            if (expr.kind === AST.NodeType.StringLiteral || expr.kind === AST.NodeType.NumberLiteral) {
+                return emitted;
+            }
+            return `tostring(${emitted})`;
+        });
+        return parts.join(' .. ');
+    }
+    emitBinaryExpr(expr) {
+        const left = this.emitExpr(expr.left);
+        const right = this.emitExpr(expr.right);
+        let op = expr.operator;
+        if (op === '!=')
+            op = '~=';
+        return `(${left} ${op} ${right})`;
+    }
+    emitUnaryExpr(expr) {
+        const space = expr.operator === 'not' ? ' ' : '';
+        return `${expr.operator}${space}${this.emitExpr(expr.operand)}`;
+    }
+    emitCallExpr(expr) {
+        const callee = this.emitExpr(expr.callee);
+        const args = expr.args.map(a => this.emitExpr(a)).join(', ');
+        return `${callee}(${args})`;
+    }
+    emitMemberExpr(expr) {
+        let obj = this.emitExpr(expr.object);
+        // Lua Requirement: Literal strings must be wrapped in parens for method calls/access
+        if (expr.object.kind === AST.NodeType.StringLiteral || expr.object.kind === AST.NodeType.TableLiteral) {
+            obj = `(${obj})`;
+        }
+        const sep = expr.isMethod ? ':' : '.';
+        if (expr.computed) {
+            return `${obj}[${this.emitExpr(expr.property)}]`;
+        }
+        return `${obj}${sep}${expr.property.name}`;
+    }
+    emitOptionalChain(expr) {
+        const chain = [];
+        let current = expr;
+        // Unroll the chain (e.g., a?.b?.c is nested as (a?.b)?.c)
+        while (current.kind === AST.NodeType.OptionalChainExpr) {
+            const oc = current;
+            const prop = oc.computed
+                ? `[${this.emitExpr(oc.property)}]`
+                : `.${oc.property.name}`;
+            chain.unshift(prop);
+            current = oc.object;
+        }
+        const base = this.emitExpr(current);
+        let result = `(${base}`;
+        let fullPath = base;
+        for (const p of chain) {
+            fullPath += p;
+            result += ` and ${fullPath}`;
+        }
+        result += `)`;
+        return result;
+    }
+    emitNullCoalesce(expr) {
+        const left = this.emitExpr(expr.left);
+        const right = this.emitExpr(expr.right);
+        // Optimization: If left is simple (identifier or member access), repetition is okay and shorter.
+        if (this.isSimpleExpr(expr.left)) {
+            return `(${left} ~= nil and ${left} or ${right})`;
+        }
+        // For complex expressions (optional chains, calls), use parameter trick to evaluate only once.
+        // This is safer and prevents massive repetition in the output.
+        return `(function(v) if v == nil then return ${right} end return v end)(${left})`;
+    }
+    emitArrowFunc(expr) {
+        const params = expr.params.map(p => p.name.name).join(', ');
+        if ('kind' in expr.body && expr.body.kind === AST.NodeType.Block) {
+            const block = expr.body;
+            const bodyLines = [];
+            for (const s of block.statements) {
+                bodyLines.push(this.emitStatementInline(s));
+            }
+            return `function(${params})\n${bodyLines.join('\n')}\nend`;
+        }
+        else {
+            return `function(${params}) return ${this.emitExpr(expr.body)} end`;
+        }
+    }
+    emitFunctionExpr(stmt) {
+        const params = stmt.params.map(p => p.name.name).join(', ');
+        const name = stmt.name ? ` ${this.emitExpr(stmt.name)}` : '';
+        const prevOutput = this.output;
+        this.output = [];
+        this.indent++;
+        // Default Values
+        for (const p of stmt.params) {
+            if (p.defaultValue) {
+                const pname = p.name.name;
+                const val = this.emitExpr(p.defaultValue);
+                this.line(`if ${pname} == nil then ${pname} = ${val} end`);
+            }
+        }
+        for (const s of stmt.body.statements) {
+            this.emitStatement(s);
+        }
+        this.indent--;
+        const body = this.output.join('\n');
+        this.output = prevOutput;
+        return `function${name}(${params})\n${body}${body ? '\n' : ''}${'    '.repeat(this.indent)}end`;
+    }
+    emitTableLiteral(expr) {
+        const hasSpread = expr.fields.some(f => f.value.kind === AST.NodeType.SpreadExpr);
+        const hasComputedKeys = expr.fields.some(f => f.key && f.key.kind !== AST.NodeType.Identifier);
+        const hasMixedFields = expr.fields.some(f => f.key) && expr.fields.some(f => !f.key);
+        // Simple array-like table: {1, 2, 3}
+        if (!hasSpread && !hasComputedKeys && !hasMixedFields && expr.fields.every(f => !f.key)) {
+            const fields = expr.fields.map(f => this.emitExpr(f.value));
+            return `{ ${fields.join(', ')} }`;
+        }
+        if (!hasSpread) {
+            const fields = expr.fields.map(f => {
+                if (f.key) {
+                    const key = f.key.kind === AST.NodeType.Identifier
+                        ? f.key.name
+                        : `[${this.emitExpr(f.key)}]`;
+                    return `${key} = ${this.emitExpr(f.value)}`;
+                }
+                return this.emitExpr(f.value);
+            });
+            return `{ ${fields.join(', ')} }`;
+        }
+        // Table with spread: Use an IIFE for merging
+        const temp = this.nextTemp('_tab');
+        const lines = [`local ${temp} = {}`];
+        for (const f of expr.fields) {
+            if (f.value.kind === AST.NodeType.SpreadExpr) {
+                const spreadArg = this.emitExpr(f.value.argument);
+                const k = this.nextTemp('_k');
+                const v = this.nextTemp('_v');
+                lines.push(`for ${k},${v} in pairs(${spreadArg}) do`);
+                lines.push(`  if type(${k}) == "number" then table.insert(${temp}, ${v}) else ${temp}[${k}] = ${v} end`);
+                lines.push(`end`);
+            }
+            else if (f.key) {
+                const key = f.key.kind === AST.NodeType.Identifier
+                    ? `"${f.key.name}"`
+                    : this.emitExpr(f.key);
+                lines.push(`${temp}[${key}] = ${this.emitExpr(f.value)}`);
+            }
+            else {
+                lines.push(`table.insert(${temp}, ${this.emitExpr(f.value)})`);
+            }
+        }
+        return `(function() ${lines.join('; ')} return ${temp} end)()`;
+    }
+    emitVectorLiteral(expr) {
+        const args = expr.components.map(c => this.emitExpr(c)).join(', ');
+        const fn = expr.components.length === 2 ? 'vector2' :
+            expr.components.length === 3 ? 'vector3' : 'vector4';
+        return `${fn}(${args})`;
+    }
+    emitUpdateExpr(expr) {
+        const op = expr.operator === '++' ? '+' : '-';
+        const arg = this.emitExpr(expr.argument);
+        if (expr.prefix) {
+            return `(function() ${arg} = ${arg} ${op} 1; return ${arg} end)()`;
+        }
+        else {
+            const temp = this.nextTemp('_old');
+            return `(function() local ${temp} = ${arg}; ${arg} = ${arg} ${op} 1; return ${temp} end)()`;
+        }
+    }
+    emitConditionalExpr(expr) {
+        const test = this.emitExpr(expr.test);
+        const cons = this.emitExpr(expr.consequent);
+        const alt = this.emitExpr(expr.alternate);
+        // Optimization: (test ? true : false) -> (not not test) or just (test) for comparisons.
+        if (expr.consequent.kind === AST.NodeType.BooleanLiteral && expr.consequent.value === true &&
+            expr.alternate.kind === AST.NodeType.BooleanLiteral && expr.alternate.value === false) {
+            if (expr.test.kind === AST.NodeType.BinaryExpr) {
+                const op = expr.test.operator;
+                if (['>', '<', '>=', '<=', '==', '!=', '==='].includes(op)) {
+                    return `(${test})`;
+                }
+            }
+            return `(not not ${test})`;
+        }
+        // Optimization: (test ? false : true) -> (not test)
+        if (expr.consequent.kind === AST.NodeType.BooleanLiteral && expr.consequent.value === false &&
+            expr.alternate.kind === AST.NodeType.BooleanLiteral && expr.alternate.value === true) {
+            return `(not ${test})`;
+        }
+        // Optimization: Use (a and b or c) if b is a non-falsy literal
+        const isTruthyLiteral = expr.consequent.kind === AST.NodeType.NumberLiteral ||
+            expr.consequent.kind === AST.NodeType.StringLiteral ||
+            expr.consequent.kind === AST.NodeType.TableLiteral ||
+            expr.consequent.kind === AST.NodeType.VectorLiteral ||
+            (expr.consequent.kind === AST.NodeType.BooleanLiteral && expr.consequent.value === true);
+        if (isTruthyLiteral) {
+            return `(${test} and ${cons} or ${alt})`;
+        }
+        return `(function() if ${test} then return ${cons} else return ${alt} end end)()`;
+    }
+    emitStatementInline(stmt) {
+        const prev = this.output;
+        this.output = [];
+        this.emitStatement(stmt);
+        const result = this.output.join('\n');
+        this.output = prev;
+        return result;
+    }
+    // ============ Helpers ============
+    hasContinue(block) {
+        return block.statements.some(s => s.kind === AST.NodeType.ContinueStmt);
+    }
+    emitBlock(block) {
+        this.indent++;
+        for (const stmt of block.statements) {
+            this.emitStatement(stmt);
+        }
+        this.indent--;
+    }
+    emitBlockWithContinue(block) {
+        this.indent++;
+        for (const stmt of block.statements) {
+            this.emitStatement(stmt);
+        }
+        if (this.hasContinue(block)) {
+            this.line('::continue::');
+        }
+        this.indent--;
+    }
+    line(code) {
+        this.output.push('    '.repeat(this.indent) + code);
+    }
+    isSimpleExpr(expr) {
+        if (expr.kind === AST.NodeType.Identifier ||
+            expr.kind === AST.NodeType.NumberLiteral ||
+            expr.kind === AST.NodeType.BooleanLiteral ||
+            expr.kind === AST.NodeType.NilLiteral ||
+            expr.kind === AST.NodeType.StringLiteral) {
+            return true;
+        }
+        if (expr.kind === AST.NodeType.MemberExpr) {
+            const mem = expr;
+            return this.isSimpleExpr(mem.object) && (mem.computed ? this.isSimpleExpr(mem.property) : true);
+        }
+        if (expr.kind === AST.NodeType.OptionalChainExpr) {
+            // Optional chains are NOT simple for repetition because they expand into long and-chains.
+            // We return false here so that NullCoalescing uses a parameter trick instead of repeating the path.
+            return false;
+        }
+        return false;
+    }
+}