typescript-to-lua 1.6.1 → 1.7.0

package/dist/transformation/utils/annotations.js

@@ -1,135 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTagArgsFromComment = exports.isForRangeType = exports.isVarargType = exports.isLuaIteratorType = exports.isTupleReturnCall = exports.getSignatureAnnotations = exports.getFileAnnotations = exports.getNodeAnnotations = exports.getTypeAnnotations = exports.getSymbolAnnotations = exports.AnnotationKind = void 0;
+exports.getFileAnnotations = exports.getNodeAnnotations = exports.getTypeAnnotations = exports.getSymbolAnnotations = exports.AnnotationKind = void 0;
 const ts = require("typescript");
 var AnnotationKind;
 (function (AnnotationKind) {
-    AnnotationKind["Extension"] = "extension";
-    AnnotationKind["MetaExtension"] = "metaExtension";
     AnnotationKind["CustomConstructor"] = "customConstructor";
     AnnotationKind["CompileMembersOnly"] = "compileMembersOnly";
     AnnotationKind["NoResolution"] = "noResolution";
-    AnnotationKind["PureAbstract"] = "pureAbstract";
-    AnnotationKind["Phantom"] = "phantom";
-    AnnotationKind["TupleReturn"] = "tupleReturn";
-    AnnotationKind["LuaIterator"] = "luaIterator";
-    AnnotationKind["LuaTable"] = "luaTable";
     AnnotationKind["NoSelf"] = "noSelf";
     AnnotationKind["NoSelfInFile"] = "noSelfInFile";
-    AnnotationKind["Vararg"] = "vararg";
-    AnnotationKind["ForRange"] = "forRange";
 })(AnnotationKind = exports.AnnotationKind || (exports.AnnotationKind = {}));
-function createAnnotation(name, args) {
-    const kind = Object.values(AnnotationKind).find(k => k.toLowerCase() === name.toLowerCase());
-    if (kind !== undefined) {
-        return { kind, args };
-    }
-}
+const annotationValues = new Map(Object.values(AnnotationKind).map(k => [k.toLowerCase(), k]));
 function collectAnnotations(source, annotationsMap) {
     var _a, _b;
     for (const tag of source.getJsDocTags()) {
-        const annotation = createAnnotation(tag.name, (_b = (_a = tag.text) === null || _a === void 0 ? void 0 : _a.map(p => p.text)) !== null && _b !== void 0 ? _b : []);
-        if (annotation) {
-            annotationsMap.set(annotation.kind, annotation);
-        }
+        const tagName = annotationValues.get(tag.name.toLowerCase());
+        if (!tagName)
+            continue;
+        const annotation = {
+            kind: tag.name,
+            args: (_b = (_a = tag.text) === null || _a === void 0 ? void 0 : _a.map(p => p.text)) !== null && _b !== void 0 ? _b : [],
+        };
+        annotationsMap.set(tagName, annotation);
     }
 }
+const symbolAnnotations = new WeakMap();
 function getSymbolAnnotations(symbol) {
+    const known = symbolAnnotations.get(symbol);
+    if (known)
+        return known;
     const annotationsMap = new Map();
     collectAnnotations(symbol, annotationsMap);
+    symbolAnnotations.set(symbol, annotationsMap);
     return annotationsMap;
 }
 exports.getSymbolAnnotations = getSymbolAnnotations;
 function getTypeAnnotations(type) {
+    // types are not frequently repeatedly polled for annotations, so it's not worth caching them
     const annotationsMap = new Map();
-    if (type.symbol)
-        collectAnnotations(type.symbol, annotationsMap);
-    if (type.aliasSymbol)
-        collectAnnotations(type.aliasSymbol, annotationsMap);
+    if (type.symbol) {
+        getSymbolAnnotations(type.symbol).forEach((value, key) => {
+            annotationsMap.set(key, value);
+        });
+    }
+    if (type.aliasSymbol) {
+        getSymbolAnnotations(type.aliasSymbol).forEach((value, key) => {
+            annotationsMap.set(key, value);
+        });
+    }
     return annotationsMap;
 }
 exports.getTypeAnnotations = getTypeAnnotations;
+const nodeAnnotations = new WeakMap();
 function getNodeAnnotations(node) {
+    const known = nodeAnnotations.get(node);
+    if (known)
+        return known;
     const annotationsMap = new Map();
-    for (const tag of ts.getJSDocTags(node)) {
-        const tagName = tag.tagName.text;
-        const annotation = createAnnotation(tagName, getTagArgsFromComment(tag));
-        if (annotation) {
-            annotationsMap.set(annotation.kind, annotation);
-        }
-    }
+    collectAnnotationsFromTags(annotationsMap, ts.getAllJSDocTags(node, ts.isJSDocUnknownTag));
+    nodeAnnotations.set(node, annotationsMap);
     return annotationsMap;
 }
 exports.getNodeAnnotations = getNodeAnnotations;
+function collectAnnotationsFromTags(annotationsMap, tags) {
+    for (const tag of tags) {
+        const tagName = annotationValues.get(tag.tagName.text.toLowerCase());
+        if (!tagName)
+            continue;
+        annotationsMap.set(tagName, { kind: tagName, args: getTagArgsFromComment(tag) });
+    }
+}
+const fileAnnotations = new WeakMap();
 function getFileAnnotations(sourceFile) {
+    const known = fileAnnotations.get(sourceFile);
+    if (known)
+        return known;
     const annotationsMap = new Map();
     if (sourceFile.statements.length > 0) {
         // Manually collect jsDoc because `getJSDocTags` includes tags only from closest comment
         const jsDoc = sourceFile.statements[0].jsDoc;
         if (jsDoc) {
-            for (const tag of jsDoc.flatMap(x => { var _a; return (_a = x.tags) !== null && _a !== void 0 ? _a : []; })) {
-                const tagName = tag.tagName.text;
-                const annotation = createAnnotation(tagName, getTagArgsFromComment(tag));
-                if (annotation) {
-                    annotationsMap.set(annotation.kind, annotation);
+            for (const jsDocElement of jsDoc) {
+                if (jsDocElement.tags) {
+                    collectAnnotationsFromTags(annotationsMap, jsDocElement.tags);
                 }
             }
         }
     }
+    fileAnnotations.set(sourceFile, annotationsMap);
     return annotationsMap;
 }
 exports.getFileAnnotations = getFileAnnotations;
-function getSignatureAnnotations(context, signature) {
-    const annotationsMap = new Map();
-    collectAnnotations(signature, annotationsMap);
-    // Function properties on interfaces have the JSDoc tags on the parent PropertySignature
-    const declaration = signature.getDeclaration();
-    if ((declaration === null || declaration === void 0 ? void 0 : declaration.parent) && ts.isPropertySignature(declaration.parent)) {
-        const symbol = context.checker.getSymbolAtLocation(declaration.parent.name);
-        if (symbol) {
-            collectAnnotations(symbol, annotationsMap);
-        }
-    }
-    return annotationsMap;
-}
-exports.getSignatureAnnotations = getSignatureAnnotations;
-function isTupleReturnCall(context, node) {
-    if (!ts.isCallExpression(node)) {
-        return false;
-    }
-    const signature = context.checker.getResolvedSignature(node);
-    if (signature) {
-        if (getSignatureAnnotations(context, signature).has(AnnotationKind.TupleReturn)) {
-            return true;
-        }
-        // Only check function type for directive if it is declared as an interface or type alias
-        const declaration = signature.getDeclaration();
-        const isInterfaceOrAlias = (declaration === null || declaration === void 0 ? void 0 : declaration.parent) &&
-            ((ts.isInterfaceDeclaration(declaration.parent) && ts.isCallSignatureDeclaration(declaration)) ||
-                ts.isTypeAliasDeclaration(declaration.parent));
-        if (!isInterfaceOrAlias) {
-            return false;
-        }
-    }
-    const type = context.checker.getTypeAtLocation(node.expression);
-    return getTypeAnnotations(type).has(AnnotationKind.TupleReturn);
-}
-exports.isTupleReturnCall = isTupleReturnCall;
-function isLuaIteratorType(context, node) {
-    const type = context.checker.getTypeAtLocation(node);
-    return getTypeAnnotations(type).has(AnnotationKind.LuaIterator);
-}
-exports.isLuaIteratorType = isLuaIteratorType;
-function isVarargType(context, node) {
-    const type = context.checker.getTypeAtLocation(node);
-    return getTypeAnnotations(type).has(AnnotationKind.Vararg);
-}
-exports.isVarargType = isVarargType;
-function isForRangeType(context, node) {
-    const type = context.checker.getTypeAtLocation(node);
-    return getTypeAnnotations(type).has(AnnotationKind.ForRange);
-}
-exports.isForRangeType = isForRangeType;
 function getTagArgsFromComment(tag) {
     if (tag.comment) {
         if (typeof tag.comment === "string") {
@@ -141,5 +102,4 @@ function getTagArgsFromComment(tag) {
     }
     return [];
 }
-exports.getTagArgsFromComment = getTagArgsFromComment;
 //# sourceMappingURL=annotations.js.map

package/dist/transformation/utils/assignment-validation.js

@@ -8,6 +8,7 @@ const function_context_1 = require("./function-context");
 // TODO: Clear if types are reused between compilations
 const typeValidationCache = new WeakMap();
 function validateAssignment(context, node, fromType, toType, toName) {
+    var _a, _b;
     if (toType === fromType) {
         return;
     }
@@ -21,13 +22,9 @@ function validateAssignment(context, node, fromType, toType, toName) {
         return;
     fromTypeCache.add(toType);
     validateFunctionAssignment(context, node, fromType, toType, toName);
-    const fromTypeNode = context.checker.typeToTypeNode(fromType, undefined, undefined);
-    const toTypeNode = context.checker.typeToTypeNode(toType, undefined, undefined);
-    if (!fromTypeNode || !toTypeNode) {
-        return;
-    }
-    if ((ts.isArrayTypeNode(toTypeNode) || ts.isTupleTypeNode(toTypeNode)) &&
-        (ts.isArrayTypeNode(fromTypeNode) || ts.isTupleTypeNode(fromTypeNode))) {
+    const checker = context.checker;
+    if ((checker.isTupleType(toType) || checker.isArrayType(toType)) &&
+        (checker.isTupleType(fromType) || checker.isArrayType(fromType))) {
         // Recurse into arrays/tuples
         const fromTypeArguments = fromType.typeArguments;
         const toTypeArguments = toType.typeArguments;
@@ -39,25 +36,32 @@ function validateAssignment(context, node, fromType, toType, toName) {
             validateAssignment(context, node, fromTypeArguments[i], toTypeArguments[i], toName);
         }
     }
-    if ((toType.flags & ts.TypeFlags.Object) !== 0 &&
-        (ts.isTypeLiteralNode(toTypeNode) ||
-            (toType.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0) &&
-        toType.symbol &&
-        toType.symbol.members &&
-        fromType.symbol &&
-        fromType.symbol.members) {
+    const fromMembers = (_a = fromType.symbol) === null || _a === void 0 ? void 0 : _a.members;
+    const toMembers = (_b = toType.symbol) === null || _b === void 0 ? void 0 : _b.members;
+    if (fromMembers && toMembers) {
         // Recurse into interfaces
-        toType.symbol.members.forEach((toMember, escapedMemberName) => {
-            if (fromType.symbol.members) {
-                const fromMember = fromType.symbol.members.get(escapedMemberName);
+        if (toMembers.size < fromMembers.size) {
+            toMembers.forEach((toMember, escapedMemberName) => {
+                const fromMember = fromMembers.get(escapedMemberName);
                 if (fromMember) {
-                    const toMemberType = context.checker.getTypeOfSymbolAtLocation(toMember, node);
-                    const fromMemberType = context.checker.getTypeOfSymbolAtLocation(fromMember, node);
-                    const memberName = ts.unescapeLeadingUnderscores(escapedMemberName);
-                    validateAssignment(context, node, fromMemberType, toMemberType, toName ? `${toName}.${memberName}` : memberName);
+                    validateMember(toMember, fromMember, escapedMemberName);
+                }
+            });
+        }
+        else {
+            fromMembers.forEach((fromMember, escapedMemberName) => {
+                const toMember = toMembers.get(escapedMemberName);
+                if (toMember) {
+                    validateMember(toMember, fromMember, escapedMemberName);
                 }
-            }
-        });
+            });
+        }
+    }
+    function validateMember(toMember, fromMember, escapedMemberName) {
+        const toMemberType = context.checker.getTypeOfSymbolAtLocation(toMember, node);
+        const fromMemberType = context.checker.getTypeOfSymbolAtLocation(fromMember, node);
+        const memberName = ts.unescapeLeadingUnderscores(escapedMemberName);
+        validateAssignment(context, node, fromMemberType, toMemberType, toName ? `${toName}.${memberName}` : memberName);
     }
 }
 exports.validateAssignment = validateAssignment;

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

@@ -74,10 +74,7 @@ export declare const invalidMultiTypeToEmptyPatternOrArrayLiteral: ((node: ts.No
 export declare const invalidMultiReturnAccess: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
-export declare const invalidOperatorMappingUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
-    code: number;
-};
-export declare const invalidTableExtensionUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+export declare const invalidCallExtensionUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
 export declare const annotationRemoved: ((node: ts.Node, kind: AnnotationKind) => ts.Diagnostic) & {

package/dist/transformation/utils/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.undefinedInArrayLiteral = exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableExtensionUse = exports.invalidOperatorMappingUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTargetButOverrideAvailable = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidPairsIterableWithoutDestructuring = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
+exports.undefinedInArrayLiteral = exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidCallExtensionUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTargetButOverrideAvailable = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidPairsIterableWithoutDestructuring = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const utils_1 = require("../../utils");
@@ -52,8 +52,7 @@ exports.invalidMultiFunctionReturnType = createErrorDiagnosticFactory("The $mult
 exports.invalidMultiTypeToNonArrayLiteral = createErrorDiagnosticFactory("Expected an array literal.");
 exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = createErrorDiagnosticFactory("There must be one or more elements specified here.");
 exports.invalidMultiReturnAccess = createErrorDiagnosticFactory("The LuaMultiReturn type can only be accessed via an element access expression of a numeric type.");
-exports.invalidOperatorMappingUse = createErrorDiagnosticFactory("This function must always be directly called and cannot be referred to.");
-exports.invalidTableExtensionUse = createErrorDiagnosticFactory("This function must be called directly and cannot be referred to.");
+exports.invalidCallExtensionUse = createErrorDiagnosticFactory("This function must be called directly and cannot be referred to.");
 exports.annotationRemoved = createErrorDiagnosticFactory((kind) => `'@${kind}' has been removed and will no longer have any effect.` +
     `See https://typescripttolua.github.io/docs/advanced/compiler-annotations#${kind.toLowerCase()} for more information.`);
 exports.annotationDeprecated = createWarningDiagnosticFactory((kind) => `'@${kind}' is deprecated and will be removed in a future update. Please update your code before upgrading to the next release, otherwise your project will no longer compile. ` +

package/dist/transformation/utils/function-context.d.ts

@@ -6,5 +6,5 @@ export declare enum ContextType {
     NonVoid = 2,
     Mixed = 3
 }
-export declare function getDeclarationContextType({ program }: TransformationContext, signatureDeclaration: ts.SignatureDeclaration): ContextType;
+export declare function getDeclarationContextType(context: TransformationContext, signatureDeclaration: ts.SignatureDeclaration): ContextType;
 export declare function getFunctionContextType(context: TransformationContext, type: ts.Type): ContextType;

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;