typescript-to-lua 1.0.0 → 1.2.0

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");
@@ -10,7 +10,7 @@ const scope_1 = require("./scope");
 const lualib_1 = require("./lualib");
 const LuaLib_1 = require("../../LuaLib");
 function unwrapVisitorResult(result) {
-    return result === undefined ? [] : utils_1.castArray(result);
+    return result === undefined ? [] : (0, utils_1.castArray)(result);
 }
 exports.unwrapVisitorResult = unwrapVisitorResult;
 function createSelfIdentifier(tsOriginal) {
@@ -55,18 +55,9 @@ 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(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 lualib_1.transformLuaLibFunction(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
+        return (0, lualib_1.transformLuaLibFunction)(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
     }
     const unpack = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 || context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT
         ? lua.createIdentifier("unpack")
@@ -91,12 +82,9 @@ exports.wrapInToStringForConcat = wrapInToStringForConcat;
 function createHoistableVariableDeclarationStatement(context, identifier, initializer, tsOriginal) {
     const declaration = lua.createVariableDeclarationStatement(identifier, initializer, tsOriginal);
     if (identifier.symbolId !== undefined) {
-        const scope = scope_1.peekScope(context);
-        utils_1.assert(scope.type !== scope_1.ScopeType.Switch);
-        if (!scope.variableDeclarations) {
-            scope.variableDeclarations = [];
-        }
-        scope.variableDeclarations.push(declaration);
+        const scope = (0, scope_1.peekScope)(context);
+        (0, utils_1.assert)(scope.type !== scope_1.ScopeType.Switch);
+        (0, scope_1.addScopeVariableDeclaration)(scope, declaration);
     }
     return declaration;
 }
@@ -106,48 +94,50 @@ function hasMultipleReferences(scope, identifiers) {
     if (!scopeSymbols) {
         return false;
     }
-    const referenceLists = utils_1.castArray(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
+    const referenceLists = (0, utils_1.castArray)(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
     return referenceLists.some(symbolRefs => symbolRefs && symbolRefs.length > 1);
 }
 function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal, overrideExportScope) {
     let declaration;
     let assignment;
     const isFunctionDeclaration = tsOriginal !== undefined && ts.isFunctionDeclaration(tsOriginal);
-    const identifiers = utils_1.castArray(lhs);
+    const identifiers = (0, utils_1.castArray)(lhs);
     if (identifiers.length === 0) {
         return [];
     }
-    const exportScope = overrideExportScope !== null && overrideExportScope !== void 0 ? overrideExportScope : export_1.getIdentifierExportScope(context, identifiers[0]);
+    const exportScope = overrideExportScope !== null && overrideExportScope !== void 0 ? overrideExportScope : (0, export_1.getIdentifierExportScope)(context, identifiers[0]);
     if (exportScope) {
         // exported
         if (!rhs) {
             return [];
         }
         else {
-            assignment = lua.createAssignmentStatement(identifiers.map(identifier => export_1.createExportedIdentifier(context, identifier, exportScope)), rhs, tsOriginal);
+            assignment = lua.createAssignmentStatement(identifiers.map(identifier => (0, export_1.createExportedIdentifier)(context, identifier, exportScope)), rhs, tsOriginal);
         }
     }
     else {
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
         if (context.isModule || !isTopLevelVariable) {
-            if (scope.type === scope_1.ScopeType.Switch || (!isFunctionDeclaration && hasMultipleReferences(scope, lhs))) {
-                // Split declaration and assignment of identifiers that reference themselves in their declaration
-                declaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
+            if (!isFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
+                // 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);
-            }
-            // Remember local variable declarations for hoisting later
-            if (!scope.variableDeclarations) {
-                scope.variableDeclarations = [];
-            }
-            scope.variableDeclarations.push(declaration);
-            if (scope.type === scope_1.ScopeType.Switch) {
-                declaration = undefined;
+                if (!isFunctionDeclaration) {
+                    // Remember local variable declarations for hoisting later
+                    (0, scope_1.addScopeVariableDeclaration)(scope, declaration);
+                }
             }
         }
         else if (rhs) {
@@ -161,7 +151,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
     if (isFunctionDeclaration) {
         // Remember function definitions for hoisting later
         const functionSymbolId = lhs.symbolId;
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         if (functionSymbolId && scope.functionDefinitions) {
             const definitions = scope.functionDefinitions.get(functionSymbolId);
             if (definitions) {

package/dist/transformation/utils/lualib.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "LuaLibFeature", { enumerable: true, get: functio
 const utils_1 = require("../../utils");
 const luaLibFeatures = new WeakMap();
 function getUsedLuaLibFeatures(context) {
-    return utils_1.getOrUpdate(luaLibFeatures, context, () => new Set());
+    return (0, utils_1.getOrUpdate)(luaLibFeatures, context, () => new Set());
 }
 exports.getUsedLuaLibFeatures = getUsedLuaLibFeatures;
 function importLuaLibFeature(context, feature) {

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/safe-names.js

@@ -51,27 +51,27 @@ const luaBuiltins = new Set([
     "type",
     "unpack",
 ]);
-const isUnsafeName = (name) => !exports.isValidLuaIdentifier(name) || luaBuiltins.has(name);
+const isUnsafeName = (name) => !(0, exports.isValidLuaIdentifier)(name) || luaBuiltins.has(name);
 exports.isUnsafeName = isUnsafeName;
 function checkName(context, name, node) {
-    const isInvalid = !exports.isValidLuaIdentifier(name);
+    const isInvalid = !(0, exports.isValidLuaIdentifier)(name);
     if (isInvalid) {
         // Empty identifier is a TypeScript error
         if (name !== "") {
-            context.diagnostics.push(diagnostics_1.invalidAmbientIdentifierName(node, name));
+            context.diagnostics.push((0, diagnostics_1.invalidAmbientIdentifierName)(node, name));
         }
     }
     return isInvalid;
 }
 function hasUnsafeSymbolName(context, symbol, tsOriginal) {
     var _a, _b;
-    const isAmbient = (_b = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => typescript_1.isAmbientNode(d))) !== null && _b !== void 0 ? _b : false;
+    const isAmbient = (_b = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => (0, typescript_1.isAmbientNode)(d))) !== null && _b !== void 0 ? _b : false;
     // Catch ambient declarations of identifiers with bad names
     if (isAmbient && checkName(context, symbol.name, tsOriginal)) {
         return true;
     }
     // only unsafe when non-ambient and not exported
-    return exports.isUnsafeName(symbol.name) && !isAmbient && !export_1.isSymbolExported(context, symbol);
+    return (0, exports.isUnsafeName)(symbol.name) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
 }
 exports.hasUnsafeSymbolName = hasUnsafeSymbolName;
 function hasUnsafeIdentifierName(context, identifier, checkSymbol = true) {

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

@@ -26,16 +26,23 @@ export interface Scope {
     loopContinued?: boolean;
     functionReturned?: boolean;
 }
+export interface HoistingResult {
+    statements: lua.Statement[];
+    hoistedStatements: lua.Statement[];
+    hoistedIdentifiers: lua.Identifier[];
+}
 export declare function walkScopesUp(context: TransformationContext): IterableIterator<Scope>;
 export declare function markSymbolAsReferencedInCurrentScopes(context: TransformationContext, symbolId: lua.SymbolId, identifier: ts.Identifier): void;
 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 & {
     node: ts.SignatureDeclaration;
 };
+export declare function separateHoistedStatements(context: TransformationContext, statements: lua.Statement[]): HoistingResult;
 export declare function performHoisting(context: TransformationContext, statements: lua.Statement[]): lua.Statement[];
 export {};

package/dist/transformation/utils/scope.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.performHoisting = 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");
@@ -19,7 +19,7 @@ var ScopeType;
 })(ScopeType = exports.ScopeType || (exports.ScopeType = {}));
 const scopeStacks = new WeakMap();
 function getScopeStack(context) {
-    return utils_1.getOrUpdate(scopeStacks, context, () => []);
+    return (0, utils_1.getOrUpdate)(scopeStacks, context, () => []);
 }
 function* walkScopesUp(context) {
     const scopeStack = getScopeStack(context);
@@ -34,7 +34,7 @@ function markSymbolAsReferencedInCurrentScopes(context, symbolId, identifier) {
         if (!scope.referencedSymbols) {
             scope.referencedSymbols = new Map();
         }
-        const references = utils_1.getOrUpdate(scope.referencedSymbols, symbolId, () => []);
+        const references = (0, utils_1.getOrUpdate)(scope.referencedSymbols, symbolId, () => []);
         references.push(identifier);
     }
 }
@@ -42,7 +42,7 @@ exports.markSymbolAsReferencedInCurrentScopes = markSymbolAsReferencedInCurrentS
 function peekScope(context) {
     const scopeStack = getScopeStack(context);
     const scope = scopeStack[scopeStack.length - 1];
-    utils_1.assert(scope);
+    (0, utils_1.assert)(scope);
     return scope;
 }
 exports.peekScope = peekScope;
@@ -64,13 +64,20 @@ exports.pushScope = pushScope;
 function popScope(context) {
     const scopeStack = getScopeStack(context);
     const scope = scopeStack.pop();
-    utils_1.assert(scope);
+    (0, utils_1.assert)(scope);
     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) && typescript_1.findFirstNodeAbove(d, (n) => n === scopeNode));
+    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));
 }
 // Checks for references to local functions which haven't been defined yet,
 // and thus will be hoisted above the current position.
@@ -106,21 +113,43 @@ function isFunctionScopeWithDefinition(scope) {
     return scope.node !== undefined && ts.isFunctionLike(scope.node);
 }
 exports.isFunctionScopeWithDefinition = isFunctionScopeWithDefinition;
-function performHoisting(context, statements) {
+function separateHoistedStatements(context, statements) {
     const scope = peekScope(context);
-    let result = statements;
-    result = hoistFunctionDefinitions(context, scope, result);
-    result = hoistVariableDeclarations(context, scope, result);
-    result = hoistImportStatements(scope, result);
-    return result;
+    const allHoistedStatments = [];
+    const allHoistedIdentifiers = [];
+    let { unhoistedStatements, hoistedStatements, hoistedIdentifiers } = hoistFunctionDefinitions(context, scope, statements);
+    allHoistedStatments.push(...hoistedStatements);
+    allHoistedIdentifiers.push(...hoistedIdentifiers);
+    ({ unhoistedStatements, hoistedIdentifiers } = hoistVariableDeclarations(context, scope, unhoistedStatements));
+    allHoistedIdentifiers.push(...hoistedIdentifiers);
+    ({ unhoistedStatements, hoistedStatements } = hoistImportStatements(scope, unhoistedStatements));
+    allHoistedStatments.unshift(...hoistedStatements);
+    return {
+        statements: unhoistedStatements,
+        hoistedStatements: allHoistedStatments,
+        hoistedIdentifiers: allHoistedIdentifiers,
+    };
+}
+exports.separateHoistedStatements = separateHoistedStatements;
+function performHoisting(context, statements) {
+    const result = separateHoistedStatements(context, statements);
+    const modifiedStatements = [...result.hoistedStatements, ...result.statements];
+    if (result.hoistedIdentifiers.length > 0) {
+        modifiedStatements.unshift(lua.createVariableDeclarationStatement(result.hoistedIdentifiers));
+    }
+    return modifiedStatements;
 }
 exports.performHoisting = performHoisting;
 function shouldHoistSymbol(context, symbolId, scope) {
-    const symbolInfo = symbols_1.getSymbolInfo(context, symbolId);
+    // Always hoist in top-level of switch statements
+    if (scope.type === ScopeType.Switch) {
+        return true;
+    }
+    const symbolInfo = (0, symbols_1.getSymbolInfo)(context, symbolId);
     if (!symbolInfo) {
         return false;
     }
-    const declaration = typescript_1.getFirstDeclarationInFile(symbolInfo.symbol, context.sourceFile);
+    const declaration = (0, typescript_1.getFirstDeclarationInFile)(symbolInfo.symbol, context.sourceFile);
     if (!declaration) {
         return false;
     }
@@ -129,7 +158,7 @@ function shouldHoistSymbol(context, symbolId, scope) {
     }
     if (scope.functionDefinitions) {
         for (const [functionSymbolId, functionDefinition] of scope.functionDefinitions) {
-            utils_1.assert(functionDefinition.definition);
+            (0, utils_1.assert)(functionDefinition.definition);
             const { line, column } = lua.getOriginalPos(functionDefinition.definition);
             if (line !== undefined && column !== undefined) {
                 const definitionPos = ts.getPositionOfLineAndCharacter(context.sourceFile, line, column);
@@ -146,52 +175,60 @@ function shouldHoistSymbol(context, symbolId, scope) {
 }
 function hoistVariableDeclarations(context, scope, statements) {
     if (!scope.variableDeclarations) {
-        return statements;
+        return { unhoistedStatements: statements, hoistedIdentifiers: [] };
     }
-    const result = [...statements];
-    const hoistedLocals = [];
+    const unhoistedStatements = [...statements];
+    const hoistedIdentifiers = [];
     for (const declaration of scope.variableDeclarations) {
         const symbols = declaration.left.map(i => i.symbolId).filter(utils_1.isNonNull);
         if (symbols.some(s => shouldHoistSymbol(context, s, scope))) {
-            const index = result.indexOf(declaration);
-            utils_1.assert(index > -1);
+            const index = unhoistedStatements.indexOf(declaration);
+            if (index < 0) {
+                continue; // statements array may not contain all statements in the scope (switch-case)
+            }
             if (declaration.right) {
                 const assignment = lua.createAssignmentStatement(declaration.left, declaration.right);
                 lua.setNodePosition(assignment, declaration); // Preserve position info for sourcemap
-                result.splice(index, 1, assignment);
+                unhoistedStatements.splice(index, 1, assignment);
             }
             else {
-                result.splice(index, 1);
+                unhoistedStatements.splice(index, 1);
             }
-            hoistedLocals.push(...declaration.left);
-        }
-        else if (scope.type === ScopeType.Switch) {
-            utils_1.assert(!declaration.right);
-            hoistedLocals.push(...declaration.left);
+            hoistedIdentifiers.push(...declaration.left);
         }
     }
-    if (hoistedLocals.length > 0) {
-        result.unshift(lua.createVariableDeclarationStatement(hoistedLocals));
-    }
-    return result;
+    return { unhoistedStatements, hoistedIdentifiers };
 }
 function hoistFunctionDefinitions(context, scope, statements) {
     if (!scope.functionDefinitions) {
-        return statements;
+        return { unhoistedStatements: statements, hoistedStatements: [], hoistedIdentifiers: [] };
     }
-    const result = [...statements];
-    const hoistedFunctions = [];
+    const unhoistedStatements = [...statements];
+    const hoistedStatements = [];
+    const hoistedIdentifiers = [];
     for (const [functionSymbolId, functionDefinition] of scope.functionDefinitions) {
-        utils_1.assert(functionDefinition.definition);
+        (0, utils_1.assert)(functionDefinition.definition);
         if (shouldHoistSymbol(context, functionSymbolId, scope)) {
-            const index = result.indexOf(functionDefinition.definition);
-            result.splice(index, 1);
-            hoistedFunctions.push(functionDefinition.definition);
+            const index = unhoistedStatements.indexOf(functionDefinition.definition);
+            if (index < 0) {
+                continue; // statements array may not contain all statements in the scope (switch-case)
+            }
+            unhoistedStatements.splice(index, 1);
+            if (lua.isVariableDeclarationStatement(functionDefinition.definition)) {
+                // Separate function definition and variable declaration
+                (0, utils_1.assert)(functionDefinition.definition.right);
+                hoistedIdentifiers.push(...functionDefinition.definition.left);
+                hoistedStatements.push(lua.createAssignmentStatement(functionDefinition.definition.left, functionDefinition.definition.right));
+            }
+            else {
+                hoistedStatements.push(functionDefinition.definition);
+            }
         }
     }
-    return [...hoistedFunctions, ...result];
+    return { unhoistedStatements, hoistedStatements, hoistedIdentifiers };
 }
 function hoistImportStatements(scope, statements) {
-    return scope.importStatements ? [...scope.importStatements, ...statements] : statements;
+    var _a;
+    return { unhoistedStatements: statements, hoistedStatements: (_a = scope.importStatements) !== null && _a !== void 0 ? _a : [] };
 }
 //# sourceMappingURL=scope.js.map

package/dist/transformation/utils/symbols.js

@@ -14,27 +14,27 @@ function nextSymbolId(context) {
 const symbolInfoMap = new WeakMap();
 const symbolIdMaps = new WeakMap();
 function getSymbolInfo(context, symbolId) {
-    return utils_1.getOrUpdate(symbolInfoMap, context, () => new Map()).get(symbolId);
+    return (0, utils_1.getOrUpdate)(symbolInfoMap, context, () => new Map()).get(symbolId);
 }
 exports.getSymbolInfo = getSymbolInfo;
 function getSymbolIdOfSymbol(context, symbol) {
-    return utils_1.getOrUpdate(symbolIdMaps, context, () => new Map()).get(symbol);
+    return (0, utils_1.getOrUpdate)(symbolIdMaps, context, () => new Map()).get(symbol);
 }
 exports.getSymbolIdOfSymbol = getSymbolIdOfSymbol;
 function trackSymbolReference(context, symbol, identifier) {
-    const symbolIds = utils_1.getOrUpdate(symbolIdMaps, context, () => new Map());
+    const symbolIds = (0, utils_1.getOrUpdate)(symbolIdMaps, context, () => new Map());
     // Track first time symbols are seen
     let symbolId = symbolIds.get(symbol);
     if (symbolId === undefined) {
         symbolId = nextSymbolId(context);
         symbolIds.set(symbol, symbolId);
-        const symbolInfo = utils_1.getOrUpdate(symbolInfoMap, context, () => new Map());
+        const symbolInfo = (0, utils_1.getOrUpdate)(symbolInfoMap, context, () => new Map());
         symbolInfo.set(symbolId, { symbol, firstSeenAtPos: identifier.pos });
     }
     // If isOptimizedVarArgSpread returns true, the identifier will not appear in the resulting Lua.
     // Only the optimized ellipses (...) will be used.
-    if (!spread_1.isOptimizedVarArgSpread(context, symbol, identifier)) {
-        scope_1.markSymbolAsReferencedInCurrentScopes(context, symbolId, identifier);
+    if (!(0, spread_1.isOptimizedVarArgSpread)(context, symbol, identifier)) {
+        (0, scope_1.markSymbolAsReferencedInCurrentScopes)(context, symbolId, identifier);
     }
     return symbolId;
 }

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/utils/typescript/nodes.d.ts

@@ -4,6 +4,8 @@ export declare function isAssignmentPattern(node: ts.Node): node is ts.Assignmen
 export declare function isDestructuringAssignment(node: ts.Node): node is ts.DestructuringAssignment;
 export declare function isAmbientNode(node: ts.Declaration): boolean;
 export declare function isInDestructingAssignment(node: ts.Node): boolean;
+export declare function isInAsyncFunction(node: ts.Node): boolean;
+export declare function isInGeneratorFunction(node: ts.Node): boolean;
 /**
  * Quite hacky, avoid unless absolutely necessary!
  */

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFirstDeclaration = exports.getSymbolOfNode = exports.isInDestructingAssignment = exports.isAmbientNode = exports.isDestructuringAssignment = exports.isAssignmentPattern = void 0;
+exports.isFirstDeclaration = exports.getSymbolOfNode = exports.isInGeneratorFunction = exports.isInAsyncFunction = exports.isInDestructingAssignment = exports.isAmbientNode = exports.isDestructuringAssignment = exports.isAssignmentPattern = void 0;
 const ts = require("typescript");
+const _1 = require(".");
 function isAssignmentPattern(node) {
     return ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node);
 }
@@ -22,6 +23,25 @@ function isInDestructingAssignment(node) {
             (ts.isBinaryExpression(node.parent) && ts.isArrayLiteralExpression(node.parent.left))));
 }
 exports.isInDestructingAssignment = isInDestructingAssignment;
+function isInAsyncFunction(node) {
+    var _a, _b;
+    // Check if node is in function declaration with `async`
+    const declaration = (0, _1.findFirstNodeAbove)(node, ts.isFunctionLike);
+    if (!declaration) {
+        return false;
+    }
+    return (_b = (_a = declaration.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) !== null && _b !== void 0 ? _b : false;
+}
+exports.isInAsyncFunction = isInAsyncFunction;
+function isInGeneratorFunction(node) {
+    // Check if node is in function declaration with `async`
+    const declaration = (0, _1.findFirstNodeAbove)(node, ts.isFunctionDeclaration);
+    if (!declaration) {
+        return false;
+    }
+    return declaration.asteriskToken !== undefined;
+}
+exports.isInGeneratorFunction = isInGeneratorFunction;
 /**
  * Quite hacky, avoid unless absolutely necessary!
  */

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>;