Preceding Statements

src/LuaAST.ts

@@ -566,6 +566,18 @@ export function createStringLiteral(value: string, tsOriginal?: ts.Node): String
     return expression;
 }
 
+export function isLiteral(
+    node: Node
+): node is NilLiteral | DotsLiteral | BooleanLiteral | NumericLiteral | StringLiteral {
+    return (
+        isNilLiteral(node) ||
+        isDotsLiteral(node) ||
+        isBooleanLiteral(node) ||
+        isNumericLiteral(node) ||
+        isStringLiteral(node)
+    );
+}
+
 export enum FunctionExpressionFlags {
     None = 1 << 0,
     Inline = 1 << 1, // Keep function body on same line

src/LuaLib.ts

@@ -70,6 +70,9 @@ export enum LuaLibFeature {
     PromiseRace = "PromiseRace",
     Set = "Set",
     SetDescriptor = "SetDescriptor",
+    SparseArrayNew = "SparseArrayNew",
+    SparseArrayPush = "SparseArrayPush",
+    SparseArraySpread = "SparseArraySpread",
     WeakMap = "WeakMap",
     WeakSet = "WeakSet",
     SourceMapTraceBack = "SourceMapTraceBack",

src/lualib/SparseArrayNew.ts

@@ -0,0 +1,9 @@
+type __TS__SparseArray<T> = T[] & { sparseLength: number };
+
+function __TS__SparseArrayNew<T>(this: void, ...args: T[]): __TS__SparseArray<T> {
+    const sparseArray = [...args] as __TS__SparseArray<T>;
+    // select("#", ...) counts the number of args passed, including nils.
+    // Note that we're depending on vararg optimization to occur here.
+    sparseArray.sparseLength = select("#", ...args);
+    return sparseArray;
+}

src/lualib/SparseArrayPush.ts

@@ -0,0 +1,8 @@
+function __TS__SparseArrayPush<T>(this: void, sparseArray: __TS__SparseArray<T>, ...args: T[]): void {
+    const argsLen = select("#", ...args);
+    const listLen = sparseArray.sparseLength;
+    for (const i of $range(1, argsLen)) {
+        sparseArray[listLen + i - 1] = args[i - 1];
+    }
+    sparseArray.sparseLength = listLen + argsLen;
+}

src/lualib/SparseArraySpread.ts

@@ -0,0 +1,4 @@
+function __TS__SparseArraySpread<T>(this: void, sparseArray: __TS__SparseArray<T>): LuaMultiReturn<T[]> {
+    const _unpack = unpack ?? table.unpack;
+    return _unpack(sparseArray, 1, sparseArray.sparseLength);
+}

src/transformation/builtins/array.ts

@@ -3,7 +3,7 @@ import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 import { unsupportedProperty } from "../utils/diagnostics";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
-import { PropertyCallExpression, transformArguments } from "../visitors/call";
+import { PropertyCallExpression, transformArguments, transformCallAndArguments } from "../visitors/call";
 import { isStringType, isNumberType } from "../utils/typescript";
 
 export function transformArrayConstructorCall(
@@ -29,8 +29,7 @@ export function transformArrayPrototypeCall(
 ): lua.CallExpression | undefined {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = transformArguments(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = transformCallAndArguments(context, expression.expression, node.arguments, signature);
 
     const expressionName = expression.name.text;
     switch (expressionName) {

src/transformation/builtins/function.ts

@@ -6,7 +6,7 @@ import { unsupportedForTarget, unsupportedProperty, unsupportedSelfFunctionConve
 import { ContextType, getFunctionContextType } from "../utils/function-context";
 import { createUnpackCall } from "../utils/lua-ast";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
-import { PropertyCallExpression, transformArguments } from "../visitors/call";
+import { PropertyCallExpression, transformCallAndArguments } from "../visitors/call";
 
 export function transformFunctionPrototypeCall(
     context: TransformationContext,
@@ -19,8 +19,7 @@ export function transformFunctionPrototypeCall(
     }
 
     const signature = context.checker.getResolvedSignature(node);
-    const params = transformArguments(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = transformCallAndArguments(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "apply":

src/transformation/builtins/string.ts

@@ -4,7 +4,7 @@ import { TransformationContext } from "../context";
 import { unsupportedProperty } from "../utils/diagnostics";
 import { addToNumericExpression, createNaN, getNumberLiteralValue } from "../utils/lua-ast";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
-import { PropertyCallExpression, transformArguments } from "../visitors/call";
+import { PropertyCallExpression, transformArguments, transformCallAndArguments } from "../visitors/call";
 
 function createStringCall(methodName: string, tsOriginal: ts.Node, ...params: lua.Expression[]): lua.CallExpression {
     const stringIdentifier = lua.createIdentifier("string");
@@ -21,8 +21,7 @@ export function transformStringPrototypeCall(
 ): lua.Expression | undefined {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = transformArguments(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = transformCallAndArguments(context, expression.expression, node.arguments, signature);
 
     const expressionName = expression.name.text;
     switch (expressionName) {

src/transformation/context/context.ts

@@ -1,11 +1,14 @@
 import * as ts from "typescript";
 import { CompilerOptions, LuaTarget } from "../../CompilerOptions";
 import * as lua from "../../LuaAST";
-import { castArray } from "../../utils";
+import { assert, castArray } from "../../utils";
 import { unsupportedNodeKind } from "../utils/diagnostics";
 import { unwrapVisitorResult } from "../utils/lua-ast";
+import { createSafeName } from "../utils/safe-names";
 import { ExpressionLikeNode, ObjectVisitor, StatementLikeNode, VisitorMap } from "./visitors";
 
+export const tempSymbolId = -1 as lua.SymbolId;
+
 export interface AllAccessorDeclarations {
     firstAccessor: ts.AccessorDeclaration;
     secondAccessor: ts.AccessorDeclaration | undefined;
@@ -29,6 +32,7 @@ export class TransformationContext {
     public readonly diagnostics: ts.Diagnostic[] = [];
     public readonly checker: DiagnosticsProducingTypeChecker = this.program.getDiagnosticsProducingTypeChecker();
     public readonly resolver: EmitResolver;
+    public readonly precedingStatementsStack: lua.Statement[][] = [];
 
     public readonly options: CompilerOptions = this.program.getCompilerOptions();
     public readonly luaTarget = this.options.luaTarget ?? LuaTarget.Universal;
@@ -46,6 +50,7 @@ export class TransformationContext {
     }
 
     private currentNodeVisitors: Array<ObjectVisitor<ts.Node>> = [];
+    private nextTempId = 0;
 
     public transformNode(node: ts.Node): lua.Node[];
     /** @internal */
@@ -104,10 +109,107 @@ export class TransformationContext {
     }
 
     public transformStatements(node: StatementLikeNode | readonly StatementLikeNode[]): lua.Statement[] {
-        return castArray(node).flatMap(n => this.transformNode(n) as lua.Statement[]);
+        return castArray(node).flatMap(n => {
+            this.pushPrecedingStatements();
+            const statements = this.transformNode(n) as lua.Statement[];
+            statements.unshift(...this.popPrecedingStatements());
+            return statements;
+        });
     }
 
     public superTransformStatements(node: StatementLikeNode | readonly StatementLikeNode[]): lua.Statement[] {
-        return castArray(node).flatMap(n => this.superTransformNode(n) as lua.Statement[]);
+        return castArray(node).flatMap(n => {
+            this.pushPrecedingStatements();
+            const statements = this.superTransformNode(n) as lua.Statement[];
+            statements.unshift(...this.popPrecedingStatements());
+            return statements;
+        });
+    }
+
+    public pushPrecedingStatements() {
+        this.precedingStatementsStack.push([]);
+    }
+
+    public popPrecedingStatements() {
+        const precedingStatements = this.precedingStatementsStack.pop();
+        assert(precedingStatements);
+        return precedingStatements;
+    }
+
+    public addPrecedingStatements(statements: lua.Statement | lua.Statement[]) {
+        const precedingStatements = this.precedingStatementsStack[this.precedingStatementsStack.length - 1];
+        assert(precedingStatements);
+        if (!Array.isArray(statements)) {
+            statements = [statements];
+        }
+        precedingStatements.push(...statements);
+    }
+
+    public prependPrecedingStatements(statements: lua.Statement | lua.Statement[]) {
+        const precedingStatements = this.precedingStatementsStack[this.precedingStatementsStack.length - 1];
+        assert(precedingStatements);
+        if (!Array.isArray(statements)) {
+            statements = [statements];
+        }
+        precedingStatements.unshift(...statements);
+    }
+
+    public createTempName(prefix = "temp") {
+        prefix = prefix.replace(/^_*/, ""); // Strip leading underscores because createSafeName will add them again
+        return createSafeName(`${prefix}_${this.nextTempId++}`);
+    }
+
+    private getTempNameForLuaExpression(expression: lua.Expression): string | undefined {
+        if (lua.isStringLiteral(expression)) {
+            return expression.value;
+        } else if (lua.isNumericLiteral(expression)) {
+            return `_${expression.value.toString()}`;
+        } else if (lua.isIdentifier(expression)) {
+            return expression.text;
+        } else if (lua.isCallExpression(expression)) {
+            const name = this.getTempNameForLuaExpression(expression.expression);
+            if (name) {
+                return `${name}_result`;
+            }
+        } else if (lua.isTableIndexExpression(expression)) {
+            const tableName = this.getTempNameForLuaExpression(expression.table);
+            const indexName = this.getTempNameForLuaExpression(expression.index);
+            if (tableName || indexName) {
+                return `${tableName ?? "table"}_${indexName ?? "index"}`;
+            }
+        }
+    }
+
+    public createTempNameForLuaExpression(expression: lua.Expression) {
+        const name = this.getTempNameForLuaExpression(expression);
+        const identifier = lua.createIdentifier(this.createTempName(name), undefined, tempSymbolId);
+        lua.setNodePosition(identifier, lua.getOriginalPos(expression));
+        return identifier;
+    }
+
+    private getTempNameForNode(node: ts.Node): string | undefined {
+        if (ts.isStringLiteral(node) || ts.isIdentifier(node) || ts.isMemberName(node)) {
+            return node.text;
+        } else if (ts.isNumericLiteral(node)) {
+            return `_${node.text}`;
+        } else if (ts.isCallExpression(node)) {
+            const name = this.getTempNameForNode(node.expression);
+            if (name) {
+                return `${name}_result`;
+            }
+        } else if (ts.isElementAccessExpression(node) || ts.isPropertyAccessExpression(node)) {
+            const tableName = this.getTempNameForNode(node.expression);
+            const indexName = ts.isElementAccessExpression(node)
+                ? this.getTempNameForNode(node.argumentExpression)
+                : node.name.text;
+            if (tableName || indexName) {
+                return `${tableName ?? "table"}_${indexName ?? "index"}`;
+            }
+        }
+    }
+
+    public createTempNameForNode(node: ts.Node) {
+        const name = this.getTempNameForNode(node);
+        return lua.createIdentifier(this.createTempName(name), node, tempSymbolId);
     }
 }

src/transformation/utils/lua-ast.ts

@@ -4,7 +4,7 @@ import * as lua from "../../LuaAST";
 import { assert, castArray } from "../../utils";
 import { TransformationContext } from "../context";
 import { createExportedIdentifier, getIdentifierExportScope } from "./export";
-import { peekScope, ScopeType, Scope } from "./scope";
+import { peekScope, ScopeType, Scope, addScopeVariableDeclaration } from "./scope";
 import { transformLuaLibFunction } from "./lualib";
 import { LuaLibFeature } from "../../LuaLib";
 
@@ -62,19 +62,6 @@ export function getNumberLiteralValue(expression?: lua.Expression) {
     return undefined;
 }
 
-// Prefer use of transformToImmediatelyInvokedFunctionExpression to maintain correct scope. If you use this directly,
-// ensure you push/pop a function scope appropriately to avoid incorrect vararg optimization.
-export function createImmediatelyInvokedFunctionExpression(
-    statements: lua.Statement[],
-    result: lua.Expression | lua.Expression[],
-    tsOriginal?: ts.Node
-): lua.CallExpression {
-    const body = [...statements, lua.createReturnStatement(castArray(result))];
-    const flags = statements.length === 0 ? lua.FunctionExpressionFlags.Inline : lua.FunctionExpressionFlags.None;
-    const iife = lua.createFunctionExpression(lua.createBlock(body), undefined, undefined, flags);
-    return lua.createCallExpression(iife, [], tsOriginal);
-}
-
 export function createUnpackCall(
     context: TransformationContext,
     expression: lua.Expression,
@@ -119,12 +106,7 @@ export function createHoistableVariableDeclarationStatement(
     if (identifier.symbolId !== undefined) {
         const scope = peekScope(context);
         assert(scope.type !== ScopeType.Switch);
-
-        if (!scope.variableDeclarations) {
-            scope.variableDeclarations = [];
-        }
-
-        scope.variableDeclarations.push(declaration);
+        addScopeVariableDeclaration(scope, declaration);
     }
 
     return declaration;
@@ -176,22 +158,25 @@ export function createLocalOrExportedOrGlobalDeclaration(
 
         if (context.isModule || !isTopLevelVariable) {
             if (!isFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
-                // Split declaration and assignment of identifiers that reference themselves in their declaration
-                declaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
+                // Split declaration and assignment of identifiers that reference themselves in their declaration.
+                // Put declaration above preceding statements in case the identifier is referenced in those.
+                const precedingDeclaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
+                context.prependPrecedingStatements(precedingDeclaration);
                 if (rhs) {
                     assignment = lua.createAssignmentStatement(lhs, rhs, tsOriginal);
                 }
+
+                if (!isFunctionDeclaration) {
+                    // Remember local variable declarations for hoisting later
+                    addScopeVariableDeclaration(scope, precedingDeclaration);
+                }
             } else {
                 declaration = lua.createVariableDeclarationStatement(lhs, rhs, tsOriginal);
-            }
 
-            if (!isFunctionDeclaration) {
-                // Remember local variable declarations for hoisting later
-                if (!scope.variableDeclarations) {
-                    scope.variableDeclarations = [];
+                if (!isFunctionDeclaration) {
+                    // Remember local variable declarations for hoisting later
+                    addScopeVariableDeclaration(scope, declaration);
                 }
-
-                scope.variableDeclarations.push(declaration);
             }
         } else if (rhs) {
             // global

src/transformation/utils/preceding-statements.ts

@@ -0,0 +1,11 @@
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+
+export function transformInPrecedingStatementScope<
+    TReturn extends lua.Statement | lua.Statement[] | lua.Expression | lua.Expression[]
+>(context: TransformationContext, transformer: () => TReturn): [lua.Statement[], TReturn] {
+    context.pushPrecedingStatements();
+    const statementOrStatements = transformer();
+    const precedingStatements = context.popPrecedingStatements();
+    return [precedingStatements, statementOrStatements];
+}

src/transformation/utils/scope.ts

@@ -98,6 +98,13 @@ export function popScope(context: TransformationContext): Scope {
     return scope;
 }
 
+export function addScopeVariableDeclaration(scope: Scope, declaration: lua.VariableDeclarationStatement) {
+    if (!scope.variableDeclarations) {
+        scope.variableDeclarations = [];
+    }
+    scope.variableDeclarations.push(declaration);
+}
+
 function isHoistableFunctionDeclaredInScope(symbol: ts.Symbol, scopeNode: ts.Node) {
     return symbol?.declarations?.some(
         d => ts.isFunctionDeclaration(d) && findFirstNodeAbove(d, (n): n is ts.Node => n === scopeNode)

src/transformation/utils/typescript/index.ts

@@ -92,3 +92,20 @@ export function getFunctionTypeForCall(context: TransformationContext, node: ts.
     }
     return context.checker.getTypeFromTypeNode(typeDeclaration.type);
 }
+
+export function isConstIdentifier(context: TransformationContext, node: ts.Node) {
+    let identifier = node;
+    if (ts.isComputedPropertyName(identifier)) {
+        identifier = identifier.expression;
+    }
+    if (!ts.isIdentifier(identifier)) {
+        return false;
+    }
+    const symbol = context.checker.getSymbolAtLocation(identifier);
+    if (!symbol || !symbol.declarations) {
+        return false;
+    }
+    return symbol.declarations.some(
+        d => ts.isVariableDeclarationList(d.parent) && (d.parent.flags & ts.NodeFlags.Const) !== 0
+    );
+}