typescript-to-lua 1.1.1 → 1.2.0

package/dist/transformation/builtins/array.js

@@ -22,8 +22,7 @@ exports.transformArrayConstructorCall = transformArrayConstructorCall;
 function transformArrayPrototypeCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "concat":

package/dist/transformation/builtins/function.js

@@ -15,8 +15,7 @@ function transformFunctionPrototypeCall(context, node) {
         context.diagnostics.push((0, diagnostics_1.unsupportedSelfFunctionConversion)(node));
     }
     const signature = context.checker.getResolvedSignature(node);
-    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "apply":

package/dist/transformation/builtins/index.d.ts

@@ -2,5 +2,5 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 export declare function transformBuiltinPropertyAccessExpression(context: TransformationContext, node: ts.PropertyAccessExpression): lua.Expression | undefined;
-export declare function transformBuiltinCallExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression | undefined;
+export declare function transformBuiltinCallExpression(context: TransformationContext, node: ts.CallExpression, isOptionalCall: boolean): lua.Expression | undefined;
 export declare function transformBuiltinIdentifierExpression(context: TransformationContext, node: ts.Identifier): lua.Expression | undefined;

package/dist/transformation/builtins/index.js

@@ -19,6 +19,7 @@ const object_1 = require("./object");
 const promise_1 = require("./promise");
 const string_1 = require("./string");
 const symbol_1 = require("./symbol");
+const diagnostics_1 = require("../utils/diagnostics");
 function transformBuiltinPropertyAccessExpression(context, node) {
     const ownerType = context.checker.getTypeAtLocation(node.expression);
     if ((0, typescript_1.isStringType)(context, ownerType)) {
@@ -40,7 +41,7 @@ function transformBuiltinPropertyAccessExpression(context, node) {
     }
 }
 exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAccessExpression;
-function transformBuiltinCallExpression(context, node) {
+function transformBuiltinCallExpression(context, node, isOptionalCall) {
     const expressionType = context.checker.getTypeAtLocation(node.expression);
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, expressionType, undefined)) {
         // TODO:
@@ -50,47 +51,79 @@ function transformBuiltinCallExpression(context, node) {
             return result;
         }
     }
-    if (!ts.isPropertyAccessExpression(node.expression)) {
+    const expression = ts.getOriginalNode(node.expression);
+    if (!ts.isPropertyAccessExpression(expression)) {
         return;
     }
     (0, utils_1.assume)(node);
+    const isOptionalAccess = expression.questionDotToken;
+    const unsupportedOptionalCall = () => {
+        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        return lua.createNilLiteral();
+    };
     // If the function being called is of type owner.func, get the type of owner
-    const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
+    const ownerType = context.checker.getTypeAtLocation(expression.expression);
     if ((0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
         const symbol = ownerType.getSymbol();
         switch (symbol === null || symbol === void 0 ? void 0 : symbol.name) {
             case "ArrayConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, array_1.transformArrayConstructorCall)(context, node);
             case "Console":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, console_1.transformConsoleCall)(context, node);
             case "Math":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, math_1.transformMathCall)(context, node);
             case "StringConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, string_1.transformStringConstructorCall)(context, node);
             case "ObjectConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, object_1.transformObjectConstructorCall)(context, node);
             case "SymbolConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, symbol_1.transformSymbolConstructorCall)(context, node);
             case "NumberConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, number_1.transformNumberConstructorCall)(context, node);
             case "PromiseConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, promise_1.transformPromiseConstructorCall)(context, node);
         }
     }
     if ((0, typescript_1.isStringType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return (0, string_1.transformStringPrototypeCall)(context, node);
     }
     if ((0, typescript_1.isNumberType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return (0, number_1.transformNumberPrototypeCall)(context, node);
     }
     if ((0, typescript_1.isArrayType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return (0, array_1.transformArrayPrototypeCall)(context, node);
     }
     if ((0, typescript_1.isFunctionType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return (0, function_1.transformFunctionPrototypeCall)(context, node);
     }
-    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node);
+    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node, expression);
     if (objectResult) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return objectResult;
     }
 }

package/dist/transformation/builtins/object.d.ts

@@ -1,5 +1,6 @@
 import * as lua from "../../LuaAST";
+import * as ts from "typescript";
 import { TransformationContext } from "../context";
 import { PropertyCallExpression } from "../visitors/call";
 export declare function transformObjectConstructorCall(context: TransformationContext, expression: PropertyCallExpression): lua.Expression | undefined;
-export declare function transformObjectPrototypeCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformObjectPrototypeCall(context: TransformationContext, node: ts.CallExpression, expression: ts.PropertyAccessExpression): lua.Expression | undefined;

package/dist/transformation/builtins/object.js

@@ -31,8 +31,7 @@ function transformObjectConstructorCall(context, expression) {
     }
 }
 exports.transformObjectConstructorCall = transformObjectConstructorCall;
-function transformObjectPrototypeCall(context, node) {
-    const expression = node.expression;
+function transformObjectPrototypeCall(context, node, expression) {
     const signature = context.checker.getResolvedSignature(node);
     const name = expression.name.text;
     switch (name) {

package/dist/transformation/builtins/string.js

@@ -13,8 +13,7 @@ function createStringCall(methodName, tsOriginal, ...params) {
 function transformStringPrototypeCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "replace":

package/dist/transformation/context/context.d.ts

@@ -2,6 +2,7 @@ import * as ts from "typescript";
 import { CompilerOptions, LuaTarget } from "../../CompilerOptions";
 import * as lua from "../../LuaAST";
 import { ExpressionLikeNode, StatementLikeNode, VisitorMap } from "./visitors";
+export declare const tempSymbolId: lua.SymbolId;
 export interface AllAccessorDeclarations {
     firstAccessor: ts.AccessorDeclaration;
     secondAccessor: ts.AccessorDeclaration | undefined;
@@ -25,16 +26,27 @@ export declare class TransformationContext {
     readonly diagnostics: ts.Diagnostic[];
     readonly checker: DiagnosticsProducingTypeChecker;
     readonly resolver: EmitResolver;
+    readonly precedingStatementsStack: lua.Statement[][];
     readonly options: CompilerOptions;
     readonly luaTarget: LuaTarget;
     readonly isModule: boolean;
     readonly isStrict: boolean;
     constructor(program: ts.Program, sourceFile: ts.SourceFile, visitorMap: VisitorMap);
     private currentNodeVisitors;
+    private nextTempId;
     transformNode(node: ts.Node): lua.Node[];
     superTransformNode(node: ts.Node): lua.Node[];
     transformExpression(node: ExpressionLikeNode): lua.Expression;
     superTransformExpression(node: ExpressionLikeNode): lua.Expression;
     transformStatements(node: StatementLikeNode | readonly StatementLikeNode[]): lua.Statement[];
     superTransformStatements(node: StatementLikeNode | readonly StatementLikeNode[]): lua.Statement[];
+    pushPrecedingStatements(): void;
+    popPrecedingStatements(): lua.Statement[];
+    addPrecedingStatements(statements: lua.Statement | lua.Statement[]): void;
+    prependPrecedingStatements(statements: lua.Statement | lua.Statement[]): void;
+    createTempName(prefix?: string): string;
+    private getTempNameForLuaExpression;
+    createTempNameForLuaExpression(expression: lua.Expression): lua.Identifier;
+    private getTempNameForNode;
+    createTempNameForNode(node: ts.Node): lua.Identifier;
 }

package/dist/transformation/context/context.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransformationContext = void 0;
+exports.TransformationContext = exports.tempSymbolId = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
 const diagnostics_1 = require("../utils/diagnostics");
 const lua_ast_1 = require("../utils/lua-ast");
+const safe_names_1 = require("../utils/safe-names");
+exports.tempSymbolId = -1;
 class TransformationContext {
     constructor(program, sourceFile, visitorMap) {
         var _a, _b, _c;
@@ -15,12 +17,14 @@ class TransformationContext {
         this.visitorMap = visitorMap;
         this.diagnostics = [];
         this.checker = this.program.getDiagnosticsProducingTypeChecker();
+        this.precedingStatementsStack = [];
         this.options = this.program.getCompilerOptions();
         this.luaTarget = (_a = this.options.luaTarget) !== null && _a !== void 0 ? _a : CompilerOptions_1.LuaTarget.Universal;
         this.isModule = ts.isExternalModule(this.sourceFile);
         this.isStrict = ((_b = this.options.alwaysStrict) !== null && _b !== void 0 ? _b : this.options.strict) ||
             (this.isModule && this.options.target !== undefined && this.options.target >= ts.ScriptTarget.ES2015);
         this.currentNodeVisitors = [];
+        this.nextTempId = 0;
         // Use `getParseTreeNode` to get original SourceFile node, before it was substituted by custom transformers.
         // It's required because otherwise `getEmitResolver` won't use cached diagnostics, produced in `emitWorker`
         // and would try to re-analyze the file, which would fail because of replaced nodes.
@@ -67,10 +71,105 @@ class TransformationContext {
         return result;
     }
     transformStatements(node) {
-        return (0, utils_1.castArray)(node).flatMap(n => this.transformNode(n));
+        return (0, utils_1.castArray)(node).flatMap(n => {
+            this.pushPrecedingStatements();
+            const statements = this.transformNode(n);
+            statements.unshift(...this.popPrecedingStatements());
+            return statements;
+        });
     }
     superTransformStatements(node) {
-        return (0, utils_1.castArray)(node).flatMap(n => this.superTransformNode(n));
+        return (0, utils_1.castArray)(node).flatMap(n => {
+            this.pushPrecedingStatements();
+            const statements = this.superTransformNode(n);
+            statements.unshift(...this.popPrecedingStatements());
+            return statements;
+        });
+    }
+    pushPrecedingStatements() {
+        this.precedingStatementsStack.push([]);
+    }
+    popPrecedingStatements() {
+        const precedingStatements = this.precedingStatementsStack.pop();
+        (0, utils_1.assert)(precedingStatements);
+        return precedingStatements;
+    }
+    addPrecedingStatements(statements) {
+        const precedingStatements = this.precedingStatementsStack[this.precedingStatementsStack.length - 1];
+        (0, utils_1.assert)(precedingStatements);
+        if (!Array.isArray(statements)) {
+            statements = [statements];
+        }
+        precedingStatements.push(...statements);
+    }
+    prependPrecedingStatements(statements) {
+        const precedingStatements = this.precedingStatementsStack[this.precedingStatementsStack.length - 1];
+        (0, utils_1.assert)(precedingStatements);
+        if (!Array.isArray(statements)) {
+            statements = [statements];
+        }
+        precedingStatements.unshift(...statements);
+    }
+    createTempName(prefix = "temp") {
+        prefix = prefix.replace(/^_*/, ""); // Strip leading underscores because createSafeName will add them again
+        return (0, safe_names_1.createSafeName)(`${prefix}_${this.nextTempId++}`);
+    }
+    getTempNameForLuaExpression(expression) {
+        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 !== null && tableName !== void 0 ? tableName : "table"}_${indexName !== null && indexName !== void 0 ? indexName : "index"}`;
+            }
+        }
+    }
+    createTempNameForLuaExpression(expression) {
+        const name = this.getTempNameForLuaExpression(expression);
+        const identifier = lua.createIdentifier(this.createTempName(name), undefined, exports.tempSymbolId);
+        lua.setNodePosition(identifier, lua.getOriginalPos(expression));
+        return identifier;
+    }
+    getTempNameForNode(node) {
+        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 !== null && tableName !== void 0 ? tableName : "table"}_${indexName !== null && indexName !== void 0 ? indexName : "index"}`;
+            }
+        }
+    }
+    createTempNameForNode(node) {
+        const name = this.getTempNameForNode(node);
+        return lua.createIdentifier(this.createTempName(name), node, exports.tempSymbolId);
     }
 }
 exports.TransformationContext = TransformationContext;

package/dist/transformation/utils/diagnostics.d.ts

@@ -91,3 +91,9 @@ export declare const notAllowedOptionalAssignment: ((node: ts.Node, ...args: any
 export declare const awaitMustBeInAsyncFunction: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
+export declare const unsupportedBuiltinOptionalCall: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};
+export declare const unsupportedOptionalCompileMembersOnly: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};

package/dist/transformation/utils/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableSetExpression = exports.invalidTableDeleteExpression = exports.invalidTableExtensionUse = exports.invalidOperatorMappingUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
+exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableSetExpression = exports.invalidTableDeleteExpression = exports.invalidTableExtensionUse = exports.invalidOperatorMappingUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const utils_1 = require("../../utils");
@@ -58,4 +58,6 @@ exports.annotationDeprecated = createWarningDiagnosticFactory((kind) => `'@${kin
     `See https://typescripttolua.github.io/docs/advanced/compiler-annotations#${kind.toLowerCase()} for more information.`);
 exports.notAllowedOptionalAssignment = createErrorDiagnosticFactory("The left-hand side of an assignment expression may not be an optional property access.");
 exports.awaitMustBeInAsyncFunction = createErrorDiagnosticFactory("Await can only be used inside async functions.");
+exports.unsupportedBuiltinOptionalCall = createErrorDiagnosticFactory("Optional calls are not supported for builtin or language extension functions.");
+exports.unsupportedOptionalCompileMembersOnly = createErrorDiagnosticFactory("Optional calls are not supported on enums marked with @compileMembersOnly.");
 //# sourceMappingURL=diagnostics.js.map

package/dist/transformation/utils/lua-ast.d.ts

@@ -7,7 +7,6 @@ export declare function createSelfIdentifier(tsOriginal?: ts.Node): lua.Identifi
 export declare function createExportsIdentifier(): lua.Identifier;
 export declare function addToNumericExpression(expression: lua.Expression, change: number): lua.Expression;
 export declare function getNumberLiteralValue(expression?: lua.Expression): number | undefined;
-export declare function createImmediatelyInvokedFunctionExpression(statements: lua.Statement[], result: lua.Expression | lua.Expression[], tsOriginal?: ts.Node): lua.CallExpression;
 export declare function createUnpackCall(context: TransformationContext, expression: lua.Expression, tsOriginal?: ts.Node): lua.Expression;
 export declare function wrapInTable(...expressions: lua.Expression[]): lua.TableExpression;
 export declare function wrapInToStringForConcat(expression: lua.Expression): lua.Expression;

package/dist/transformation/utils/lua-ast.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNaN = exports.createLocalOrExportedOrGlobalDeclaration = exports.createHoistableVariableDeclarationStatement = exports.wrapInToStringForConcat = exports.wrapInTable = exports.createUnpackCall = exports.createImmediatelyInvokedFunctionExpression = exports.getNumberLiteralValue = exports.addToNumericExpression = exports.createExportsIdentifier = exports.createSelfIdentifier = exports.unwrapVisitorResult = void 0;
+exports.createNaN = exports.createLocalOrExportedOrGlobalDeclaration = exports.createHoistableVariableDeclarationStatement = exports.wrapInToStringForConcat = exports.wrapInTable = exports.createUnpackCall = exports.getNumberLiteralValue = exports.addToNumericExpression = exports.createExportsIdentifier = exports.createSelfIdentifier = exports.unwrapVisitorResult = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const lua = require("../../LuaAST");
@@ -55,15 +55,6 @@ function getNumberLiteralValue(expression) {
     return undefined;
 }
 exports.getNumberLiteralValue = getNumberLiteralValue;
-// 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.
-function createImmediatelyInvokedFunctionExpression(statements, result, tsOriginal) {
-    const body = [...statements, lua.createReturnStatement((0, utils_1.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);
-}
-exports.createImmediatelyInvokedFunctionExpression = createImmediatelyInvokedFunctionExpression;
 function createUnpackCall(context, expression, tsOriginal) {
     if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
         return (0, lualib_1.transformLuaLibFunction)(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
@@ -93,10 +84,7 @@ function createHoistableVariableDeclarationStatement(context, identifier, initia
     if (identifier.symbolId !== undefined) {
         const scope = (0, scope_1.peekScope)(context);
         (0, utils_1.assert)(scope.type !== scope_1.ScopeType.Switch);
-        if (!scope.variableDeclarations) {
-            scope.variableDeclarations = [];
-        }
-        scope.variableDeclarations.push(declaration);
+        (0, scope_1.addScopeVariableDeclaration)(scope, declaration);
     }
     return declaration;
 }
@@ -132,21 +120,24 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
         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
+                    (0, scope_1.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
+                    (0, scope_1.addScopeVariableDeclaration)(scope, declaration);
                 }
-                scope.variableDeclarations.push(declaration);
             }
         }
         else if (rhs) {

package/dist/transformation/utils/preceding-statements.d.ts

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

package/dist/transformation/utils/preceding-statements.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformInPrecedingStatementScope = void 0;
+function transformInPrecedingStatementScope(context, transformer) {
+    context.pushPrecedingStatements();
+    const statementOrStatements = transformer();
+    const precedingStatements = context.popPrecedingStatements();
+    return [precedingStatements, statementOrStatements];
+}
+exports.transformInPrecedingStatementScope = transformInPrecedingStatementScope;
+//# sourceMappingURL=preceding-statements.js.map

package/dist/transformation/utils/scope.d.ts

@@ -37,6 +37,7 @@ export declare function peekScope(context: TransformationContext): Scope;
 export declare function findScope(context: TransformationContext, scopeTypes: ScopeType): Scope | undefined;
 export declare function pushScope(context: TransformationContext, scopeType: ScopeType): Scope;
 export declare function popScope(context: TransformationContext): Scope;
+export declare function addScopeVariableDeclaration(scope: Scope, declaration: lua.VariableDeclarationStatement): void;
 export declare function hasReferencedUndefinedLocalFunction(context: TransformationContext, scope: Scope): boolean;
 export declare function hasReferencedSymbol(context: TransformationContext, scope: Scope, symbol: ts.Symbol): boolean | undefined;
 export declare function isFunctionScopeWithDefinition(scope: Scope): scope is Scope & {

package/dist/transformation/utils/scope.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.performHoisting = exports.separateHoistedStatements = exports.isFunctionScopeWithDefinition = exports.hasReferencedSymbol = exports.hasReferencedUndefinedLocalFunction = exports.popScope = exports.pushScope = exports.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
+exports.performHoisting = exports.separateHoistedStatements = exports.isFunctionScopeWithDefinition = exports.hasReferencedSymbol = exports.hasReferencedUndefinedLocalFunction = exports.addScopeVariableDeclaration = exports.popScope = exports.pushScope = exports.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
@@ -68,6 +68,13 @@ function popScope(context) {
     return scope;
 }
 exports.popScope = popScope;
+function addScopeVariableDeclaration(scope, declaration) {
+    if (!scope.variableDeclarations) {
+        scope.variableDeclarations = [];
+    }
+    scope.variableDeclarations.push(declaration);
+}
+exports.addScopeVariableDeclaration = addScopeVariableDeclaration;
 function isHoistableFunctionDeclaredInScope(symbol, scopeNode) {
     var _a;
     return (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => ts.isFunctionDeclaration(d) && (0, typescript_1.findFirstNodeAbove)(d, (n) => n === scopeNode));

package/dist/transformation/utils/typescript/index.d.ts

@@ -14,3 +14,4 @@ export declare function inferAssignedType(context: TransformationContext, expres
 export declare function getAllCallSignatures(type: ts.Type): readonly ts.Signature[];
 export declare function isExpressionWithEvaluationEffect(node: ts.Expression): boolean;
 export declare function getFunctionTypeForCall(context: TransformationContext, node: ts.CallExpression): ts.Type | undefined;
+export declare function isConstIdentifier(context: TransformationContext, node: ts.Node): boolean;

package/dist/transformation/utils/typescript/index.js

@@ -10,7 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.getFirstDeclarationInFile = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
+exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.getFirstDeclarationInFile = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
 const ts = require("typescript");
 __exportStar(require("./nodes"), exports);
 __exportStar(require("./types"), exports);
@@ -94,4 +94,19 @@ function getFunctionTypeForCall(context, node) {
     return context.checker.getTypeFromTypeNode(typeDeclaration.type);
 }
 exports.getFunctionTypeForCall = getFunctionTypeForCall;
+function isConstIdentifier(context, 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);
+}
+exports.isConstIdentifier = isConstIdentifier;
 //# sourceMappingURL=index.js.map

package/dist/transformation/visitors/access.d.ts

@@ -1,7 +1,10 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
+import { ExpressionWithThisValue } from "./optional-chaining";
 export declare function transformElementAccessArgument(context: TransformationContext, node: ts.ElementAccessExpression): lua.Expression;
 export declare const transformElementAccessExpression: FunctionVisitor<ts.ElementAccessExpression>;
+export declare function transformElementAccessExpressionWithCapture(context: TransformationContext, node: ts.ElementAccessExpression, thisValueCapture: lua.Identifier | undefined): ExpressionWithThisValue;
 export declare const transformPropertyAccessExpression: FunctionVisitor<ts.PropertyAccessExpression>;
+export declare function transformPropertyAccessExpressionWithCapture(context: TransformationContext, node: ts.PropertyAccessExpression, thisValueCapture: lua.Identifier | undefined): ExpressionWithThisValue;
 export declare const transformQualifiedName: FunctionVisitor<ts.QualifiedName>;