@gwigz/slua-tstl-plugin 1.0.0 → 1.2.0

package/dist/lua-transforms.js

@@ -0,0 +1,302 @@
+import * as ts from "typescript";
+import * as lua from "typescript-to-lua";
+import { walkBlocks, walkIdentifiers, containsIdentifier } from "./lua-ast-walk.js";
+const JSDOC_TAG_RE = /@(?:index(?:Arg|Return)|define)\b/;
+/**
+ * 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 function stripInternalJSDocTags(file) {
+    let changed = false;
+    walkBlocks(file, (statements) => {
+        for (const stmt of statements) {
+            if (!stmt.leadingComments || stmt.leadingComments.length === 0)
+                continue;
+            const filtered = [];
+            let skip = false;
+            for (const comment of stmt.leadingComments) {
+                if (typeof comment === "string") {
+                    if (JSDOC_TAG_RE.test(comment)) {
+                        // Tag line, skip it and subsequent continuation lines
+                        skip = true;
+                        continue;
+                    }
+                    if (skip) {
+                        // Continuation line: starts with space but not with ` @tag`
+                        if (comment.startsWith(" ") && !comment.match(/^ @\w/)) {
+                            continue;
+                        }
+                        // Not a continuation, stop skipping
+                        skip = false;
+                    }
+                    filtered.push(comment);
+                }
+                else {
+                    // Block comment (string[]), strip if any line contains the tag
+                    skip = false;
+                    if (comment.some((line) => JSDOC_TAG_RE.test(line))) {
+                        continue;
+                    }
+                    filtered.push(comment);
+                }
+            }
+            // If only the JSDoc opener "-" remains, remove it too
+            if (filtered.length === 1 && filtered[0] === "-") {
+                filtered.length = 0;
+            }
+            if (filtered.length !== stmt.leadingComments.length) {
+                stmt.leadingComments = filtered.length > 0 ? filtered : undefined;
+                changed = true;
+            }
+        }
+    });
+    return changed;
+}
+/**
+ * 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 function stripEmptyModuleBoilerplate(file, sourceFiles) {
+    const stmts = file.statements;
+    if (stmts.length < 2)
+        return false;
+    // Find `local ____exports = {}` at top level
+    const declIdx = stmts.findIndex((s) => lua.isVariableDeclarationStatement(s) &&
+        s.left.length === 1 &&
+        s.left[0].text === "____exports" &&
+        s.right &&
+        s.right.length === 1 &&
+        lua.isTableExpression(s.right[0]) &&
+        s.right[0].fields.length === 0);
+    if (declIdx === -1)
+        return false;
+    // Find `return ____exports` at end
+    const last = stmts[stmts.length - 1];
+    if (!lua.isReturnStatement(last) ||
+        last.expressions.length !== 1 ||
+        !lua.isIdentifier(last.expressions[0]) ||
+        last.expressions[0].text !== "____exports") {
+        return false;
+    }
+    // Check TS source files for explicit exports
+    const hasExplicitExports = sourceFiles?.some((sf) => sf.statements.some((s) => ts.isExportDeclaration(s) ||
+        ts.isExportAssignment(s) ||
+        (ts.canHaveModifiers(s) &&
+            ts.getModifiers(s)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword))));
+    if (hasExplicitExports)
+        return false;
+    // Remove both: the decl and the return
+    stmts.splice(stmts.length - 1, 1); // remove return first (higher index)
+    stmts.splice(declIdx, 1); // then remove decl
+    return true;
+}
+/**
+ * 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 function collapseDefaultParamNilChecks(file) {
+    let changed = false;
+    walkBlocks(file, (statements) => {
+        for (let i = 0; i < statements.length; i++) {
+            const stmt = statements[i];
+            if (!lua.isIfStatement(stmt))
+                continue;
+            if (stmt.elseBlock)
+                continue;
+            // condition: x == nil
+            if (!lua.isBinaryExpression(stmt.condition))
+                continue;
+            if (stmt.condition.operator !== lua.SyntaxKind.EqualityOperator)
+                continue;
+            if (!lua.isIdentifier(stmt.condition.left))
+                continue;
+            if (!lua.isNilLiteral(stmt.condition.right))
+                continue;
+            const paramName = stmt.condition.left;
+            // ifBlock has exactly 1 statement: x = <literal>
+            if (stmt.ifBlock.statements.length !== 1)
+                continue;
+            const inner = stmt.ifBlock.statements[0];
+            if (!lua.isAssignmentStatement(inner))
+                continue;
+            if (inner.left.length !== 1 || inner.right.length !== 1)
+                continue;
+            const assignTarget = inner.left[0];
+            if (!lua.isIdentifier(assignTarget))
+                continue;
+            if (assignTarget.text !== paramName.text)
+                continue;
+            const literal = inner.right[0];
+            if (!lua.isStringLiteral(literal) && !lua.isNumericLiteral(literal)) {
+                continue;
+            }
+            // Replace with: x = x or <literal>
+            const orExpr = lua.createBinaryExpression(lua.cloneIdentifier(paramName), literal, lua.SyntaxKind.OrOperator);
+            const assignment = lua.createAssignmentStatement(lua.cloneIdentifier(paramName), orExpr);
+            // Preserve leading comments from the if statement
+            if (stmt.leadingComments) {
+                assignment.leadingComments = stmt.leadingComments;
+            }
+            statements[i] = assignment;
+            changed = true;
+        }
+    });
+    return changed;
+}
+/**
+ * Shorten TSTL destructuring temp names: ____*_result_* -> _rN.
+ * Two-pass: collect unique names in order, then rename all identifiers.
+ */
+export function shortenTempNames(file) {
+    const seen = new Map();
+    let counter = 0;
+    const tempRe = /^____\w+_result_\d+$/;
+    // Pass 1: collect unique temp names in order of first occurrence
+    walkIdentifiers(file, (id) => {
+        if (tempRe.test(id.text) && !seen.has(id.text)) {
+            seen.set(id.text, `_r${counter++}`);
+        }
+    });
+    if (seen.size === 0)
+        return false;
+    // Pass 2: rename all matching identifiers
+    walkIdentifiers(file, (id) => {
+        const short = seen.get(id.text);
+        if (short)
+            id.text = short;
+    });
+    return true;
+}
+/**
+ * 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 function collapseFieldAccesses(file) {
+    let changed = false;
+    const tempBaseRe = /^_r\d+$/;
+    walkBlocks(file, (statements) => {
+        let i = 0;
+        while (i < statements.length) {
+            const stmt = statements[i];
+            // Match: local <name> = <temp>.<field>
+            if (!lua.isVariableDeclarationStatement(stmt) ||
+                stmt.left.length !== 1 ||
+                !stmt.right ||
+                stmt.right.length !== 1 ||
+                !lua.isTableIndexExpression(stmt.right[0]) ||
+                !lua.isIdentifier(stmt.right[0].table) ||
+                !tempBaseRe.test(stmt.right[0].table.text)) {
+                i++;
+                continue;
+            }
+            const baseName = stmt.right[0].table.text;
+            // Look ahead for consecutive field accesses on the same base
+            const left = [...stmt.left];
+            const right = [...stmt.right];
+            let end = i + 1;
+            while (end < statements.length) {
+                const next = statements[end];
+                if (lua.isVariableDeclarationStatement(next) &&
+                    next.left.length === 1 &&
+                    next.right &&
+                    next.right.length === 1 &&
+                    lua.isTableIndexExpression(next.right[0]) &&
+                    lua.isIdentifier(next.right[0].table) &&
+                    next.right[0].table.text === baseName) {
+                    left.push(...next.left);
+                    right.push(...next.right);
+                    end++;
+                }
+                else {
+                    break;
+                }
+            }
+            if (end - i > 1) {
+                // Create merged multi-assignment
+                const merged = lua.createVariableDeclarationStatement(left, right);
+                if (stmt.leadingComments) {
+                    merged.leadingComments = stmt.leadingComments;
+                }
+                statements.splice(i, end - i, merged);
+                changed = true;
+            }
+            i++;
+        }
+    });
+    return changed;
+}
+/**
+ * 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 function inlineForwardDeclarations(file) {
+    let changed = false;
+    walkBlocks(file, (statements) => {
+        for (let i = 0; i < statements.length; i++) {
+            const stmt = statements[i];
+            // Match forward declaration: `local var1, var2, ...` with no initializer
+            if (!lua.isVariableDeclarationStatement(stmt) || (stmt.right && stmt.right.length > 0)) {
+                continue;
+            }
+            const vars = stmt.left;
+            const inlined = new Set();
+            for (const varId of vars) {
+                const varName = varId.text;
+                // Scan forward for assignment to same identifier
+                for (let j = i + 1; j < statements.length; j++) {
+                    const candidate = statements[j];
+                    if (lua.isAssignmentStatement(candidate) &&
+                        candidate.left.length === 1 &&
+                        lua.isIdentifier(candidate.left[0]) &&
+                        candidate.left[0].text === varName &&
+                        candidate.right.length === 1) {
+                        // Don't inline if RHS references the variable (self-referencing)
+                        if (containsIdentifier(candidate.right[0], varName))
+                            break;
+                        // Don't inline multi-variable assignments like `a, b = fn()`
+                        // (already handled by the length check above)
+                        // Replace assignment with variable declaration
+                        const newDecl = lua.createVariableDeclarationStatement(lua.cloneIdentifier(candidate.left[0]), candidate.right[0]);
+                        if (candidate.leadingComments) {
+                            newDecl.leadingComments = candidate.leadingComments;
+                        }
+                        statements[j] = newDecl;
+                        inlined.add(varName);
+                        break;
+                    }
+                    // Reference to varName prevents inlining
+                    if (containsIdentifier(candidate, varName))
+                        break;
+                }
+            }
+            if (inlined.size === 0)
+                continue;
+            changed = true;
+            const remaining = vars.filter((v) => !inlined.has(v.text));
+            if (remaining.length === 0) {
+                // Remove the forward declaration entirely
+                statements.splice(i, 1);
+                i--; // re-check this index
+            }
+            else {
+                // Keep remaining vars in the forward declaration
+                statements[i] = lua.createVariableDeclarationStatement(remaining);
+                if (stmt.leadingComments) {
+                    ;
+                    statements[i].leadingComments =
+                        stmt.leadingComments;
+                }
+            }
+        }
+    });
+    return changed;
+}

package/dist/optimize.d.ts

@@ -0,0 +1,31 @@
+import * as ts from "typescript";
+import type { CallTransform } from "./transforms.js";
+export interface OptimizeFlags {
+    /** Inline `.filter()` calls as `for` loops with `ipairs`. Default: false */
+    filter?: boolean;
+    /** Rewrite `x = x + n` to `x += n` (Luau compound assignment). Default: false */
+    compoundAssignment?: boolean;
+    /** Reorder `Math.floor((a / b) * c)` to `a * c // b`. */
+    floorMultiply?: boolean;
+    /** Emit bare `string.find`/`table.find` for indexOf presence checks. */
+    indexOf?: boolean;
+    /** Shorten TSTL destructuring temp names (`____fn_result_N` -> `_rN`). */
+    shortenTemps?: boolean;
+    /** Merge forward-declared `local x` with its first `x = value` assignment. */
+    inlineLocals?: boolean;
+    /** Strip `tostring()` from number-typed template literal interpolations. */
+    numericConcat?: boolean;
+    /** Collapse `if x == nil then x = <literal> end` to `x = x or <literal>`. */
+    defaultParams?: boolean;
+}
+export declare const ALL_OPTIMIZE: Required<OptimizeFlags>;
+/**
+ * Count `arr.filter(cb)` calls and return a set of file names where inlining
+ * should be skipped (the shared `__TS__ArrayFilter` helper is smaller).
+ *
+ * When `bundle` is true (luaBundle mode), all source files end up in a single
+ * output, so the total across the program is what matters.  Otherwise each
+ * file is counted independently.
+ */
+export declare function countFilterCalls(program: ts.Program, bundle: boolean): Set<string>;
+export declare function createOptimizeTransforms(filterSkipFiles: Set<string>): CallTransform[];

package/dist/optimize.js

@@ -0,0 +1,106 @@
+import * as ts from "typescript";
+import * as tstl from "typescript-to-lua";
+import { isMethodCall, isArrayType } from "./utils.js";
+export const ALL_OPTIMIZE = {
+    filter: true,
+    compoundAssignment: true,
+    floorMultiply: true,
+    indexOf: true,
+    shortenTemps: true,
+    inlineLocals: true,
+    numericConcat: true,
+    defaultParams: true,
+};
+/**
+ * Count `arr.filter(cb)` calls and return a set of file names where inlining
+ * should be skipped (the shared `__TS__ArrayFilter` helper is smaller).
+ *
+ * When `bundle` is true (luaBundle mode), all source files end up in a single
+ * output, so the total across the program is what matters.  Otherwise each
+ * file is counted independently.
+ */
+export function countFilterCalls(program, bundle) {
+    const skip = new Set();
+    const checker = program.getTypeChecker();
+    const sourceFiles = program.getSourceFiles().filter((sf) => !sf.isDeclarationFile);
+    if (bundle) {
+        let total = 0;
+        for (const sf of sourceFiles) {
+            ts.forEachChild(sf, function visit(node) {
+                if (isArrayFilterCall(node, checker))
+                    total++;
+                ts.forEachChild(node, visit);
+            });
+        }
+        if (total > 1) {
+            for (const sf of sourceFiles) {
+                skip.add(sf.fileName);
+            }
+        }
+    }
+    else {
+        for (const sf of sourceFiles) {
+            let count = 0;
+            ts.forEachChild(sf, function visit(node) {
+                if (isArrayFilterCall(node, checker))
+                    count++;
+                ts.forEachChild(node, visit);
+            });
+            if (count > 1) {
+                skip.add(sf.fileName);
+            }
+        }
+    }
+    return skip;
+}
+function isArrayFilterCall(node, checker) {
+    return (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === "filter" &&
+        node.arguments.length === 1 &&
+        isArrayType(node.expression.expression, checker));
+}
+export function createOptimizeTransforms(filterSkipFiles) {
+    let counter = 0;
+    return [
+        // arr.filter(cb) -> inline for loop with ipairs
+        {
+            match: (node, checker) => {
+                if (filterSkipFiles.has(node.getSourceFile().fileName))
+                    return false;
+                return isMethodCall(node, checker, isArrayType, "filter", 1);
+            },
+            emit: (node, context) => {
+                const n = counter++;
+                const resultId = tstl.createIdentifier(`____opt_${n}`);
+                const valueId = tstl.createIdentifier(`____opt_v_${n}`);
+                const cbId = tstl.createIdentifier(`____opt_fn_${n}`);
+                const arr = context.transformExpression(node.expression.expression);
+                const cb = context.transformExpression(node.arguments[0]);
+                // Strip TSTL's context parameter (____) from the callback if present.
+                // Array callbacks are always called positionally; the context param is dead.
+                if (tstl.isFunctionExpression(cb) &&
+                    cb.params &&
+                    cb.params.length > 0 &&
+                    cb.params[0].text === "____") {
+                    cb.params = cb.params.slice(1);
+                }
+                // local ____opt_fn_N = <callback>
+                context.addPrecedingStatements(tstl.createVariableDeclarationStatement(cbId, cb, node));
+                // local ____opt_N = {}
+                context.addPrecedingStatements(tstl.createVariableDeclarationStatement(tstl.cloneIdentifier(resultId), tstl.createTableExpression(), node));
+                // ____opt_fn_N(____opt_v_N)
+                const filterCall = tstl.createCallExpression(tstl.cloneIdentifier(cbId), [
+                    tstl.cloneIdentifier(valueId),
+                ]);
+                // ____opt_N[#____opt_N + 1] = ____opt_v_N
+                const appendStmt = tstl.createAssignmentStatement(tstl.createTableIndexExpression(tstl.cloneIdentifier(resultId), tstl.createBinaryExpression(tstl.createUnaryExpression(tstl.cloneIdentifier(resultId), tstl.SyntaxKind.LengthOperator), tstl.createNumericLiteral(1), tstl.SyntaxKind.AdditionOperator)), tstl.cloneIdentifier(valueId));
+                // if ____opt_fn_N(____opt_v_N) then ... end
+                const ifStmt = tstl.createIfStatement(filterCall, tstl.createBlock([appendStmt]));
+                // for _, ____opt_v_N in ipairs(arr) do ... end
+                context.addPrecedingStatements(tstl.createForInStatement(tstl.createBlock([ifStmt]), [tstl.createIdentifier("_"), valueId], [tstl.createCallExpression(tstl.createIdentifier("ipairs"), [arr])], node));
+                return tstl.cloneIdentifier(resultId);
+            },
+        },
+    ];
+}

package/dist/transforms.d.ts

@@ -0,0 +1,7 @@
+import * as ts from "typescript";
+import * as tstl from "typescript-to-lua";
+export type CallTransform = {
+    match: (node: ts.CallExpression, checker: ts.TypeChecker) => boolean;
+    emit: (node: ts.CallExpression, context: tstl.TransformationContext) => tstl.Expression;
+};
+export declare const CALL_TRANSFORMS: CallTransform[];

package/dist/transforms.js

@@ -0,0 +1,195 @@
+import * as ts from "typescript";
+import * as tstl from "typescript-to-lua";
+import { isMethodCall, isNamespaceCall, isGlobalCall, isStringType, isArrayType, createNamespacedCall, createStringFindCall, } from "./utils.js";
+export const CALL_TRANSFORMS = [
+    // JSON.stringify(val) -> lljson.encode(val)
+    {
+        match: (node) => isNamespaceCall(node, "JSON", "stringify"),
+        emit: (node, context) => {
+            const args = node.arguments.map((a) => context.transformExpression(a));
+            return createNamespacedCall("lljson", "encode", args, node);
+        },
+    },
+    // JSON.parse(str) -> lljson.decode(str)
+    {
+        match: (node) => isNamespaceCall(node, "JSON", "parse"),
+        emit: (node, context) => {
+            const args = node.arguments.map((a) => context.transformExpression(a));
+            return createNamespacedCall("lljson", "decode", args, node);
+        },
+    },
+    // btoa(str) -> llbase64.encode(str)
+    {
+        match: (node) => isGlobalCall(node, "btoa") && node.arguments.length === 1,
+        emit: (node, context) => {
+            const args = node.arguments.map((a) => context.transformExpression(a));
+            return createNamespacedCall("llbase64", "encode", args, node);
+        },
+    },
+    // atob(str) -> llbase64.decode(str)
+    {
+        match: (node) => isGlobalCall(node, "atob") && node.arguments.length === 1,
+        emit: (node, context) => {
+            const args = node.arguments.map((a) => context.transformExpression(a));
+            return createNamespacedCall("llbase64", "decode", args, node);
+        },
+    },
+    // str.toUpperCase() -> ll.ToUpper(str)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "toUpperCase", 0),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            return createNamespacedCall("ll", "ToUpper", [str], node);
+        },
+    },
+    // str.toLowerCase() -> ll.ToLower(str)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "toLowerCase", 0),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            return createNamespacedCall("ll", "ToLower", [str], node);
+        },
+    },
+    // str.trim() -> ll.StringTrim(str, STRING_TRIM)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "trim", 0),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            return createNamespacedCall("ll", "StringTrim", [str, tstl.createIdentifier("STRING_TRIM")], node);
+        },
+    },
+    // str.trimStart() -> ll.StringTrim(str, STRING_TRIM_HEAD)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "trimStart", 0),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            return createNamespacedCall("ll", "StringTrim", [str, tstl.createIdentifier("STRING_TRIM_HEAD")], node);
+        },
+    },
+    // str.trimEnd() -> ll.StringTrim(str, STRING_TRIM_TAIL)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "trimEnd", 0),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            return createNamespacedCall("ll", "StringTrim", [str, tstl.createIdentifier("STRING_TRIM_TAIL")], node);
+        },
+    },
+    // str.indexOf(x) -> (string.find(str, x, 1, true) or 0) - 1
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "indexOf", 1),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            const search = context.transformExpression(node.arguments[0]);
+            const findOrZero = tstl.createBinaryExpression(createStringFindCall(str, search, node), tstl.createNumericLiteral(0), tstl.SyntaxKind.OrOperator, node);
+            return tstl.createBinaryExpression(tstl.createParenthesizedExpression(findOrZero), tstl.createNumericLiteral(1), tstl.SyntaxKind.SubtractionOperator, node);
+        },
+    },
+    // str.indexOf(x, fromIndex) -> (string.find(str, x, fromIndex + 1, true) or 0) - 1
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "indexOf", 2),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            const search = context.transformExpression(node.arguments[0]);
+            const fromArg = node.arguments[1];
+            const init = ts.isNumericLiteral(fromArg)
+                ? tstl.createNumericLiteral(Number(fromArg.text) + 1)
+                : tstl.createBinaryExpression(context.transformExpression(fromArg), tstl.createNumericLiteral(1), tstl.SyntaxKind.AdditionOperator, node);
+            const findCall = createNamespacedCall("string", "find", [str, search, init, tstl.createBooleanLiteral(true)], node);
+            const findOrZero = tstl.createBinaryExpression(findCall, tstl.createNumericLiteral(0), tstl.SyntaxKind.OrOperator, node);
+            return tstl.createBinaryExpression(tstl.createParenthesizedExpression(findOrZero), tstl.createNumericLiteral(1), tstl.SyntaxKind.SubtractionOperator, node);
+        },
+    },
+    // str.includes(x) -> string.find(str, x, 1, true) ~= nil
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "includes", 1),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            const search = context.transformExpression(node.arguments[0]);
+            return tstl.createBinaryExpression(createStringFindCall(str, search, node), tstl.createNilLiteral(), tstl.SyntaxKind.InequalityOperator, node);
+        },
+    },
+    // str.split(sep) -> string.split(str, sep)  (1-arg only)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "split", 1),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            const sep = context.transformExpression(node.arguments[0]);
+            return createNamespacedCall("string", "split", [str, sep], node);
+        },
+    },
+    // str.repeat(n) -> string.rep(str, n)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "repeat", 1),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            const n = context.transformExpression(node.arguments[0]);
+            return createNamespacedCall("string", "rep", [str, n], node);
+        },
+    },
+    // str.startsWith(search) -> string.find(str, search, 1, true) == 1  (1-arg only)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isStringType, "startsWith", 1),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            const search = context.transformExpression(node.arguments[0]);
+            return tstl.createBinaryExpression(createStringFindCall(str, search, node), tstl.createNumericLiteral(1), tstl.SyntaxKind.EqualityOperator, node);
+        },
+    },
+    // str.substring(start) -> string.sub(str, start + 1)
+    // str.substring(start, end) -> string.sub(str, start + 1, end)
+    {
+        match: (node, checker) => {
+            if (!isMethodCall(node, checker, isStringType, "substring")) {
+                return false;
+            }
+            return node.arguments.length === 1 || node.arguments.length === 2;
+        },
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            const startArg = node.arguments[0];
+            const start = ts.isNumericLiteral(startArg)
+                ? tstl.createNumericLiteral(Number(startArg.text) + 1)
+                : tstl.createBinaryExpression(context.transformExpression(startArg), tstl.createNumericLiteral(1), tstl.SyntaxKind.AdditionOperator, node);
+            const args = [str, start];
+            if (node.arguments.length === 2) {
+                args.push(context.transformExpression(node.arguments[1]));
+            }
+            return createNamespacedCall("string", "sub", args, node);
+        },
+    },
+    // str.replace / str.replaceAll -> ll.ReplaceSubString(str, search, replacement, count)
+    // count=1 for replace (first match only), count=0 for replaceAll
+    ...[
+        ["replace", 1],
+        ["replaceAll", 0],
+    ].map(([method, count]) => ({
+        match: (node, checker) => isMethodCall(node, checker, isStringType, method, 2),
+        emit: (node, context) => {
+            const str = context.transformExpression(node.expression.expression);
+            const search = context.transformExpression(node.arguments[0]);
+            const replacement = context.transformExpression(node.arguments[1]);
+            return createNamespacedCall("ll", "ReplaceSubString", [str, search, replacement, tstl.createNumericLiteral(count)], node);
+        },
+    })),
+    // arr.includes(val) -> table.find(arr, val) ~= nil
+    {
+        match: (node, checker) => isMethodCall(node, checker, isArrayType, "includes", 1),
+        emit: (node, context) => {
+            const arr = context.transformExpression(node.expression.expression);
+            const val = context.transformExpression(node.arguments[0]);
+            const findCall = createNamespacedCall("table", "find", [arr, val], node);
+            return tstl.createBinaryExpression(findCall, tstl.createNilLiteral(), tstl.SyntaxKind.InequalityOperator, node);
+        },
+    },
+    // arr.indexOf(val) -> (table.find(arr, val) or 0) - 1  (1-arg only)
+    {
+        match: (node, checker) => isMethodCall(node, checker, isArrayType, "indexOf", 1),
+        emit: (node, context) => {
+            const arr = context.transformExpression(node.expression.expression);
+            const val = context.transformExpression(node.arguments[0]);
+            const findCall = createNamespacedCall("table", "find", [arr, val], node);
+            const findOrZero = tstl.createBinaryExpression(findCall, tstl.createNumericLiteral(0), tstl.SyntaxKind.OrOperator, node);
+            return tstl.createBinaryExpression(tstl.createParenthesizedExpression(findOrZero), tstl.createNumericLiteral(1), tstl.SyntaxKind.SubtractionOperator, node);
+        },
+    },
+];