typescript-to-lua 1.6.3 → 1.7.0

package/dist/transformation/visitors/conditional.js

@@ -34,10 +34,10 @@ const transformConditionalExpression = (expression, context) => {
 };
 exports.transformConditionalExpression = transformConditionalExpression;
 function transformIfStatement(statement, context) {
-    (0, scope_1.pushScope)(context, scope_1.ScopeType.Conditional);
+    context.pushScope(scope_1.ScopeType.Conditional);
     const condition = context.transformExpression(statement.expression);
     const statements = (0, scope_1.performHoisting)(context, (0, block_1.transformBlockOrStatement)(context, statement.thenStatement));
-    (0, scope_1.popScope)(context);
+    context.popScope();
     const ifBlock = lua.createBlock(statements);
     if (statement.elseStatement) {
         if (ts.isIfStatement(statement.elseStatement)) {
@@ -60,9 +60,9 @@ function transformIfStatement(statement, context) {
             }
         }
         else {
-            (0, scope_1.pushScope)(context, scope_1.ScopeType.Conditional);
+            context.pushScope(scope_1.ScopeType.Conditional);
             const elseStatements = (0, scope_1.performHoisting)(context, (0, block_1.transformBlockOrStatement)(context, statement.elseStatement));
-            (0, scope_1.popScope)(context);
+            context.popScope();
             const elseBlock = lua.createBlock(elseStatements);
             return lua.createIfStatement(condition, ifBlock, elseBlock);
         }

package/dist/transformation/visitors/function.d.ts

@@ -3,7 +3,7 @@ import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 import { Scope } from "../utils/scope";
 export declare function createCallableTable(functionExpression: lua.Expression): lua.Expression;
-export declare function isFunctionTypeWithProperties(functionType: ts.Type): boolean;
+export declare function isFunctionTypeWithProperties(context: TransformationContext, functionType: ts.Type): boolean;
 export declare function transformFunctionBodyContent(context: TransformationContext, body: ts.ConciseBody): lua.Statement[];
 export declare function transformFunctionBodyHeader(context: TransformationContext, bodyScope: Scope, parameters: ts.NodeArray<ts.ParameterDeclaration>, spreadIdentifier?: lua.Identifier): lua.Statement[];
 export declare function transformFunctionBody(context: TransformationContext, parameters: ts.NodeArray<ts.ParameterDeclaration>, body: ts.ConciseBody, spreadIdentifier?: lua.Identifier, node?: ts.FunctionLikeDeclaration): [lua.Statement[], Scope];

package/dist/transformation/visitors/function.js

@@ -4,8 +4,6 @@ exports.transformYieldExpression = exports.transformFunctionDeclaration = export
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
-const annotations_1 = require("../utils/annotations");
-const diagnostics_1 = require("../utils/diagnostics");
 const export_1 = require("../utils/export");
 const function_context_1 = require("../utils/function-context");
 const language_extensions_1 = require("../utils/language-extensions");
@@ -56,14 +54,14 @@ function createCallableTable(functionExpression) {
     ]);
 }
 exports.createCallableTable = createCallableTable;
-function isFunctionTypeWithProperties(functionType) {
+function isFunctionTypeWithProperties(context, functionType) {
     if (functionType.isUnion()) {
-        return functionType.types.some(isFunctionTypeWithProperties);
+        return functionType.types.some(t => isFunctionTypeWithProperties(context, t));
     }
     else {
         return ((0, typescript_1.isFunctionType)(functionType) &&
             functionType.getProperties().length > 0 &&
-            (0, language_extensions_1.getExtensionKinds)(functionType).length === 0 // ignore TSTL extension functions like $range
+            (0, language_extensions_1.getExtensionKindForType)(context, functionType) === undefined // ignore TSTL extension functions like $range
         );
     }
 }
@@ -110,14 +108,14 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
 }
 exports.transformFunctionBodyHeader = transformFunctionBodyHeader;
 function transformFunctionBody(context, parameters, body, spreadIdentifier, node) {
-    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
+    const scope = context.pushScope(scope_1.ScopeType.Function);
     scope.node = node;
     let bodyStatements = transformFunctionBodyContent(context, body);
     if (node && (0, async_await_1.isAsyncFunction)(node)) {
         bodyStatements = [lua.createReturnStatement([(0, async_await_1.wrapInAsyncAwaiter)(context, bodyStatements)])];
     }
     const headerStatements = transformFunctionBodyHeader(context, scope, parameters, spreadIdentifier);
-    (0, scope_1.popScope)(context);
+    context.popScope();
     return [[...headerStatements, ...bodyStatements], scope];
 }
 exports.transformFunctionBody = transformFunctionBody;
@@ -191,9 +189,6 @@ function transformFunctionLikeDeclaration(node, context) {
         // This code can be reached only from object methods, which is TypeScript error
         return lua.createNilLiteral();
     }
-    if ((0, annotations_1.getNodeAnnotations)(node).has(annotations_1.AnnotationKind.TupleReturn)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
-    }
     const [functionExpression, functionScope] = transformFunctionToExpression(context, node);
     const isNamedFunctionExpression = ts.isFunctionExpression(node) && node.name;
     // Handle named function expressions which reference themselves
@@ -205,7 +200,7 @@ function transformFunctionLikeDeclaration(node, context) {
             // Only handle if the name is actually referenced inside the function
             if (isReferenced) {
                 const nameIdentifier = (0, identifier_1.transformIdentifier)(context, node.name);
-                if (isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))) {
+                if (isFunctionTypeWithProperties(context, context.checker.getTypeAtLocation(node))) {
                     context.addPrecedingStatements([
                         lua.createVariableDeclarationStatement(nameIdentifier),
                         lua.createAssignmentStatement(nameIdentifier, createCallableTable(functionExpression)),
@@ -218,16 +213,13 @@ function transformFunctionLikeDeclaration(node, context) {
             }
         }
     }
-    return isNamedFunctionExpression && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))
+    return isNamedFunctionExpression && isFunctionTypeWithProperties(context, context.checker.getTypeAtLocation(node))
         ? createCallableTable(functionExpression)
         : functionExpression;
 }
 exports.transformFunctionLikeDeclaration = transformFunctionLikeDeclaration;
 const transformFunctionDeclaration = (node, context) => {
     var _a;
-    if ((0, annotations_1.getNodeAnnotations)(node).has(annotations_1.AnnotationKind.TupleReturn)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
-    }
     // Don't transform functions without body (overload declarations)
     if (node.body === undefined) {
         return undefined;
@@ -248,7 +240,7 @@ const transformFunctionDeclaration = (node, context) => {
         scope.functionDefinitions.set(name.symbolId, functionInfo);
     }
     // Wrap functions with properties into a callable table
-    const wrappedFunction = node.name && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node.name))
+    const wrappedFunction = node.name && isFunctionTypeWithProperties(context, context.checker.getTypeAtLocation(node.name))
         ? createCallableTable(functionExpression)
         : functionExpression;
     return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, name, wrappedFunction, node);

package/dist/transformation/visitors/identifier.d.ts

@@ -2,4 +2,5 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 export declare function transformIdentifier(context: TransformationContext, identifier: ts.Identifier): lua.Identifier;
+export declare function transformIdentifierWithSymbol(context: TransformationContext, node: ts.Identifier, symbol: ts.Symbol | undefined): lua.Expression;
 export declare const transformIdentifierExpression: FunctionVisitor<ts.Identifier>;

package/dist/transformation/visitors/identifier.js

@@ -1,82 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformIdentifierExpression = exports.transformIdentifier = void 0;
+exports.transformIdentifierExpression = exports.transformIdentifierWithSymbol = exports.transformIdentifier = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
 const promise_1 = require("../builtins/promise");
 const context_1 = require("../context");
-const annotations_1 = require("../utils/annotations");
 const diagnostics_1 = require("../utils/diagnostics");
 const export_1 = require("../utils/export");
-const lualib_1 = require("../utils/lualib");
 const safe_names_1 = require("../utils/safe-names");
 const symbols_1 = require("../utils/symbols");
-const multi_1 = require("./language-extensions/multi");
-const operators_1 = require("./language-extensions/operators");
-const range_1 = require("./language-extensions/range");
-const table_1 = require("./language-extensions/table");
-const vararg_1 = require("./language-extensions/vararg");
 const optional_chaining_1 = require("./optional-chaining");
 const typescript_1 = require("../utils/typescript");
+const language_extensions_1 = require("../utils/language-extensions");
+const call_extension_1 = require("./language-extensions/call-extension");
+const identifier_1 = require("./language-extensions/identifier");
 function transformIdentifier(context, identifier) {
+    return transformNonValueIdentifier(context, identifier, context.checker.getSymbolAtLocation(identifier));
+}
+exports.transformIdentifier = transformIdentifier;
+function transformNonValueIdentifier(context, identifier, symbol) {
     if ((0, optional_chaining_1.isOptionalContinuation)(identifier)) {
         return lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
     }
-    if ((0, multi_1.isMultiFunctionNode)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(identifier));
-        return lua.createAnonymousIdentifier(identifier);
-    }
-    if ((0, operators_1.isOperatorMapping)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidOperatorMappingUse)(identifier));
-    }
-    if ((0, table_1.isTableExtensionIdentifier)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidTableExtensionUse)(identifier));
-    }
-    if ((0, range_1.isRangeFunctionNode)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidRangeUse)(identifier));
-        return lua.createAnonymousIdentifier(identifier);
-    }
-    if ((0, vararg_1.isVarargConstantNode)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.invalidVarargUse)(identifier));
-        return lua.createAnonymousIdentifier(identifier);
-    }
-    if ((0, annotations_1.isForRangeType)(context, identifier)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(identifier, annotations_1.AnnotationKind.ForRange));
-    }
-    if ((0, promise_1.isPromiseClass)(context, identifier)) {
-        (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
-        return (0, promise_1.createPromiseIdentifier)(identifier);
+    const extensionKind = symbol
+        ? (0, language_extensions_1.getExtensionKindForSymbol)(context, symbol)
+        : (0, language_extensions_1.getExtensionKindForNode)(context, identifier);
+    if (extensionKind) {
+        if (call_extension_1.callExtensions.has(extensionKind)) {
+            context.diagnostics.push((0, diagnostics_1.invalidCallExtensionUse)(identifier));
+            // fall through
+        }
+        else if ((0, identifier_1.isIdentifierExtensionValue)(symbol, extensionKind)) {
+            (0, identifier_1.reportInvalidExtensionValue)(context, identifier, extensionKind);
+            return lua.createAnonymousIdentifier(identifier);
+        }
     }
     const type = context.checker.getTypeAtLocation(identifier);
     if ((0, typescript_1.isStandardLibraryType)(context, type, undefined)) {
         (0, builtins_1.checkForLuaLibType)(context, type);
+        if ((0, promise_1.isPromiseClass)(context, identifier)) {
+            return (0, promise_1.createPromiseIdentifier)(identifier);
+        }
     }
-    const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, identifier) ? (0, safe_names_1.createSafeName)(identifier.text) : identifier.text;
-    const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, identifier);
+    const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, identifier, symbol)
+        ? (0, safe_names_1.createSafeName)(identifier.text)
+        : identifier.text;
+    const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, identifier, symbol);
     return lua.createIdentifier(text, identifier, symbolId, identifier.text);
 }
-exports.transformIdentifier = transformIdentifier;
-const transformIdentifierExpression = (node, context) => {
-    const symbol = context.checker.getSymbolAtLocation(node);
+function transformIdentifierWithSymbol(context, node, symbol) {
     if (symbol) {
         const exportScope = (0, export_1.getSymbolExportScope)(context, symbol);
         if (exportScope) {
             const name = symbol.name;
-            const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, node) ? (0, safe_names_1.createSafeName)(name) : name;
-            const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, node);
+            const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, node, symbol) ? (0, safe_names_1.createSafeName)(name) : name;
+            const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, node, symbol);
             const identifier = lua.createIdentifier(text, node, symbolId, name);
             return (0, export_1.createExportedIdentifier)(context, identifier, exportScope);
         }
     }
-    if (node.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
-        return lua.createNilLiteral();
-    }
-    const builtinResult = (0, builtins_1.transformBuiltinIdentifierExpression)(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinIdentifierExpression)(context, node, symbol);
     if (builtinResult) {
         return builtinResult;
     }
-    return transformIdentifier(context, node);
+    return transformNonValueIdentifier(context, node, symbol);
+}
+exports.transformIdentifierWithSymbol = transformIdentifierWithSymbol;
+const transformIdentifierExpression = (node, context) => {
+    if (node.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
+        return lua.createNilLiteral(node);
+    }
+    const symbol = context.checker.getSymbolAtLocation(node);
+    return transformIdentifierWithSymbol(context, node, symbol);
 };
 exports.transformIdentifierExpression = transformIdentifierExpression;
 //# sourceMappingURL=identifier.js.map

package/dist/transformation/visitors/language-extensions/call-extension.d.ts

@@ -0,0 +1,10 @@
+import { TransformationContext } from "../../context";
+import * as ts from "typescript";
+import { ExtensionKind } from "../../utils/language-extensions";
+import * as lua from "../../../LuaAST";
+export declare const callExtensions: Set<ExtensionKind>;
+export declare type LanguageExtensionCallTransformer = (context: TransformationContext, node: ts.CallExpression, extensionKind: ExtensionKind) => lua.Expression;
+export declare type LanguageExtensionCallTransformerMap = {
+    [P in ExtensionKind]?: LanguageExtensionCallTransformer;
+};
+export declare function transformLanguageExtensionCallExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression | undefined;

package/dist/transformation/visitors/language-extensions/call-extension.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLanguageExtensionCallExpression = exports.callExtensions = void 0;
+const language_extensions_1 = require("../../utils/language-extensions");
+const operators_1 = require("./operators");
+const table_1 = require("./table");
+const allCallExtensionHandlers = {
+    ...operators_1.operatorExtensionTransformers,
+    ...table_1.tableExtensionTransformers,
+};
+exports.callExtensions = new Set(Object.keys(allCallExtensionHandlers));
+table_1.tableNewExtensions.forEach(kind => exports.callExtensions.add(kind));
+function transformLanguageExtensionCallExpression(context, node) {
+    const extensionKind = (0, language_extensions_1.getExtensionKindForNode)(context, node.expression);
+    if (!extensionKind)
+        return;
+    const transformer = allCallExtensionHandlers[extensionKind];
+    if (transformer) {
+        return transformer(context, node, extensionKind);
+    }
+}
+exports.transformLanguageExtensionCallExpression = transformLanguageExtensionCallExpression;
+//# sourceMappingURL=call-extension.js.map

package/dist/transformation/visitors/language-extensions/identifier.d.ts

@@ -0,0 +1,5 @@
+import * as ts from "typescript";
+import { ExtensionKind } from "../../utils/language-extensions";
+import { TransformationContext } from "../../context";
+export declare function isIdentifierExtensionValue(symbol: ts.Symbol | undefined, extensionKind: ExtensionKind): boolean;
+export declare function reportInvalidExtensionValue(context: TransformationContext, identifier: ts.Identifier, extensionKind: ExtensionKind): void;

package/dist/transformation/visitors/language-extensions/identifier.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportInvalidExtensionValue = exports.isIdentifierExtensionValue = void 0;
+const language_extensions_1 = require("../../utils/language-extensions");
+const diagnostics_1 = require("../../utils/diagnostics");
+const extensionKindToValueName = {
+    [language_extensions_1.ExtensionKind.MultiFunction]: "$multi",
+    [language_extensions_1.ExtensionKind.RangeFunction]: "$range",
+    [language_extensions_1.ExtensionKind.VarargConstant]: "$vararg",
+};
+function isIdentifierExtensionValue(symbol, extensionKind) {
+    return symbol !== undefined && extensionKindToValueName[extensionKind] === symbol.name;
+}
+exports.isIdentifierExtensionValue = isIdentifierExtensionValue;
+function reportInvalidExtensionValue(context, identifier, extensionKind) {
+    if (extensionKind === language_extensions_1.ExtensionKind.MultiFunction) {
+        context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(identifier));
+    }
+    else if (extensionKind === language_extensions_1.ExtensionKind.RangeFunction) {
+        context.diagnostics.push((0, diagnostics_1.invalidRangeUse)(identifier));
+    }
+    else if (extensionKind === language_extensions_1.ExtensionKind.VarargConstant) {
+        context.diagnostics.push((0, diagnostics_1.invalidVarargUse)(identifier));
+    }
+}
+exports.reportInvalidExtensionValue = reportInvalidExtensionValue;
+//# sourceMappingURL=identifier.js.map

package/dist/transformation/visitors/language-extensions/iterable.d.ts

@@ -1,7 +1,6 @@
 import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
-export declare function isIterableType(type: ts.Type): boolean;
-export declare function returnsIterableType(context: TransformationContext, node: ts.CallExpression): boolean;
-export declare function isIterableExpression(context: TransformationContext, expression: ts.Expression): boolean;
 export declare function transformForOfIterableStatement(context: TransformationContext, statement: ts.ForOfStatement, block: lua.Block): lua.Statement;
+export declare function transformForOfPairsIterableStatement(context: TransformationContext, statement: ts.ForOfStatement, block: lua.Block): lua.Statement;
+export declare function transformForOfPairsKeyIterableStatement(context: TransformationContext, statement: ts.ForOfStatement, block: lua.Block): lua.Statement;

package/dist/transformation/visitors/language-extensions/iterable.js

@@ -1,31 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformForOfIterableStatement = exports.isIterableExpression = exports.returnsIterableType = exports.isIterableType = void 0;
+exports.transformForOfPairsKeyIterableStatement = exports.transformForOfPairsIterableStatement = exports.transformForOfIterableStatement = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
-const extensions = require("../../utils/language-extensions");
 const utils_1 = require("../loops/utils");
 const variable_declaration_1 = require("../variable-declaration");
 const diagnostics_1 = require("../../utils/diagnostics");
 const utils_2 = require("../../../utils");
 const multi_1 = require("./multi");
-function isIterableType(type) {
-    return extensions.isExtensionType(type, extensions.ExtensionKind.IterableType);
-}
-exports.isIterableType = isIterableType;
-function returnsIterableType(context, node) {
-    const signature = context.checker.getResolvedSignature(node);
-    const type = signature === null || signature === void 0 ? void 0 : signature.getReturnType();
-    return type ? isIterableType(type) : false;
-}
-exports.returnsIterableType = returnsIterableType;
-function isIterableExpression(context, expression) {
-    const type = context.checker.getTypeAtLocation(expression);
-    return isIterableType(type);
-}
-exports.isIterableExpression = isIterableExpression;
-function transformForOfMultiIterableStatement(context, statement, block) {
-    const luaIterator = context.transformExpression(statement.expression);
+function transformForOfMultiIterableStatement(context, statement, block, luaIterator, invalidMultiUseDiagnostic) {
     let identifiers = [];
     if (ts.isVariableDeclarationList(statement.initializer)) {
         // Variables declared in for loop
@@ -35,7 +18,7 @@ function transformForOfMultiIterableStatement(context, statement, block) {
             identifiers = binding.elements.map(e => (0, variable_declaration_1.transformArrayBindingElement)(context, e));
         }
         else {
-            context.diagnostics.push((0, diagnostics_1.invalidMultiIterableWithoutDestructuring)(binding));
+            context.diagnostics.push(invalidMultiUseDiagnostic(binding));
         }
     }
     else if (ts.isArrayLiteralExpression(statement.initializer)) {
@@ -48,7 +31,7 @@ function transformForOfMultiIterableStatement(context, statement, block) {
         }
     }
     else {
-        context.diagnostics.push((0, diagnostics_1.invalidMultiIterableWithoutDestructuring)(statement.initializer));
+        context.diagnostics.push(invalidMultiUseDiagnostic(statement.initializer));
     }
     if (identifiers.length === 0) {
         identifiers.push(lua.createAnonymousIdentifier());
@@ -59,11 +42,27 @@ function transformForOfIterableStatement(context, statement, block) {
     var _a;
     const type = context.checker.getTypeAtLocation(statement.expression);
     if (((_a = type.aliasTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 2 && (0, multi_1.isMultiReturnType)(type.aliasTypeArguments[0])) {
-        return transformForOfMultiIterableStatement(context, statement, block);
+        const luaIterator = context.transformExpression(statement.expression);
+        return transformForOfMultiIterableStatement(context, statement, block, luaIterator, diagnostics_1.invalidMultiIterableWithoutDestructuring);
     }
     const luaIterator = context.transformExpression(statement.expression);
     const identifier = (0, utils_1.transformForInitializer)(context, statement.initializer, block);
     return lua.createForInStatement(block, [identifier], [luaIterator], statement);
 }
 exports.transformForOfIterableStatement = transformForOfIterableStatement;
+function transformForOfPairsIterableStatement(context, statement, block) {
+    const pairsCall = lua.createCallExpression(lua.createIdentifier("pairs"), [
+        context.transformExpression(statement.expression),
+    ]);
+    return transformForOfMultiIterableStatement(context, statement, block, pairsCall, diagnostics_1.invalidPairsIterableWithoutDestructuring);
+}
+exports.transformForOfPairsIterableStatement = transformForOfPairsIterableStatement;
+function transformForOfPairsKeyIterableStatement(context, statement, block) {
+    const pairsCall = lua.createCallExpression(lua.createIdentifier("pairs"), [
+        context.transformExpression(statement.expression),
+    ]);
+    const identifier = (0, utils_1.transformForInitializer)(context, statement.initializer, block);
+    return lua.createForInStatement(block, [identifier], [pairsCall], statement);
+}
+exports.transformForOfPairsKeyIterableStatement = transformForOfPairsKeyIterableStatement;
 //# sourceMappingURL=iterable.js.map

package/dist/transformation/visitors/language-extensions/multi.d.ts

@@ -8,4 +8,3 @@ export declare function isMultiReturnCall(context: TransformationContext, expres
 export declare function isMultiFunctionNode(context: TransformationContext, node: ts.Node): boolean;
 export declare function isInMultiReturnFunction(context: TransformationContext, node: ts.Node): boolean;
 export declare function shouldMultiReturnCallBeWrapped(context: TransformationContext, node: ts.CallExpression): boolean;
-export declare function findMultiAssignmentViolations(context: TransformationContext, node: ts.ObjectLiteralExpression): ts.Node[];

package/dist/transformation/visitors/language-extensions/multi.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findMultiAssignmentViolations = exports.shouldMultiReturnCallBeWrapped = exports.isInMultiReturnFunction = exports.isMultiFunctionNode = exports.isMultiReturnCall = exports.returnsMultiType = exports.isMultiFunctionCall = exports.canBeMultiReturnType = exports.isMultiReturnType = void 0;
+exports.shouldMultiReturnCallBeWrapped = exports.isInMultiReturnFunction = exports.isMultiFunctionNode = exports.isMultiReturnCall = exports.returnsMultiType = exports.isMultiFunctionCall = exports.canBeMultiReturnType = exports.isMultiReturnType = void 0;
 const ts = require("typescript");
 const extensions = require("../../utils/language-extensions");
+const language_extensions_1 = require("../../utils/language-extensions");
 const typescript_1 = require("../../utils/typescript");
-const iterable_1 = require("./iterable");
-const diagnostics_1 = require("../../utils/diagnostics");
+const multiReturnExtensionName = "__tstlMultiReturn";
 function isMultiReturnType(type) {
-    return extensions.isExtensionType(type, extensions.ExtensionKind.MultiType);
+    return type.getProperty(multiReturnExtensionName) !== undefined;
 }
 exports.isMultiReturnType = isMultiReturnType;
 function canBeMultiReturnType(type) {
-    return isMultiReturnType(type) || (type.isUnion() && type.types.some(canBeMultiReturnType));
+    return isMultiReturnType(type) || (type.isUnion() && type.types.some(t => canBeMultiReturnType(t)));
 }
 exports.canBeMultiReturnType = canBeMultiReturnType;
 function isMultiFunctionCall(context, expression) {
@@ -29,8 +29,9 @@ function isMultiReturnCall(context, expression) {
 }
 exports.isMultiReturnCall = isMultiReturnCall;
 function isMultiFunctionNode(context, node) {
-    const symbol = context.checker.getSymbolAtLocation(node);
-    return symbol ? extensions.isExtensionValue(context, symbol, extensions.ExtensionKind.MultiFunction) : false;
+    return (ts.isIdentifier(node) &&
+        node.text === "$multi" &&
+        (0, language_extensions_1.getExtensionKindForNode)(context, node) === extensions.ExtensionKind.MultiFunction);
 }
 exports.isMultiFunctionNode = isMultiFunctionNode;
 function isInMultiReturnFunction(context, node) {
@@ -75,26 +76,11 @@ function shouldMultiReturnCallBeWrapped(context, node) {
         return false;
     }
     // LuaIterable in for...of
-    if (ts.isForOfStatement(node.parent) && (0, iterable_1.isIterableExpression)(context, node)) {
+    if (ts.isForOfStatement(node.parent) &&
+        (0, language_extensions_1.getIterableExtensionKindForNode)(context, node) === language_extensions_1.IterableExtensionKind.Iterable) {
         return false;
     }
     return true;
 }
 exports.shouldMultiReturnCallBeWrapped = shouldMultiReturnCallBeWrapped;
-function findMultiAssignmentViolations(context, node) {
-    const result = [];
-    for (const element of node.properties) {
-        if (!ts.isShorthandPropertyAssignment(element))
-            continue;
-        const valueSymbol = context.checker.getShorthandAssignmentValueSymbol(element);
-        if (valueSymbol) {
-            if (extensions.isExtensionValue(context, valueSymbol, extensions.ExtensionKind.MultiFunction)) {
-                context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(element));
-                result.push(element);
-            }
-        }
-    }
-    return result;
-}
-exports.findMultiAssignmentViolations = findMultiAssignmentViolations;
 //# sourceMappingURL=multi.js.map

package/dist/transformation/visitors/language-extensions/operators.d.ts

@@ -1,5 +1,2 @@
-import * as ts from "typescript";
-import * as lua from "../../../LuaAST";
-import { TransformationContext } from "../../context";
-export declare function isOperatorMapping(context: TransformationContext, node: ts.CallExpression | ts.Identifier): boolean;
-export declare function transformOperatorMappingExpression(context: TransformationContext, node: ts.CallExpression, isOptionalCall: boolean): lua.Expression | undefined;
+import { LanguageExtensionCallTransformerMap } from "./call-extension";
+export declare const operatorExtensionTransformers: LanguageExtensionCallTransformerMap;