@gwigz/slua-tstl-plugin 1.1.0 → 1.3.0

package/dist/lua-ast-walk.js

@@ -0,0 +1,422 @@
+import * as lua from "typescript-to-lua";
+function walkExpression(expr, blockVisitor) {
+    switch (expr.kind) {
+        case lua.SyntaxKind.StringLiteral:
+        case lua.SyntaxKind.NumericLiteral:
+        case lua.SyntaxKind.NilKeyword:
+        case lua.SyntaxKind.DotsKeyword:
+        case lua.SyntaxKind.ArgKeyword:
+        case lua.SyntaxKind.TrueKeyword:
+        case lua.SyntaxKind.FalseKeyword:
+        case lua.SyntaxKind.Identifier:
+            break;
+        case lua.SyntaxKind.BinaryExpression: {
+            const bin = expr;
+            walkExpression(bin.left, blockVisitor);
+            walkExpression(bin.right, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.UnaryExpression:
+            walkExpression(expr.operand, blockVisitor);
+            break;
+        case lua.SyntaxKind.ParenthesizedExpression:
+            walkExpression(expr.expression, blockVisitor);
+            break;
+        case lua.SyntaxKind.ConditionalExpression: {
+            const cond = expr;
+            walkExpression(cond.condition, blockVisitor);
+            walkExpression(cond.whenTrue, blockVisitor);
+            walkExpression(cond.whenFalse, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.CallExpression: {
+            const call = expr;
+            walkExpression(call.expression, blockVisitor);
+            for (const p of call.params)
+                walkExpression(p, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.MethodCallExpression: {
+            const mc = expr;
+            walkExpression(mc.prefixExpression, blockVisitor);
+            for (const p of mc.params)
+                walkExpression(p, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.TableIndexExpression: {
+            const ti = expr;
+            walkExpression(ti.table, blockVisitor);
+            walkExpression(ti.index, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.TableExpression:
+            for (const f of expr.fields) {
+                walkExpression(f.value, blockVisitor);
+                if (f.key)
+                    walkExpression(f.key, blockVisitor);
+            }
+            break;
+        case lua.SyntaxKind.FunctionExpression: {
+            const fn = expr;
+            walkBlock(fn.body, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.TableFieldExpression: {
+            const tf = expr;
+            walkExpression(tf.value, blockVisitor);
+            if (tf.key)
+                walkExpression(tf.key, blockVisitor);
+            break;
+        }
+    }
+}
+function walkStatement(stmt, blockVisitor) {
+    switch (stmt.kind) {
+        case lua.SyntaxKind.DoStatement:
+            walkBlock(stmt, blockVisitor);
+            break;
+        case lua.SyntaxKind.VariableDeclarationStatement: {
+            const vds = stmt;
+            if (vds.right) {
+                for (const r of vds.right)
+                    walkExpression(r, blockVisitor);
+            }
+            break;
+        }
+        case lua.SyntaxKind.AssignmentStatement: {
+            const as_ = stmt;
+            for (const l of as_.left)
+                walkExpression(l, blockVisitor);
+            for (const r of as_.right)
+                walkExpression(r, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.IfStatement: {
+            const is_ = stmt;
+            walkExpression(is_.condition, blockVisitor);
+            walkBlock(is_.ifBlock, blockVisitor);
+            if (is_.elseBlock) {
+                if (lua.isIfStatement(is_.elseBlock)) {
+                    walkStatement(is_.elseBlock, blockVisitor);
+                }
+                else {
+                    walkBlock(is_.elseBlock, blockVisitor);
+                }
+            }
+            break;
+        }
+        case lua.SyntaxKind.WhileStatement: {
+            const ws = stmt;
+            walkExpression(ws.condition, blockVisitor);
+            walkBlock(ws.body, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.RepeatStatement: {
+            const rs = stmt;
+            walkExpression(rs.condition, blockVisitor);
+            walkBlock(rs.body, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.ForStatement: {
+            const fs = stmt;
+            walkExpression(fs.controlVariableInitializer, blockVisitor);
+            walkExpression(fs.limitExpression, blockVisitor);
+            if (fs.stepExpression)
+                walkExpression(fs.stepExpression, blockVisitor);
+            walkBlock(fs.body, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.ForInStatement: {
+            const fis = stmt;
+            for (const e of fis.expressions)
+                walkExpression(e, blockVisitor);
+            walkBlock(fis.body, blockVisitor);
+            break;
+        }
+        case lua.SyntaxKind.ReturnStatement:
+            for (const e of stmt.expressions)
+                walkExpression(e, blockVisitor);
+            break;
+        case lua.SyntaxKind.ExpressionStatement:
+            walkExpression(stmt.expression, blockVisitor);
+            break;
+        case lua.SyntaxKind.GotoStatement:
+        case lua.SyntaxKind.LabelStatement:
+        case lua.SyntaxKind.BreakStatement:
+        case lua.SyntaxKind.ContinueStatement:
+            break;
+    }
+}
+function walkBlock(block, blockVisitor) {
+    blockVisitor(block.statements);
+    for (const stmt of block.statements) {
+        walkStatement(stmt, blockVisitor);
+    }
+}
+/** Walk all statement arrays in a File. Depth-first. */
+export function walkBlocks(file, visitor) {
+    walkBlock(file, visitor);
+}
+function walkExpressionIds(expr, cb) {
+    switch (expr.kind) {
+        case lua.SyntaxKind.Identifier:
+            cb(expr);
+            break;
+        case lua.SyntaxKind.StringLiteral:
+        case lua.SyntaxKind.NumericLiteral:
+        case lua.SyntaxKind.NilKeyword:
+        case lua.SyntaxKind.DotsKeyword:
+        case lua.SyntaxKind.ArgKeyword:
+        case lua.SyntaxKind.TrueKeyword:
+        case lua.SyntaxKind.FalseKeyword:
+            break;
+        case lua.SyntaxKind.BinaryExpression: {
+            const bin = expr;
+            walkExpressionIds(bin.left, cb);
+            walkExpressionIds(bin.right, cb);
+            break;
+        }
+        case lua.SyntaxKind.UnaryExpression:
+            walkExpressionIds(expr.operand, cb);
+            break;
+        case lua.SyntaxKind.ParenthesizedExpression:
+            walkExpressionIds(expr.expression, cb);
+            break;
+        case lua.SyntaxKind.ConditionalExpression: {
+            const cond = expr;
+            walkExpressionIds(cond.condition, cb);
+            walkExpressionIds(cond.whenTrue, cb);
+            walkExpressionIds(cond.whenFalse, cb);
+            break;
+        }
+        case lua.SyntaxKind.CallExpression: {
+            const call = expr;
+            walkExpressionIds(call.expression, cb);
+            for (const p of call.params)
+                walkExpressionIds(p, cb);
+            break;
+        }
+        case lua.SyntaxKind.MethodCallExpression: {
+            const mc = expr;
+            walkExpressionIds(mc.prefixExpression, cb);
+            walkExpressionIds(mc.name, cb);
+            for (const p of mc.params)
+                walkExpressionIds(p, cb);
+            break;
+        }
+        case lua.SyntaxKind.TableIndexExpression: {
+            const ti = expr;
+            walkExpressionIds(ti.table, cb);
+            walkExpressionIds(ti.index, cb);
+            break;
+        }
+        case lua.SyntaxKind.TableExpression:
+            for (const f of expr.fields) {
+                walkExpressionIds(f.value, cb);
+                if (f.key)
+                    walkExpressionIds(f.key, cb);
+            }
+            break;
+        case lua.SyntaxKind.FunctionExpression: {
+            const fn = expr;
+            if (fn.params) {
+                for (const p of fn.params)
+                    cb(p);
+            }
+            walkBlockIds(fn.body, cb);
+            break;
+        }
+        case lua.SyntaxKind.TableFieldExpression: {
+            const tf = expr;
+            walkExpressionIds(tf.value, cb);
+            if (tf.key)
+                walkExpressionIds(tf.key, cb);
+            break;
+        }
+    }
+}
+function walkStatementIds(stmt, cb) {
+    switch (stmt.kind) {
+        case lua.SyntaxKind.DoStatement:
+            walkBlockIds(stmt, cb);
+            break;
+        case lua.SyntaxKind.VariableDeclarationStatement: {
+            const vds = stmt;
+            for (const l of vds.left)
+                cb(l);
+            if (vds.right) {
+                for (const r of vds.right)
+                    walkExpressionIds(r, cb);
+            }
+            break;
+        }
+        case lua.SyntaxKind.AssignmentStatement: {
+            const as_ = stmt;
+            for (const l of as_.left)
+                walkExpressionIds(l, cb);
+            for (const r of as_.right)
+                walkExpressionIds(r, cb);
+            break;
+        }
+        case lua.SyntaxKind.IfStatement: {
+            const is_ = stmt;
+            walkExpressionIds(is_.condition, cb);
+            walkBlockIds(is_.ifBlock, cb);
+            if (is_.elseBlock) {
+                if (lua.isIfStatement(is_.elseBlock)) {
+                    walkStatementIds(is_.elseBlock, cb);
+                }
+                else {
+                    walkBlockIds(is_.elseBlock, cb);
+                }
+            }
+            break;
+        }
+        case lua.SyntaxKind.WhileStatement: {
+            const ws = stmt;
+            walkExpressionIds(ws.condition, cb);
+            walkBlockIds(ws.body, cb);
+            break;
+        }
+        case lua.SyntaxKind.RepeatStatement: {
+            const rs = stmt;
+            walkExpressionIds(rs.condition, cb);
+            walkBlockIds(rs.body, cb);
+            break;
+        }
+        case lua.SyntaxKind.ForStatement: {
+            const fs = stmt;
+            cb(fs.controlVariable);
+            walkExpressionIds(fs.controlVariableInitializer, cb);
+            walkExpressionIds(fs.limitExpression, cb);
+            if (fs.stepExpression)
+                walkExpressionIds(fs.stepExpression, cb);
+            walkBlockIds(fs.body, cb);
+            break;
+        }
+        case lua.SyntaxKind.ForInStatement: {
+            const fis = stmt;
+            for (const n of fis.names)
+                cb(n);
+            for (const e of fis.expressions)
+                walkExpressionIds(e, cb);
+            walkBlockIds(fis.body, cb);
+            break;
+        }
+        case lua.SyntaxKind.ReturnStatement:
+            for (const e of stmt.expressions)
+                walkExpressionIds(e, cb);
+            break;
+        case lua.SyntaxKind.ExpressionStatement:
+            walkExpressionIds(stmt.expression, cb);
+            break;
+        case lua.SyntaxKind.GotoStatement:
+        case lua.SyntaxKind.LabelStatement:
+        case lua.SyntaxKind.BreakStatement:
+        case lua.SyntaxKind.ContinueStatement:
+            break;
+    }
+}
+function walkBlockIds(block, cb) {
+    for (const stmt of block.statements) {
+        walkStatementIds(stmt, cb);
+    }
+}
+/** Walk all Identifier nodes in a File. Callback may mutate id.text. */
+export function walkIdentifiers(file, cb) {
+    walkBlockIds(file, cb);
+}
+/** Check if an expression tree contains an Identifier with the given name. */
+export function containsIdentifier(node, name) {
+    if (lua.isIdentifier(node)) {
+        return node.text === name;
+    }
+    // Walk expressions
+    if (lua.isBinaryExpression(node)) {
+        return containsIdentifier(node.left, name) || containsIdentifier(node.right, name);
+    }
+    if (lua.isUnaryExpression(node)) {
+        return containsIdentifier(node.operand, name);
+    }
+    if (lua.isParenthesizedExpression(node)) {
+        return containsIdentifier(node.expression, name);
+    }
+    if (lua.isConditionalExpression(node)) {
+        return (containsIdentifier(node.condition, name) ||
+            containsIdentifier(node.whenTrue, name) ||
+            containsIdentifier(node.whenFalse, name));
+    }
+    if (lua.isCallExpression(node)) {
+        return (containsIdentifier(node.expression, name) ||
+            node.params.some((p) => containsIdentifier(p, name)));
+    }
+    if (lua.isMethodCallExpression(node)) {
+        return (containsIdentifier(node.prefixExpression, name) ||
+            containsIdentifier(node.name, name) ||
+            node.params.some((p) => containsIdentifier(p, name)));
+    }
+    if (lua.isTableIndexExpression(node)) {
+        return containsIdentifier(node.table, name) || containsIdentifier(node.index, name);
+    }
+    if (lua.isTableExpression(node)) {
+        return node.fields.some((f) => containsIdentifier(f.value, name) || (f.key ? containsIdentifier(f.key, name) : false));
+    }
+    if (lua.isTableFieldExpression(node)) {
+        return (containsIdentifier(node.value, name) ||
+            (node.key ? containsIdentifier(node.key, name) : false));
+    }
+    if (lua.isFunctionExpression(node)) {
+        return node.body.statements.some((s) => containsIdentifierInStatement(s, name));
+    }
+    // Walk statements
+    if (lua.isDoStatement(node)) {
+        return node.statements.some((s) => containsIdentifierInStatement(s, name));
+    }
+    if (lua.isVariableDeclarationStatement(node)) {
+        return (node.left.some((l) => l.text === name) ||
+            (node.right?.some((r) => containsIdentifier(r, name)) ?? false));
+    }
+    if (lua.isAssignmentStatement(node)) {
+        return (node.left.some((l) => containsIdentifier(l, name)) ||
+            node.right.some((r) => containsIdentifier(r, name)));
+    }
+    if (lua.isIfStatement(node)) {
+        if (containsIdentifier(node.condition, name))
+            return true;
+        if (node.ifBlock.statements.some((s) => containsIdentifierInStatement(s, name)))
+            return true;
+        if (node.elseBlock) {
+            if (lua.isIfStatement(node.elseBlock))
+                return containsIdentifier(node.elseBlock, name);
+            return node.elseBlock.statements.some((s) => containsIdentifierInStatement(s, name));
+        }
+        return false;
+    }
+    if (lua.isReturnStatement(node)) {
+        return node.expressions.some((e) => containsIdentifier(e, name));
+    }
+    if (lua.isExpressionStatement(node)) {
+        return containsIdentifier(node.expression, name);
+    }
+    if (lua.isIterationStatement(node)) {
+        if (lua.isForStatement(node)) {
+            return (node.controlVariable.text === name ||
+                containsIdentifier(node.controlVariableInitializer, name) ||
+                containsIdentifier(node.limitExpression, name) ||
+                (node.stepExpression ? containsIdentifier(node.stepExpression, name) : false) ||
+                node.body.statements.some((s) => containsIdentifierInStatement(s, name)));
+        }
+        if (lua.isForInStatement(node)) {
+            return (node.names.some((n) => n.text === name) ||
+                node.expressions.some((e) => containsIdentifier(e, name)) ||
+                node.body.statements.some((s) => containsIdentifierInStatement(s, name)));
+        }
+        // While / Repeat
+        return (containsIdentifier(node.condition, name) ||
+            node.body.statements.some((s) => containsIdentifierInStatement(s, name)));
+    }
+    return false;
+}
+function containsIdentifierInStatement(stmt, name) {
+    return containsIdentifier(stmt, name);
+}

package/dist/lua-transforms.d.ts

@@ -0,0 +1,41 @@
+import * as ts from "typescript";
+import * as lua from "typescript-to-lua";
+/**
+ * Strip internal JSDoc tags from Lua comments (@indexArg, @indexReturn, @define).
+ * These are only consumed by the plugin at transpile time.
+ *
+ * TSTL generates JSDoc as flat string arrays in leadingComments:
+ *   ["-", " @define FLAG", " continuation line", " @indexArg 0"]
+ * Each string becomes a `-- <text>` line. When we find a tag line, we also
+ * remove its continuation lines (those starting with ` ` but not ` @`).
+ */
+export declare function stripInternalJSDocTags(file: lua.File): boolean;
+/**
+ * Strip empty module boilerplate from files without explicit exports.
+ * `moduleDetection: "force"` causes TSTL to wrap every file as a module;
+ * standalone SLua scripts don't need the ____exports wrapper.
+ */
+export declare function stripEmptyModuleBoilerplate(file: lua.File, sourceFiles: readonly ts.SourceFile[] | undefined): boolean;
+/**
+ * Collapse default-parameter nil-checks into `x = x or <literal>`.
+ * Matches: if x == nil then x = <literal> end
+ * Safe for strings and numbers (both truthy in Lua); the TS source only
+ * generates these for string/number defaults.
+ */
+export declare function collapseDefaultParamNilChecks(file: lua.File): boolean;
+/**
+ * Shorten TSTL destructuring temp names: ____*_result_* -> _rN.
+ * Two-pass: collect unique names in order, then rename all identifiers.
+ */
+export declare function shortenTempNames(file: lua.File): boolean;
+/**
+ * Collapse consecutive field accesses from the same shortened temp into
+ * multi-assignment: `local a = _r0.x; local b = _r0.y` -> `local a, b = _r0.x, _r0.y`.
+ * Only collapses when the base matches `_r\d+` (shortened temps).
+ */
+export declare function collapseFieldAccesses(file: lua.File): boolean;
+/**
+ * Merge forward-declared `local x` with its first `x = value` assignment.
+ * Only inlines when there are no references to x between declaration and assignment.
+ */
+export declare function inlineForwardDeclarations(file: lua.File): boolean;