typescript-to-lua 1.6.1 → 1.7.0

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

@@ -1,131 +1,111 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExtensionValue = exports.getExtensionKinds = exports.isExtensionType = exports.ExtensionKind = void 0;
+exports.getIterableExtensionKindForNode = exports.getIterableExtensionTypeForType = exports.IterableExtensionKind = exports.getExtensionKindForSymbol = exports.getExtensionKindForNode = exports.getExtensionKindForType = exports.ExtensionKind = void 0;
+const ts = require("typescript");
 var ExtensionKind;
 (function (ExtensionKind) {
     ExtensionKind["MultiFunction"] = "MultiFunction";
-    ExtensionKind["MultiType"] = "MultiType";
     ExtensionKind["RangeFunction"] = "RangeFunction";
     ExtensionKind["VarargConstant"] = "VarargConstant";
-    ExtensionKind["IterableType"] = "IterableType";
-    ExtensionKind["PairsIterableType"] = "PairsIterableType";
-    ExtensionKind["AdditionOperatorType"] = "AdditionOperatorType";
-    ExtensionKind["AdditionOperatorMethodType"] = "AdditionOperatorMethodType";
-    ExtensionKind["SubtractionOperatorType"] = "SubtractionOperatorType";
-    ExtensionKind["SubtractionOperatorMethodType"] = "SubtractionOperatorMethodType";
-    ExtensionKind["MultiplicationOperatorType"] = "MultiplicationOperatorType";
-    ExtensionKind["MultiplicationOperatorMethodType"] = "MultiplicationOperatorMethodType";
-    ExtensionKind["DivisionOperatorType"] = "DivisionOperatorType";
-    ExtensionKind["DivisionOperatorMethodType"] = "DivisionOperatorMethodType";
-    ExtensionKind["ModuloOperatorType"] = "ModuloOperatorType";
-    ExtensionKind["ModuloOperatorMethodType"] = "ModuloOperatorMethodType";
-    ExtensionKind["PowerOperatorType"] = "PowerOperatorType";
-    ExtensionKind["PowerOperatorMethodType"] = "PowerOperatorMethodType";
-    ExtensionKind["FloorDivisionOperatorType"] = "FloorDivisionOperatorType";
-    ExtensionKind["FloorDivisionOperatorMethodType"] = "FloorDivisionOperatorMethodType";
-    ExtensionKind["BitwiseAndOperatorType"] = "BitwiseAndOperatorType";
-    ExtensionKind["BitwiseAndOperatorMethodType"] = "BitwiseAndOperatorMethodType";
-    ExtensionKind["BitwiseOrOperatorType"] = "BitwiseOrOperatorType";
-    ExtensionKind["BitwiseOrOperatorMethodType"] = "BitwiseOrOperatorMethodType";
-    ExtensionKind["BitwiseExclusiveOrOperatorType"] = "BitwiseExclusiveOrOperatorType";
-    ExtensionKind["BitwiseExclusiveOrOperatorMethodType"] = "BitwiseExclusiveOrOperatorMethodType";
-    ExtensionKind["BitwiseLeftShiftOperatorType"] = "BitwiseLeftShiftOperatorType";
-    ExtensionKind["BitwiseLeftShiftOperatorMethodType"] = "BitwiseLeftShiftOperatorMethodType";
-    ExtensionKind["BitwiseRightShiftOperatorType"] = "BitwiseRightShiftOperatorType";
-    ExtensionKind["BitwiseRightShiftOperatorMethodType"] = "BitwiseRightShiftOperatorMethodType";
-    ExtensionKind["ConcatOperatorType"] = "ConcatOperatorType";
-    ExtensionKind["ConcatOperatorMethodType"] = "ConcatOperatorMethodType";
-    ExtensionKind["LessThanOperatorType"] = "LessThanOperatorType";
-    ExtensionKind["LessThanOperatorMethodType"] = "LessThanOperatorMethodType";
-    ExtensionKind["GreaterThanOperatorType"] = "GreaterThanOperatorType";
-    ExtensionKind["GreaterThanOperatorMethodType"] = "GreaterThanOperatorMethodType";
-    ExtensionKind["NegationOperatorType"] = "NegationOperatorType";
-    ExtensionKind["NegationOperatorMethodType"] = "NegationOperatorMethodType";
-    ExtensionKind["BitwiseNotOperatorType"] = "BitwiseNotOperatorType";
-    ExtensionKind["BitwiseNotOperatorMethodType"] = "BitwiseNotOperatorMethodType";
-    ExtensionKind["LengthOperatorType"] = "LengthOperatorType";
-    ExtensionKind["LengthOperatorMethodType"] = "LengthOperatorMethodType";
-    ExtensionKind["TableNewType"] = "TableNewType";
-    ExtensionKind["TableDeleteType"] = "TableDeleteType";
-    ExtensionKind["TableDeleteMethodType"] = "TableDeleteMethodType";
-    ExtensionKind["TableGetType"] = "TableGetType";
-    ExtensionKind["TableGetMethodType"] = "TableGetMethodType";
-    ExtensionKind["TableHasType"] = "TableHasType";
-    ExtensionKind["TableHasMethodType"] = "TableHasMethodType";
-    ExtensionKind["TableSetType"] = "TableSetType";
-    ExtensionKind["TableSetMethodType"] = "TableSetMethodType";
+    ExtensionKind["AdditionOperatorType"] = "Addition";
+    ExtensionKind["AdditionOperatorMethodType"] = "AdditionMethod";
+    ExtensionKind["SubtractionOperatorType"] = "Subtraction";
+    ExtensionKind["SubtractionOperatorMethodType"] = "SubtractionMethod";
+    ExtensionKind["MultiplicationOperatorType"] = "Multiplication";
+    ExtensionKind["MultiplicationOperatorMethodType"] = "MultiplicationMethod";
+    ExtensionKind["DivisionOperatorType"] = "Division";
+    ExtensionKind["DivisionOperatorMethodType"] = "DivisionMethod";
+    ExtensionKind["ModuloOperatorType"] = "Modulo";
+    ExtensionKind["ModuloOperatorMethodType"] = "ModuloMethod";
+    ExtensionKind["PowerOperatorType"] = "Power";
+    ExtensionKind["PowerOperatorMethodType"] = "PowerMethod";
+    ExtensionKind["FloorDivisionOperatorType"] = "FloorDivision";
+    ExtensionKind["FloorDivisionOperatorMethodType"] = "FloorDivisionMethod";
+    ExtensionKind["BitwiseAndOperatorType"] = "BitwiseAnd";
+    ExtensionKind["BitwiseAndOperatorMethodType"] = "BitwiseAndMethod";
+    ExtensionKind["BitwiseOrOperatorType"] = "BitwiseOr";
+    ExtensionKind["BitwiseOrOperatorMethodType"] = "BitwiseOrMethod";
+    ExtensionKind["BitwiseExclusiveOrOperatorType"] = "BitwiseExclusiveOr";
+    ExtensionKind["BitwiseExclusiveOrOperatorMethodType"] = "BitwiseExclusiveOrMethod";
+    ExtensionKind["BitwiseLeftShiftOperatorType"] = "BitwiseLeftShift";
+    ExtensionKind["BitwiseLeftShiftOperatorMethodType"] = "BitwiseLeftShiftMethod";
+    ExtensionKind["BitwiseRightShiftOperatorType"] = "BitwiseRightShift";
+    ExtensionKind["BitwiseRightShiftOperatorMethodType"] = "BitwiseRightShiftMethod";
+    ExtensionKind["ConcatOperatorType"] = "Concat";
+    ExtensionKind["ConcatOperatorMethodType"] = "ConcatMethod";
+    ExtensionKind["LessThanOperatorType"] = "LessThan";
+    ExtensionKind["LessThanOperatorMethodType"] = "LessThanMethod";
+    ExtensionKind["GreaterThanOperatorType"] = "GreaterThan";
+    ExtensionKind["GreaterThanOperatorMethodType"] = "GreaterThanMethod";
+    ExtensionKind["NegationOperatorType"] = "Negation";
+    ExtensionKind["NegationOperatorMethodType"] = "NegationMethod";
+    ExtensionKind["BitwiseNotOperatorType"] = "BitwiseNot";
+    ExtensionKind["BitwiseNotOperatorMethodType"] = "BitwiseNotMethod";
+    ExtensionKind["LengthOperatorType"] = "Length";
+    ExtensionKind["LengthOperatorMethodType"] = "LengthMethod";
+    ExtensionKind["TableNewType"] = "TableNew";
+    ExtensionKind["TableDeleteType"] = "TableDelete";
+    ExtensionKind["TableDeleteMethodType"] = "TableDeleteMethod";
+    ExtensionKind["TableGetType"] = "TableGet";
+    ExtensionKind["TableGetMethodType"] = "TableGetMethod";
+    ExtensionKind["TableHasType"] = "TableHas";
+    ExtensionKind["TableHasMethodType"] = "TableHasMethod";
+    ExtensionKind["TableSetType"] = "TableSet";
+    ExtensionKind["TableSetMethodType"] = "TableSetMethod";
+    ExtensionKind["TableAddKeyType"] = "TableAddKey";
+    ExtensionKind["TableAddKeyMethodType"] = "TableAddKeyMethod";
 })(ExtensionKind = exports.ExtensionKind || (exports.ExtensionKind = {}));
-const extensionKindToValueName = {
-    [ExtensionKind.MultiFunction]: "$multi",
-    [ExtensionKind.RangeFunction]: "$range",
-    [ExtensionKind.VarargConstant]: "$vararg",
-};
-const extensionKindToTypeBrand = {
-    [ExtensionKind.MultiFunction]: "__luaMultiFunctionBrand",
-    [ExtensionKind.MultiType]: "__luaMultiReturnBrand",
-    [ExtensionKind.RangeFunction]: "__luaRangeFunctionBrand",
-    [ExtensionKind.VarargConstant]: "__luaVarargConstantBrand",
-    [ExtensionKind.IterableType]: "__luaIterableBrand",
-    [ExtensionKind.PairsIterableType]: "__luaPairsIterableBrand",
-    [ExtensionKind.AdditionOperatorType]: "__luaAdditionBrand",
-    [ExtensionKind.AdditionOperatorMethodType]: "__luaAdditionMethodBrand",
-    [ExtensionKind.SubtractionOperatorType]: "__luaSubtractionBrand",
-    [ExtensionKind.SubtractionOperatorMethodType]: "__luaSubtractionMethodBrand",
-    [ExtensionKind.MultiplicationOperatorType]: "__luaMultiplicationBrand",
-    [ExtensionKind.MultiplicationOperatorMethodType]: "__luaMultiplicationMethodBrand",
-    [ExtensionKind.DivisionOperatorType]: "__luaDivisionBrand",
-    [ExtensionKind.DivisionOperatorMethodType]: "__luaDivisionMethodBrand",
-    [ExtensionKind.ModuloOperatorType]: "__luaModuloBrand",
-    [ExtensionKind.ModuloOperatorMethodType]: "__luaModuloMethodBrand",
-    [ExtensionKind.PowerOperatorType]: "__luaPowerBrand",
-    [ExtensionKind.PowerOperatorMethodType]: "__luaPowerMethodBrand",
-    [ExtensionKind.FloorDivisionOperatorType]: "__luaFloorDivisionBrand",
-    [ExtensionKind.FloorDivisionOperatorMethodType]: "__luaFloorDivisionMethodBrand",
-    [ExtensionKind.BitwiseAndOperatorType]: "__luaBitwiseAndBrand",
-    [ExtensionKind.BitwiseAndOperatorMethodType]: "__luaBitwiseAndMethodBrand",
-    [ExtensionKind.BitwiseOrOperatorType]: "__luaBitwiseOrBrand",
-    [ExtensionKind.BitwiseOrOperatorMethodType]: "__luaBitwiseOrMethodBrand",
-    [ExtensionKind.BitwiseExclusiveOrOperatorType]: "__luaBitwiseExclusiveOrBrand",
-    [ExtensionKind.BitwiseExclusiveOrOperatorMethodType]: "__luaBitwiseExclusiveOrMethodBrand",
-    [ExtensionKind.BitwiseLeftShiftOperatorType]: "__luaBitwiseLeftShiftBrand",
-    [ExtensionKind.BitwiseLeftShiftOperatorMethodType]: "__luaBitwiseLeftShiftMethodBrand",
-    [ExtensionKind.BitwiseRightShiftOperatorType]: "__luaBitwiseRightShiftBrand",
-    [ExtensionKind.BitwiseRightShiftOperatorMethodType]: "__luaBitwiseRightShiftMethodBrand",
-    [ExtensionKind.ConcatOperatorType]: "__luaConcatBrand",
-    [ExtensionKind.ConcatOperatorMethodType]: "__luaConcatMethodBrand",
-    [ExtensionKind.LessThanOperatorType]: "__luaLessThanBrand",
-    [ExtensionKind.LessThanOperatorMethodType]: "__luaLessThanMethodBrand",
-    [ExtensionKind.GreaterThanOperatorType]: "__luaGreaterThanBrand",
-    [ExtensionKind.GreaterThanOperatorMethodType]: "__luaGreaterThanMethodBrand",
-    [ExtensionKind.NegationOperatorType]: "__luaNegationBrand",
-    [ExtensionKind.NegationOperatorMethodType]: "__luaNegationMethodBrand",
-    [ExtensionKind.BitwiseNotOperatorType]: "__luaBitwiseNotBrand",
-    [ExtensionKind.BitwiseNotOperatorMethodType]: "__luaBitwiseNotMethodBrand",
-    [ExtensionKind.LengthOperatorType]: "__luaLengthBrand",
-    [ExtensionKind.LengthOperatorMethodType]: "__luaLengthMethodBrand",
-    [ExtensionKind.TableNewType]: "__luaTableNewBrand",
-    [ExtensionKind.TableDeleteType]: "__luaTableDeleteBrand",
-    [ExtensionKind.TableDeleteMethodType]: "__luaTableDeleteMethodBrand",
-    [ExtensionKind.TableGetType]: "__luaTableGetBrand",
-    [ExtensionKind.TableGetMethodType]: "__luaTableGetMethodBrand",
-    [ExtensionKind.TableHasType]: "__luaTableHasBrand",
-    [ExtensionKind.TableHasMethodType]: "__luaTableHasMethodBrand",
-    [ExtensionKind.TableSetType]: "__luaTableSetBrand",
-    [ExtensionKind.TableSetMethodType]: "__luaTableSetMethodBrand",
-};
-function isExtensionType(type, extensionKind) {
-    const typeBrand = extensionKindToTypeBrand[extensionKind];
-    return typeBrand !== undefined && type.getProperty(typeBrand) !== undefined;
+const extensionValues = new Set(Object.values(ExtensionKind));
+function getExtensionKindForType(context, type) {
+    const value = getPropertyValue(context, type, "__tstlExtension");
+    if (value && extensionValues.has(value)) {
+        return value;
+    }
 }
-exports.isExtensionType = isExtensionType;
-function getExtensionKinds(type) {
-    return Object.keys(extensionKindToTypeBrand).filter(e => type.getProperty(extensionKindToTypeBrand[e]) !== undefined);
+exports.getExtensionKindForType = getExtensionKindForType;
+const excludedTypeFlags = ((1 << 18) - 1) | // All flags from Any...Never
+    ts.TypeFlags.Index |
+    ts.TypeFlags.NonPrimitive;
+function getPropertyValue(context, type, propertyName) {
+    if (type.flags & excludedTypeFlags)
+        return;
+    const property = type.getProperty(propertyName);
+    if (!property)
+        return undefined;
+    const propertyType = context.checker.getTypeOfSymbolAtLocation(property, context.sourceFile);
+    if (propertyType.isStringLiteral())
+        return propertyType.value;
 }
-exports.getExtensionKinds = getExtensionKinds;
-function isExtensionValue(context, symbol, extensionKind) {
-    var _a;
-    return (symbol.getName() === extensionKindToValueName[extensionKind] &&
-        ((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => isExtensionType(context.checker.getTypeAtLocation(d), extensionKind))) === true);
+function getExtensionKindForNode(context, node) {
+    const originalNode = ts.getOriginalNode(node);
+    let type = context.checker.getTypeAtLocation(originalNode);
+    if (ts.isOptionalChain(originalNode)) {
+        type = context.checker.getNonNullableType(type);
+    }
+    return getExtensionKindForType(context, type);
 }
-exports.isExtensionValue = isExtensionValue;
+exports.getExtensionKindForNode = getExtensionKindForNode;
+function getExtensionKindForSymbol(context, symbol) {
+    const type = context.checker.getTypeOfSymbolAtLocation(symbol, context.sourceFile);
+    return getExtensionKindForType(context, type);
+}
+exports.getExtensionKindForSymbol = getExtensionKindForSymbol;
+var IterableExtensionKind;
+(function (IterableExtensionKind) {
+    IterableExtensionKind["Iterable"] = "Iterable";
+    IterableExtensionKind["Pairs"] = "Pairs";
+    IterableExtensionKind["PairsKey"] = "PairsKey";
+})(IterableExtensionKind = exports.IterableExtensionKind || (exports.IterableExtensionKind = {}));
+function getIterableExtensionTypeForType(context, type) {
+    const value = getPropertyValue(context, type, "__tstlIterable");
+    if (value && value in IterableExtensionKind) {
+        return value;
+    }
+}
+exports.getIterableExtensionTypeForType = getIterableExtensionTypeForType;
+function getIterableExtensionKindForNode(context, node) {
+    const type = context.checker.getTypeAtLocation(node);
+    return getIterableExtensionTypeForType(context, type);
+}
+exports.getIterableExtensionKindForNode = getIterableExtensionKindForNode;
 //# sourceMappingURL=language-extensions.js.map

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

@@ -3,6 +3,5 @@ import * as lua from "../../LuaAST";
 import { LuaLibFeature } from "../../LuaLib";
 import { TransformationContext } from "../context";
 export { LuaLibFeature };
-export declare function getUsedLuaLibFeatures(context: TransformationContext): Set<LuaLibFeature>;
 export declare function importLuaLibFeature(context: TransformationContext, feature: LuaLibFeature): void;
 export declare function transformLuaLibFunction(context: TransformationContext, feature: LuaLibFeature, tsParent?: ts.Node, ...params: lua.Expression[]): lua.CallExpression;

package/dist/transformation/utils/lualib.js

@@ -1,17 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformLuaLibFunction = exports.importLuaLibFeature = exports.getUsedLuaLibFeatures = exports.LuaLibFeature = void 0;
+exports.transformLuaLibFunction = exports.importLuaLibFeature = exports.LuaLibFeature = void 0;
 const lua = require("../../LuaAST");
 const LuaLib_1 = require("../../LuaLib");
 Object.defineProperty(exports, "LuaLibFeature", { enumerable: true, get: function () { return LuaLib_1.LuaLibFeature; } });
-const utils_1 = require("../../utils");
-const luaLibFeatures = new WeakMap();
-function getUsedLuaLibFeatures(context) {
-    return (0, utils_1.getOrUpdate)(luaLibFeatures, context, () => new Set());
-}
-exports.getUsedLuaLibFeatures = getUsedLuaLibFeatures;
 function importLuaLibFeature(context, feature) {
-    getUsedLuaLibFeatures(context).add(feature);
+    context.usedLuaLibFeatures.add(feature);
 }
 exports.importLuaLibFeature = importLuaLibFeature;
 function transformLuaLibFunction(context, feature, tsParent, ...params) {

package/dist/transformation/utils/safe-names.d.ts

@@ -6,5 +6,5 @@ export declare const isValidLuaIdentifier: (name: string, options: CompilerOptio
 export declare const luaKeywords: ReadonlySet<string>;
 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 function hasUnsafeIdentifierName(context: TransformationContext, identifier: ts.Identifier, symbol: ts.Symbol | undefined): boolean;
 export declare const createSafeName: (name: string) => string;

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

@@ -80,12 +80,9 @@ function hasUnsafeSymbolName(context, symbol, tsOriginal) {
     return (0, exports.isUnsafeName)(symbol.name, context.options) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
 }
 exports.hasUnsafeSymbolName = hasUnsafeSymbolName;
-function hasUnsafeIdentifierName(context, identifier, checkSymbol = true) {
-    if (checkSymbol) {
-        const symbol = context.checker.getSymbolAtLocation(identifier);
-        if (symbol) {
-            return hasUnsafeSymbolName(context, symbol, identifier);
-        }
+function hasUnsafeIdentifierName(context, identifier, symbol) {
+    if (symbol) {
+        return hasUnsafeSymbolName(context, symbol, identifier);
     }
     return checkName(context, identifier.text, identifier);
 }

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

@@ -36,8 +36,6 @@ export declare function walkScopesUp(context: TransformationContext): IterableIt
 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;

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.addScopeVariableDeclaration = 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.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
@@ -18,12 +18,8 @@ var ScopeType;
     ScopeType[ScopeType["Catch"] = 128] = "Catch";
     ScopeType[ScopeType["LoopInitializer"] = 256] = "LoopInitializer";
 })(ScopeType = exports.ScopeType || (exports.ScopeType = {}));
-const scopeStacks = new WeakMap();
-function getScopeStack(context) {
-    return (0, utils_1.getOrUpdate)(scopeStacks, context, () => []);
-}
 function* walkScopesUp(context) {
-    const scopeStack = getScopeStack(context);
+    const scopeStack = context.scopeStack;
     for (let i = scopeStack.length - 1; i >= 0; --i) {
         const scope = scopeStack[i];
         yield scope;
@@ -31,7 +27,7 @@ function* walkScopesUp(context) {
 }
 exports.walkScopesUp = walkScopesUp;
 function markSymbolAsReferencedInCurrentScopes(context, symbolId, identifier) {
-    for (const scope of getScopeStack(context)) {
+    for (const scope of context.scopeStack) {
         if (!scope.referencedSymbols) {
             scope.referencedSymbols = new Map();
         }
@@ -41,34 +37,21 @@ function markSymbolAsReferencedInCurrentScopes(context, symbolId, identifier) {
 }
 exports.markSymbolAsReferencedInCurrentScopes = markSymbolAsReferencedInCurrentScopes;
 function peekScope(context) {
-    const scopeStack = getScopeStack(context);
+    const scopeStack = context.scopeStack;
     const scope = scopeStack[scopeStack.length - 1];
     (0, utils_1.assert)(scope);
     return scope;
 }
 exports.peekScope = peekScope;
 function findScope(context, scopeTypes) {
-    return [...getScopeStack(context)].reverse().find(s => scopeTypes & s.type);
+    for (let i = context.scopeStack.length - 1; i >= 0; --i) {
+        const scope = context.scopeStack[i];
+        if (scopeTypes & scope.type) {
+            return scope;
+        }
+    }
 }
 exports.findScope = findScope;
-const scopeIdCounters = new WeakMap();
-function pushScope(context, scopeType) {
-    var _a;
-    const nextScopeId = ((_a = scopeIdCounters.get(context)) !== null && _a !== void 0 ? _a : 0) + 1;
-    scopeIdCounters.set(context, nextScopeId);
-    const scopeStack = getScopeStack(context);
-    const scope = { type: scopeType, id: nextScopeId };
-    scopeStack.push(scope);
-    return scope;
-}
-exports.pushScope = pushScope;
-function popScope(context) {
-    const scopeStack = getScopeStack(context);
-    const scope = scopeStack.pop();
-    (0, utils_1.assert)(scope);
-    return scope;
-}
-exports.popScope = popScope;
 function addScopeVariableDeclaration(scope, declaration) {
     if (!scope.variableDeclarations) {
         scope.variableDeclarations = [];

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

@@ -8,4 +8,4 @@ export interface SymbolInfo {
 export declare function getSymbolInfo(context: TransformationContext, symbolId: lua.SymbolId): SymbolInfo | undefined;
 export declare function getSymbolIdOfSymbol(context: TransformationContext, symbol: ts.Symbol): lua.SymbolId | undefined;
 export declare function trackSymbolReference(context: TransformationContext, symbol: ts.Symbol, identifier: ts.Identifier): lua.SymbolId | undefined;
-export declare function getIdentifierSymbolId(context: TransformationContext, identifier: ts.Identifier): lua.SymbolId | undefined;
+export declare function getIdentifierSymbolId(context: TransformationContext, identifier: ts.Identifier, symbol: ts.Symbol | undefined): lua.SymbolId | undefined;

package/dist/transformation/utils/symbols.js

@@ -1,35 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIdentifierSymbolId = exports.trackSymbolReference = exports.getSymbolIdOfSymbol = exports.getSymbolInfo = void 0;
-const utils_1 = require("../../utils");
 const spread_1 = require("../visitors/spread");
 const scope_1 = require("./scope");
-const symbolIdCounters = new WeakMap();
-function nextSymbolId(context) {
-    var _a;
-    const symbolId = ((_a = symbolIdCounters.get(context)) !== null && _a !== void 0 ? _a : 0) + 1;
-    symbolIdCounters.set(context, symbolId);
-    return symbolId;
-}
-const symbolInfoMap = new WeakMap();
-const symbolIdMaps = new WeakMap();
 function getSymbolInfo(context, symbolId) {
-    return (0, utils_1.getOrUpdate)(symbolInfoMap, context, () => new Map()).get(symbolId);
+    return context.symbolInfoMap.get(symbolId);
 }
 exports.getSymbolInfo = getSymbolInfo;
 function getSymbolIdOfSymbol(context, symbol) {
-    return (0, utils_1.getOrUpdate)(symbolIdMaps, context, () => new Map()).get(symbol);
+    return context.symbolIdMaps.get(symbol);
 }
 exports.getSymbolIdOfSymbol = getSymbolIdOfSymbol;
 function trackSymbolReference(context, symbol, identifier) {
-    const symbolIds = (0, utils_1.getOrUpdate)(symbolIdMaps, context, () => new Map());
     // Track first time symbols are seen
-    let symbolId = symbolIds.get(symbol);
+    let symbolId = context.symbolIdMaps.get(symbol);
     if (symbolId === undefined) {
-        symbolId = nextSymbolId(context);
-        symbolIds.set(symbol, symbolId);
-        const symbolInfo = (0, utils_1.getOrUpdate)(symbolInfoMap, context, () => new Map());
-        symbolInfo.set(symbolId, { symbol, firstSeenAtPos: identifier.pos });
+        symbolId = context.nextSymbolId();
+        context.symbolIdMaps.set(symbol, symbolId);
+        context.symbolInfoMap.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.
@@ -39,8 +27,7 @@ function trackSymbolReference(context, symbol, identifier) {
     return symbolId;
 }
 exports.trackSymbolReference = trackSymbolReference;
-function getIdentifierSymbolId(context, identifier) {
-    const symbol = context.checker.getSymbolAtLocation(identifier);
+function getIdentifierSymbolId(context, identifier, symbol) {
     if (symbol) {
         return trackSymbolReference(context, symbol, identifier);
     }

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

@@ -9,6 +9,7 @@ export declare function hasExportEquals(sourceFile: ts.SourceFile): boolean;
 export declare function findFirstNodeAbove<T extends ts.Node>(node: ts.Node, callback: (n: ts.Node) => n is T): T | undefined;
 export declare function findFirstNonOuterParent(node: ts.Node): ts.Node;
 export declare function getFirstDeclarationInFile(symbol: ts.Symbol, sourceFile: ts.SourceFile): ts.Declaration | undefined;
+export declare function isStandardLibraryDeclaration(context: TransformationContext, declaration: ts.Declaration): boolean;
 export declare function isStandardLibraryType(context: TransformationContext, type: ts.Type, name: string | undefined): boolean;
 export declare function hasStandardLibrarySignature(context: TransformationContext, callExpression: ts.CallExpression): boolean;
 export declare function inferAssignedType(context: TransformationContext, expression: ts.Expression): ts.Type;

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

@@ -14,7 +14,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.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.getFirstDeclarationInFile = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
+exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.isStandardLibraryDeclaration = exports.getFirstDeclarationInFile = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
 const ts = require("typescript");
 __exportStar(require("./nodes"), exports);
 __exportStar(require("./types"), exports);
@@ -62,6 +62,7 @@ function isStandardLibraryDeclaration(context, declaration) {
     }
     return context.program.isSourceFileDefaultLibrary(sourceFile);
 }
+exports.isStandardLibraryDeclaration = isStandardLibraryDeclaration;
 function isStandardLibraryType(context, type, name) {
     const symbol = type.getSymbol();
     if (!symbol || (name ? symbol.name !== name : symbol.name === "__type")) {

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

@@ -1,12 +1,9 @@
 import * as ts from "typescript";
 import { TransformationContext } from "../../context";
-export declare function isTypeWithFlags(context: TransformationContext, type: ts.Type, flags: ts.TypeFlags): boolean;
-export declare function typeAlwaysSatisfies(context: TransformationContext, type: ts.Type, predicate: (type: ts.Type) => boolean): boolean;
-export declare function typeCanSatisfy(context: TransformationContext, type: ts.Type, predicate: (type: ts.Type) => boolean): boolean;
-export declare function isNullishType(context: TransformationContext, type: ts.Type): boolean;
+export declare function typeAlwaysHasSomeOfFlags(context: TransformationContext, type: ts.Type, flags: ts.TypeFlags): boolean;
+export declare function typeCanHaveSomeOfFlags(context: TransformationContext, type: ts.Type, flags: ts.TypeFlags): boolean;
 export declare function isStringType(context: TransformationContext, type: ts.Type): boolean;
 export declare function isNumberType(context: TransformationContext, type: ts.Type): boolean;
-export declare function isNullableType(context: TransformationContext, type: ts.Type, isType: (c: TransformationContext, t: ts.Type) => boolean): boolean;
 /**
  * Iterate over a type and its bases until the callback returns true.
  */

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

@@ -1,30 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNullableType = exports.isNumberType = exports.isStringType = exports.isNullishType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
+exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanHaveSomeOfFlags = exports.typeAlwaysHasSomeOfFlags = void 0;
 const ts = require("typescript");
-function isTypeWithFlags(context, type, flags) {
-    const predicate = (type) => (type.flags & flags) !== 0;
-    return typeAlwaysSatisfies(context, type, predicate);
-}
-exports.isTypeWithFlags = isTypeWithFlags;
-function typeAlwaysSatisfies(context, type, predicate) {
+function typeAlwaysHasSomeOfFlags(context, type, flags) {
     const baseConstraint = context.checker.getBaseConstraintOfType(type);
     if (baseConstraint) {
         type = baseConstraint;
     }
-    if (predicate(type)) {
+    if (type.flags & flags) {
         return true;
     }
     if (type.isUnion()) {
-        return type.types.every(t => typeAlwaysSatisfies(context, t, predicate));
+        return type.types.every(t => typeAlwaysHasSomeOfFlags(context, t, flags));
     }
     if (type.isIntersection()) {
-        return type.types.some(t => typeAlwaysSatisfies(context, t, predicate));
+        return type.types.some(t => typeAlwaysHasSomeOfFlags(context, t, flags));
     }
     return false;
 }
-exports.typeAlwaysSatisfies = typeAlwaysSatisfies;
-function typeCanSatisfy(context, type, predicate) {
+exports.typeAlwaysHasSomeOfFlags = typeAlwaysHasSomeOfFlags;
+function typeCanHaveSomeOfFlags(context, type, flags) {
     const baseConstraint = context.checker.getBaseConstraintOfType(type);
     if (!baseConstraint) {
         // type parameter with no constraint can be anything, assume it might satisfy predicate
@@ -34,36 +29,29 @@ function typeCanSatisfy(context, type, predicate) {
     else {
         type = baseConstraint;
     }
-    if (predicate(type)) {
+    if (type.flags & flags) {
         return true;
     }
     if (type.isUnion()) {
-        return type.types.some(t => typeCanSatisfy(context, t, predicate));
+        return type.types.some(t => typeCanHaveSomeOfFlags(context, t, flags));
     }
     if (type.isIntersection()) {
-        return type.types.some(t => typeCanSatisfy(context, t, predicate));
+        return type.types.some(t => typeCanHaveSomeOfFlags(context, t, flags));
     }
     return false;
 }
-exports.typeCanSatisfy = typeCanSatisfy;
-function isNullishType(context, type) {
-    return isTypeWithFlags(context, type, ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.VoidLike);
-}
-exports.isNullishType = isNullishType;
+exports.typeCanHaveSomeOfFlags = typeCanHaveSomeOfFlags;
 function isStringType(context, type) {
-    return isTypeWithFlags(context, type, ts.TypeFlags.String | ts.TypeFlags.StringLike | ts.TypeFlags.StringLiteral);
+    return typeAlwaysHasSomeOfFlags(context, type, ts.TypeFlags.StringLike);
 }
 exports.isStringType = isStringType;
 function isNumberType(context, type) {
-    return isTypeWithFlags(context, type, ts.TypeFlags.Number | ts.TypeFlags.NumberLike | ts.TypeFlags.NumberLiteral);
+    return typeAlwaysHasSomeOfFlags(context, type, ts.TypeFlags.NumberLike);
 }
 exports.isNumberType = isNumberType;
-function isNullableType(context, type, isType) {
-    return (typeCanSatisfy(context, type, t => isType(context, t)) &&
-        typeAlwaysSatisfies(context, type, t => isType(context, t) || isNullishType(context, t)));
-}
-exports.isNullableType = isNullableType;
 function isExplicitArrayType(context, type) {
+    if (context.checker.isArrayType(type) || context.checker.isTupleType(type))
+        return true;
     if (type.symbol) {
         const baseConstraint = context.checker.getBaseConstraintOfType(type);
         if (baseConstraint && baseConstraint !== type) {
@@ -73,25 +61,22 @@ function isExplicitArrayType(context, type) {
     if (type.isUnionOrIntersection()) {
         return type.types.some(t => isExplicitArrayType(context, t));
     }
-    const flags = ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.AllowEmptyTuple;
-    let typeNode = context.checker.typeToTypeNode(type, undefined, flags);
-    if (typeNode && ts.isTypeOperatorNode(typeNode) && typeNode.operator === ts.SyntaxKind.ReadonlyKeyword) {
-        typeNode = typeNode.type;
-    }
-    return typeNode !== undefined && (ts.isArrayTypeNode(typeNode) || ts.isTupleTypeNode(typeNode));
+    return false;
 }
 /**
  * Iterate over a type and its bases until the callback returns true.
  */
 function forTypeOrAnySupertype(context, type, predicate) {
-    var _a;
     if (predicate(type)) {
         return true;
     }
     if (!type.isClassOrInterface() && type.symbol) {
         type = context.checker.getDeclaredTypeOfSymbol(type.symbol);
     }
-    return ((_a = type.getBaseTypes()) !== null && _a !== void 0 ? _a : []).some(superType => forTypeOrAnySupertype(context, superType, predicate));
+    const baseTypes = type.getBaseTypes();
+    if (!baseTypes)
+        return false;
+    return baseTypes.some(superType => forTypeOrAnySupertype(context, superType, predicate));
 }
 exports.forTypeOrAnySupertype = forTypeOrAnySupertype;
 function isArrayType(context, type) {
@@ -104,6 +89,8 @@ function isFunctionType(type) {
 exports.isFunctionType = isFunctionType;
 function canBeFalsy(context, type) {
     const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
+    if (!strictNullChecks && !type.isLiteral())
+        return true;
     const falsyFlags = ts.TypeFlags.Boolean |
         ts.TypeFlags.BooleanLiteral |
         ts.TypeFlags.Never |
@@ -112,17 +99,20 @@ function canBeFalsy(context, type) {
         ts.TypeFlags.Any |
         ts.TypeFlags.Undefined |
         ts.TypeFlags.Null;
-    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0 || (!strictNullChecks && !type.isLiteral()));
+    return typeCanHaveSomeOfFlags(context, type, falsyFlags);
 }
 exports.canBeFalsy = canBeFalsy;
 function canBeFalsyWhenNotNull(context, type) {
+    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
+    if (!strictNullChecks && !type.isLiteral())
+        return true;
     const falsyFlags = ts.TypeFlags.Boolean |
         ts.TypeFlags.BooleanLiteral |
         ts.TypeFlags.Never |
         ts.TypeFlags.Void |
         ts.TypeFlags.Unknown |
         ts.TypeFlags.Any;
-    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0);
+    return typeCanHaveSomeOfFlags(context, type, falsyFlags);
 }
 exports.canBeFalsyWhenNotNull = canBeFalsyWhenNotNull;
 //# sourceMappingURL=types.js.map