typescript-to-lua 1.6.3 → 1.7.2

package/dist/transformation/utils/function-context.js

@@ -27,9 +27,22 @@ function hasNoSelfAncestor(declaration) {
     }
 }
 function getExplicitThisParameter(signatureDeclaration) {
-    return signatureDeclaration.parameters.find(param => ts.isIdentifier(param.name) && param.name.originalKeywordKind === ts.SyntaxKind.ThisKeyword);
+    const param = signatureDeclaration.parameters[0];
+    if (param && ts.isIdentifier(param.name) && param.name.originalKeywordKind === ts.SyntaxKind.ThisKeyword) {
+        return param;
+    }
+}
+const signatureDeclarationContextTypes = new WeakMap();
+function getDeclarationContextType(context, signatureDeclaration) {
+    const known = signatureDeclarationContextTypes.get(signatureDeclaration);
+    if (known !== undefined)
+        return known;
+    const contextType = computeDeclarationContextType(context, signatureDeclaration);
+    signatureDeclarationContextTypes.set(signatureDeclaration, contextType);
+    return contextType;
 }
-function getDeclarationContextType({ program }, signatureDeclaration) {
+exports.getDeclarationContextType = getDeclarationContextType;
+function computeDeclarationContextType(context, signatureDeclaration) {
     const thisParameter = getExplicitThisParameter(signatureDeclaration);
     if (thisParameter) {
         // Explicit 'this'
@@ -49,15 +62,13 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
         (signatureDeclaration.parent && ts.isPropertySignature(signatureDeclaration.parent))) {
         // Class/interface methods only respect @noSelf on their parent
         const scopeDeclaration = (0, typescript_1.findFirstNodeAbove)(signatureDeclaration, (n) => ts.isClassDeclaration(n) || ts.isClassExpression(n) || ts.isInterfaceDeclaration(n));
-        if (scopeDeclaration === undefined) {
-            return ContextType.NonVoid;
-        }
-        if ((0, annotations_1.getNodeAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+        if (scopeDeclaration !== undefined && (0, annotations_1.getNodeAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
             return ContextType.Void;
         }
         return ContextType.NonVoid;
     }
     // When using --noImplicitSelf and the signature is defined in a file targeted by the program apply the @noSelf rule.
+    const program = context.program;
     const options = program.getCompilerOptions();
     if (options.noImplicitSelf) {
         const sourceFile = program.getSourceFile(signatureDeclaration.getSourceFile().fileName);
@@ -73,61 +84,56 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
     }
     return ContextType.NonVoid;
 }
-exports.getDeclarationContextType = getDeclarationContextType;
 function reduceContextTypes(contexts) {
-    const reducer = (a, b) => {
-        if (a === ContextType.None) {
-            return b;
-        }
-        else if (b === ContextType.None) {
-            return a;
-        }
-        else if (a !== b) {
-            return ContextType.Mixed;
-        }
-        else {
-            return a;
-        }
-    };
-    return contexts.reduce(reducer, ContextType.None);
+    let type = ContextType.None;
+    for (const context of contexts) {
+        type |= context;
+        if (type === ContextType.Mixed)
+            break;
+    }
+    return type;
 }
-function getSignatureDeclarations(context, signatures) {
-    return signatures.flatMap(signature => {
-        const signatureDeclaration = signature.getDeclaration();
-        let inferredType;
-        if (ts.isMethodDeclaration(signatureDeclaration) &&
-            ts.isObjectLiteralExpression(signatureDeclaration.parent) &&
-            !getExplicitThisParameter(signatureDeclaration)) {
-            inferredType = context.checker.getContextualTypeForObjectLiteralElement(signatureDeclaration);
-        }
-        else if ((ts.isFunctionExpression(signatureDeclaration) || ts.isArrowFunction(signatureDeclaration)) &&
-            !getExplicitThisParameter(signatureDeclaration)) {
-            // Infer type of function expressions/arrow functions
-            inferredType = (0, typescript_1.inferAssignedType)(context, signatureDeclaration);
-        }
-        if (inferredType) {
-            const inferredSignatures = (0, typescript_1.getAllCallSignatures)(inferredType);
-            if (inferredSignatures.length > 0) {
-                return inferredSignatures.map(s => s.getDeclaration());
-            }
+function getSignatureDeclarations(context, signature) {
+    const signatureDeclaration = signature.getDeclaration();
+    let inferredType;
+    if (ts.isMethodDeclaration(signatureDeclaration) &&
+        ts.isObjectLiteralExpression(signatureDeclaration.parent) &&
+        !getExplicitThisParameter(signatureDeclaration)) {
+        inferredType = context.checker.getContextualTypeForObjectLiteralElement(signatureDeclaration);
+    }
+    else if ((ts.isFunctionExpression(signatureDeclaration) || ts.isArrowFunction(signatureDeclaration)) &&
+        !getExplicitThisParameter(signatureDeclaration)) {
+        // Infer type of function expressions/arrow functions
+        inferredType = (0, typescript_1.inferAssignedType)(context, signatureDeclaration);
+    }
+    if (inferredType) {
+        const inferredSignatures = (0, typescript_1.getAllCallSignatures)(inferredType);
+        if (inferredSignatures.length > 0) {
+            return inferredSignatures.map(s => s.getDeclaration());
         }
-        return signatureDeclaration;
-    });
+    }
+    return [signatureDeclaration];
 }
+const typeContextTypes = new WeakMap();
 function getFunctionContextType(context, type) {
-    var _a;
+    const known = typeContextTypes.get(type);
+    if (known !== undefined)
+        return known;
+    const contextType = computeFunctionContextType(context, type);
+    typeContextTypes.set(type, contextType);
+    return contextType;
+}
+exports.getFunctionContextType = getFunctionContextType;
+function computeFunctionContextType(context, type) {
     if (type.isTypeParameter()) {
-        type = (_a = type.getConstraint()) !== null && _a !== void 0 ? _a : type;
-    }
-    if (type.isUnion()) {
-        return reduceContextTypes(type.types.map(t => getFunctionContextType(context, t)));
+        const constraint = type.getConstraint();
+        if (constraint)
+            return getFunctionContextType(context, constraint);
     }
     const signatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Call);
     if (signatures.length === 0) {
         return ContextType.None;
     }
-    const signatureDeclarations = getSignatureDeclarations(context, signatures);
-    return reduceContextTypes(signatureDeclarations.map(s => getDeclarationContextType(context, s)));
+    return reduceContextTypes(signatures.flatMap(s => getSignatureDeclarations(context, s)).map(s => getDeclarationContextType(context, s)));
 }
-exports.getFunctionContextType = getFunctionContextType;
 //# sourceMappingURL=function-context.js.map

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

@@ -2,57 +2,63 @@ import * as ts from "typescript";
 import { TransformationContext } from "../context";
 export declare enum ExtensionKind {
     MultiFunction = "MultiFunction",
-    MultiType = "MultiType",
     RangeFunction = "RangeFunction",
     VarargConstant = "VarargConstant",
-    IterableType = "IterableType",
-    PairsIterableType = "PairsIterableType",
-    AdditionOperatorType = "AdditionOperatorType",
-    AdditionOperatorMethodType = "AdditionOperatorMethodType",
-    SubtractionOperatorType = "SubtractionOperatorType",
-    SubtractionOperatorMethodType = "SubtractionOperatorMethodType",
-    MultiplicationOperatorType = "MultiplicationOperatorType",
-    MultiplicationOperatorMethodType = "MultiplicationOperatorMethodType",
-    DivisionOperatorType = "DivisionOperatorType",
-    DivisionOperatorMethodType = "DivisionOperatorMethodType",
-    ModuloOperatorType = "ModuloOperatorType",
-    ModuloOperatorMethodType = "ModuloOperatorMethodType",
-    PowerOperatorType = "PowerOperatorType",
-    PowerOperatorMethodType = "PowerOperatorMethodType",
-    FloorDivisionOperatorType = "FloorDivisionOperatorType",
-    FloorDivisionOperatorMethodType = "FloorDivisionOperatorMethodType",
-    BitwiseAndOperatorType = "BitwiseAndOperatorType",
-    BitwiseAndOperatorMethodType = "BitwiseAndOperatorMethodType",
-    BitwiseOrOperatorType = "BitwiseOrOperatorType",
-    BitwiseOrOperatorMethodType = "BitwiseOrOperatorMethodType",
-    BitwiseExclusiveOrOperatorType = "BitwiseExclusiveOrOperatorType",
-    BitwiseExclusiveOrOperatorMethodType = "BitwiseExclusiveOrOperatorMethodType",
-    BitwiseLeftShiftOperatorType = "BitwiseLeftShiftOperatorType",
-    BitwiseLeftShiftOperatorMethodType = "BitwiseLeftShiftOperatorMethodType",
-    BitwiseRightShiftOperatorType = "BitwiseRightShiftOperatorType",
-    BitwiseRightShiftOperatorMethodType = "BitwiseRightShiftOperatorMethodType",
-    ConcatOperatorType = "ConcatOperatorType",
-    ConcatOperatorMethodType = "ConcatOperatorMethodType",
-    LessThanOperatorType = "LessThanOperatorType",
-    LessThanOperatorMethodType = "LessThanOperatorMethodType",
-    GreaterThanOperatorType = "GreaterThanOperatorType",
-    GreaterThanOperatorMethodType = "GreaterThanOperatorMethodType",
-    NegationOperatorType = "NegationOperatorType",
-    NegationOperatorMethodType = "NegationOperatorMethodType",
-    BitwiseNotOperatorType = "BitwiseNotOperatorType",
-    BitwiseNotOperatorMethodType = "BitwiseNotOperatorMethodType",
-    LengthOperatorType = "LengthOperatorType",
-    LengthOperatorMethodType = "LengthOperatorMethodType",
-    TableNewType = "TableNewType",
-    TableDeleteType = "TableDeleteType",
-    TableDeleteMethodType = "TableDeleteMethodType",
-    TableGetType = "TableGetType",
-    TableGetMethodType = "TableGetMethodType",
-    TableHasType = "TableHasType",
-    TableHasMethodType = "TableHasMethodType",
-    TableSetType = "TableSetType",
-    TableSetMethodType = "TableSetMethodType"
+    AdditionOperatorType = "Addition",
+    AdditionOperatorMethodType = "AdditionMethod",
+    SubtractionOperatorType = "Subtraction",
+    SubtractionOperatorMethodType = "SubtractionMethod",
+    MultiplicationOperatorType = "Multiplication",
+    MultiplicationOperatorMethodType = "MultiplicationMethod",
+    DivisionOperatorType = "Division",
+    DivisionOperatorMethodType = "DivisionMethod",
+    ModuloOperatorType = "Modulo",
+    ModuloOperatorMethodType = "ModuloMethod",
+    PowerOperatorType = "Power",
+    PowerOperatorMethodType = "PowerMethod",
+    FloorDivisionOperatorType = "FloorDivision",
+    FloorDivisionOperatorMethodType = "FloorDivisionMethod",
+    BitwiseAndOperatorType = "BitwiseAnd",
+    BitwiseAndOperatorMethodType = "BitwiseAndMethod",
+    BitwiseOrOperatorType = "BitwiseOr",
+    BitwiseOrOperatorMethodType = "BitwiseOrMethod",
+    BitwiseExclusiveOrOperatorType = "BitwiseExclusiveOr",
+    BitwiseExclusiveOrOperatorMethodType = "BitwiseExclusiveOrMethod",
+    BitwiseLeftShiftOperatorType = "BitwiseLeftShift",
+    BitwiseLeftShiftOperatorMethodType = "BitwiseLeftShiftMethod",
+    BitwiseRightShiftOperatorType = "BitwiseRightShift",
+    BitwiseRightShiftOperatorMethodType = "BitwiseRightShiftMethod",
+    ConcatOperatorType = "Concat",
+    ConcatOperatorMethodType = "ConcatMethod",
+    LessThanOperatorType = "LessThan",
+    LessThanOperatorMethodType = "LessThanMethod",
+    GreaterThanOperatorType = "GreaterThan",
+    GreaterThanOperatorMethodType = "GreaterThanMethod",
+    NegationOperatorType = "Negation",
+    NegationOperatorMethodType = "NegationMethod",
+    BitwiseNotOperatorType = "BitwiseNot",
+    BitwiseNotOperatorMethodType = "BitwiseNotMethod",
+    LengthOperatorType = "Length",
+    LengthOperatorMethodType = "LengthMethod",
+    TableNewType = "TableNew",
+    TableDeleteType = "TableDelete",
+    TableDeleteMethodType = "TableDeleteMethod",
+    TableGetType = "TableGet",
+    TableGetMethodType = "TableGetMethod",
+    TableHasType = "TableHas",
+    TableHasMethodType = "TableHasMethod",
+    TableSetType = "TableSet",
+    TableSetMethodType = "TableSetMethod",
+    TableAddKeyType = "TableAddKey",
+    TableAddKeyMethodType = "TableAddKeyMethod"
 }
-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;
+export declare function getExtensionKindForType(context: TransformationContext, type: ts.Type): ExtensionKind | undefined;
+export declare function getExtensionKindForNode(context: TransformationContext, node: ts.Node): ExtensionKind | undefined;
+export declare function getExtensionKindForSymbol(context: TransformationContext, symbol: ts.Symbol): ExtensionKind | undefined;
+export declare enum IterableExtensionKind {
+    Iterable = "Iterable",
+    Pairs = "Pairs",
+    PairsKey = "PairsKey"
+}
+export declare function getIterableExtensionTypeForType(context: TransformationContext, type: ts.Type): IterableExtensionKind | undefined;
+export declare function getIterableExtensionKindForNode(context: TransformationContext, node: ts.Node): IterableExtensionKind | undefined;

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;