typescript-to-lua 1.0.1 → 1.3.0

package/dist/transformation/utils/language-extensions.d.ts

@@ -6,6 +6,7 @@ export declare enum ExtensionKind {
     RangeFunction = "RangeFunction",
     VarargConstant = "VarargConstant",
     IterableType = "IterableType",
+    PairsIterableType = "PairsIterableType",
     AdditionOperatorType = "AdditionOperatorType",
     AdditionOperatorMethodType = "AdditionOperatorMethodType",
     SubtractionOperatorType = "SubtractionOperatorType",
@@ -53,4 +54,5 @@ export declare enum ExtensionKind {
     TableSetMethodType = "TableSetMethodType"
 }
 export declare function isExtensionType(type: ts.Type, extensionKind: ExtensionKind): boolean;
+export declare function getExtensionKinds(type: ts.Type): ExtensionKind[];
 export declare function isExtensionValue(context: TransformationContext, symbol: ts.Symbol, extensionKind: ExtensionKind): boolean;

package/dist/transformation/utils/language-extensions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExtensionValue = exports.isExtensionType = exports.ExtensionKind = void 0;
+exports.isExtensionValue = exports.getExtensionKinds = exports.isExtensionType = exports.ExtensionKind = void 0;
 var ExtensionKind;
 (function (ExtensionKind) {
     ExtensionKind["MultiFunction"] = "MultiFunction";
@@ -8,6 +8,7 @@ var ExtensionKind;
     ExtensionKind["RangeFunction"] = "RangeFunction";
     ExtensionKind["VarargConstant"] = "VarargConstant";
     ExtensionKind["IterableType"] = "IterableType";
+    ExtensionKind["PairsIterableType"] = "PairsIterableType";
     ExtensionKind["AdditionOperatorType"] = "AdditionOperatorType";
     ExtensionKind["AdditionOperatorMethodType"] = "AdditionOperatorMethodType";
     ExtensionKind["SubtractionOperatorType"] = "SubtractionOperatorType";
@@ -65,6 +66,7 @@ const extensionKindToTypeBrand = {
     [ExtensionKind.RangeFunction]: "__luaRangeFunctionBrand",
     [ExtensionKind.VarargConstant]: "__luaVarargConstantBrand",
     [ExtensionKind.IterableType]: "__luaIterableBrand",
+    [ExtensionKind.PairsIterableType]: "__luaPairsIterableBrand",
     [ExtensionKind.AdditionOperatorType]: "__luaAdditionBrand",
     [ExtensionKind.AdditionOperatorMethodType]: "__luaAdditionMethodBrand",
     [ExtensionKind.SubtractionOperatorType]: "__luaSubtractionBrand",
@@ -116,6 +118,10 @@ function isExtensionType(type, extensionKind) {
     return typeBrand !== undefined && type.getProperty(typeBrand) !== undefined;
 }
 exports.isExtensionType = isExtensionType;
+function getExtensionKinds(type) {
+    return Object.keys(extensionKindToTypeBrand).filter(e => type.getProperty(extensionKindToTypeBrand[e]) !== undefined);
+}
+exports.getExtensionKinds = getExtensionKinds;
 function isExtensionValue(context, symbol, extensionKind) {
     var _a;
     return (symbol.getName() === extensionKindToValueName[extensionKind] &&

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");
@@ -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);
+            const isLuaFunctionExpression = rhs && !Array.isArray(rhs) && lua.isFunctionExpression(rhs);
+            const isSafeRecursiveFunctionDeclaration = isFunctionDeclaration && isLuaFunctionExpression;
+            if (!isSafeRecursiveFunctionDeclaration && 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);
                 }
+                // 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.d.ts

@@ -1,8 +1,10 @@
 import * as ts from "typescript";
+import { CompilerOptions } from "../..";
 import { TransformationContext } from "../context";
-export declare const isValidLuaIdentifier: (name: string) => boolean;
+export declare const shouldAllowUnicode: (options: CompilerOptions) => boolean;
+export declare const isValidLuaIdentifier: (name: string, options: CompilerOptions) => boolean;
 export declare const luaKeywords: ReadonlySet<string>;
-export declare const isUnsafeName: (name: string) => boolean;
+export declare const isUnsafeName: (name: string, options: CompilerOptions) => boolean;
 export declare function hasUnsafeSymbolName(context: TransformationContext, symbol: ts.Symbol, tsOriginal: ts.Identifier): boolean;
 export declare function hasUnsafeIdentifierName(context: TransformationContext, identifier: ts.Identifier, checkSymbol?: boolean): boolean;
 export declare const createSafeName: (name: string) => string;

package/dist/transformation/utils/safe-names.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSafeName = exports.hasUnsafeIdentifierName = exports.hasUnsafeSymbolName = exports.isUnsafeName = exports.luaKeywords = exports.isValidLuaIdentifier = void 0;
+exports.createSafeName = exports.hasUnsafeIdentifierName = exports.hasUnsafeSymbolName = exports.isUnsafeName = exports.luaKeywords = exports.isValidLuaIdentifier = exports.shouldAllowUnicode = void 0;
+const __1 = require("../..");
 const diagnostics_1 = require("./diagnostics");
 const export_1 = require("./export");
 const typescript_1 = require("./typescript");
-const isValidLuaIdentifier = (name) => !exports.luaKeywords.has(name) && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+const shouldAllowUnicode = (options) => options.luaTarget === __1.LuaTarget.LuaJIT;
+exports.shouldAllowUnicode = shouldAllowUnicode;
+const isValidLuaIdentifier = (name, options) => !exports.luaKeywords.has(name) &&
+    ((0, exports.shouldAllowUnicode)(options)
+        ? /^[a-zA-Z_\u007F-\uFFFD][a-zA-Z0-9_\u007F-\uFFFD]*$/
+        : /^[a-zA-Z_][a-zA-Z0-9_]*$/).test(name);
 exports.isValidLuaIdentifier = isValidLuaIdentifier;
 exports.luaKeywords = new Set([
     "and",
@@ -51,27 +57,27 @@ const luaBuiltins = new Set([
     "type",
     "unpack",
 ]);
-const isUnsafeName = (name) => !exports.isValidLuaIdentifier(name) || luaBuiltins.has(name);
+const isUnsafeName = (name, options) => !(0, exports.isValidLuaIdentifier)(name, options) || luaBuiltins.has(name);
 exports.isUnsafeName = isUnsafeName;
 function checkName(context, name, node) {
-    const isInvalid = !exports.isValidLuaIdentifier(name);
+    const isInvalid = !(0, exports.isValidLuaIdentifier)(name, context.options);
     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, context.options) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
 }
 exports.hasUnsafeSymbolName = hasUnsafeSymbolName;
 function hasUnsafeIdentifierName(context, identifier, checkSymbol = true) {

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

@@ -9,7 +9,8 @@ export declare enum ScopeType {
     Conditional = 16,
     Block = 32,
     Try = 64,
-    Catch = 128
+    Catch = 128,
+    LoopInitializer = 256
 }
 interface FunctionDefinitionInfo {
     referencedSymbols: Map<lua.SymbolId, ts.Node[]>;
@@ -26,16 +27,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");
@@ -16,10 +16,11 @@ var ScopeType;
     ScopeType[ScopeType["Block"] = 32] = "Block";
     ScopeType[ScopeType["Try"] = 64] = "Try";
     ScopeType[ScopeType["Catch"] = 128] = "Catch";
+    ScopeType[ScopeType["LoopInitializer"] = 256] = "LoopInitializer";
 })(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 +35,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 +43,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 +65,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 +114,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 +159,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 +176,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!
  */