typescript-to-lua 1.1.1 → 1.3.2

package/dist/transformation/visitors/expression-list.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOrderedExpressions = exports.transformExpressionList = exports.moveToPrecedingTemp = exports.shouldMoveToTemp = void 0;
+const assert = require("assert");
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+const context_1 = require("../context");
+const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const typescript_1 = require("../utils/typescript");
+const optional_chaining_1 = require("./optional-chaining");
+function shouldMoveToTemp(context, expression, tsOriginal) {
+    return (!lua.isLiteral(expression) &&
+        !(lua.isIdentifier(expression) && expression.symbolId === context_1.tempSymbolId) && // Treat generated temps as consts
+        !(tsOriginal && ((0, typescript_1.isConstIdentifier)(context, tsOriginal) || (0, optional_chaining_1.isOptionalContinuation)(tsOriginal))));
+}
+exports.shouldMoveToTemp = shouldMoveToTemp;
+// Cache an expression in a preceding statement and return the temp identifier
+function moveToPrecedingTemp(context, expression, tsOriginal) {
+    if (!shouldMoveToTemp(context, expression, tsOriginal)) {
+        return expression;
+    }
+    const tempIdentifier = context.createTempNameForLuaExpression(expression);
+    const tempDeclaration = lua.createVariableDeclarationStatement(tempIdentifier, expression, tsOriginal);
+    context.addPrecedingStatements(tempDeclaration);
+    return lua.cloneIdentifier(tempIdentifier, tsOriginal);
+}
+exports.moveToPrecedingTemp = moveToPrecedingTemp;
+function transformExpressions(context, expressions) {
+    const precedingStatements = [];
+    const transformedExpressions = [];
+    let lastPrecedingStatementsIndex = -1;
+    for (let i = 0; i < expressions.length; ++i) {
+        const [expressionPrecedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expressions[i]));
+        transformedExpressions.push(expression);
+        if (expressionPrecedingStatements.length > 0) {
+            lastPrecedingStatementsIndex = i;
+        }
+        precedingStatements.push(expressionPrecedingStatements);
+    }
+    return { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex };
+}
+function transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex) {
+    for (let i = 0; i < transformedExpressions.length; ++i) {
+        context.addPrecedingStatements(precedingStatements[i]);
+        if (i < lastPrecedingStatementsIndex) {
+            transformedExpressions[i] = moveToPrecedingTemp(context, transformedExpressions[i], expressions[i]);
+        }
+    }
+    return transformedExpressions;
+}
+function pushToSparseArray(context, arrayIdentifier, expressions) {
+    if (!arrayIdentifier) {
+        arrayIdentifier = lua.createIdentifier(context.createTempName("array"));
+        const libCall = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArrayNew, undefined, ...expressions);
+        const declaration = lua.createVariableDeclarationStatement(arrayIdentifier, libCall);
+        context.addPrecedingStatements(declaration);
+    }
+    else {
+        const libCall = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArrayPush, undefined, arrayIdentifier, ...expressions);
+        context.addPrecedingStatements(lua.createExpressionStatement(libCall));
+    }
+    return arrayIdentifier;
+}
+function transformExpressionsUsingSparseArray(context, expressions, transformedExpressions, precedingStatements) {
+    let arrayIdentifier;
+    let expressionBatch = [];
+    for (let i = 0; i < expressions.length; ++i) {
+        // Expressions with preceding statements should always be at the start of a batch
+        if (precedingStatements[i].length > 0 && expressionBatch.length > 0) {
+            arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+            expressionBatch = [];
+        }
+        context.addPrecedingStatements(precedingStatements[i]);
+        expressionBatch.push(transformedExpressions[i]);
+        // Spread expressions should always be at the end of a batch
+        if (ts.isSpreadElement(expressions[i])) {
+            arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+            expressionBatch = [];
+        }
+    }
+    if (expressionBatch.length > 0) {
+        arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+    }
+    assert(arrayIdentifier);
+    return [(0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArraySpread, undefined, arrayIdentifier)];
+}
+function countNeededTemps(context, expressions, transformedExpressions, lastPrecedingStatementsIndex) {
+    if (lastPrecedingStatementsIndex < 0) {
+        return 0;
+    }
+    return transformedExpressions
+        .slice(0, lastPrecedingStatementsIndex)
+        .filter((e, i) => shouldMoveToTemp(context, e, expressions[i])).length;
+}
+// Transforms a list of expressions while flattening spreads and maintaining execution order
+function transformExpressionList(context, expressions) {
+    const { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex } = transformExpressions(context, expressions);
+    // If more than this number of temps are required to preserve execution order, we'll fall back to using the
+    // sparse array lib functions instead to prevent excessive locals.
+    const maxTemps = 2;
+    // Use sparse array lib if there are spreads before the last expression
+    // or if too many temps are needed to preserve order
+    const lastSpread = expressions.findIndex(e => ts.isSpreadElement(e));
+    if ((lastSpread >= 0 && lastSpread < expressions.length - 1) ||
+        countNeededTemps(context, expressions, transformedExpressions, lastPrecedingStatementsIndex) > maxTemps) {
+        return transformExpressionsUsingSparseArray(context, expressions, transformedExpressions, precedingStatements);
+    }
+    else {
+        return transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex);
+    }
+}
+exports.transformExpressionList = transformExpressionList;
+// Transforms a series of expressions while maintaining execution order
+function transformOrderedExpressions(context, expressions) {
+    const { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex } = transformExpressions(context, expressions);
+    return transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex);
+}
+exports.transformOrderedExpressions = transformOrderedExpressions;
+//# sourceMappingURL=expression-list.js.map

package/dist/transformation/visitors/expression-statement.d.ts

@@ -1,3 +1,5 @@
 import * as ts from "typescript";
-import { FunctionVisitor } from "../context";
+import * as lua from "../../LuaAST";
+import { FunctionVisitor, TransformationContext } from "../context";
 export declare const transformExpressionStatement: FunctionVisitor<ts.ExpressionStatement>;
+export declare function transformExpressionToStatement(context: TransformationContext, expression: ts.Expression): lua.Statement | undefined;

package/dist/transformation/visitors/expression-statement.js

@@ -1,23 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformExpressionStatement = void 0;
-const ts = require("typescript");
+exports.transformExpressionToStatement = exports.transformExpressionStatement = void 0;
 const lua = require("../../LuaAST");
+const context_1 = require("../context");
 const binary_expression_1 = require("./binary-expression");
-const table_1 = require("./language-extensions/table");
 const unary_expression_1 = require("./unary-expression");
-const void_1 = require("./void");
 const transformExpressionStatement = (node, context) => {
-    const expression = node.expression;
-    if (ts.isCallExpression(expression) && (0, table_1.isTableDeleteCall)(context, expression)) {
-        return (0, table_1.transformTableDeleteExpression)(context, expression);
-    }
-    if (ts.isCallExpression(expression) && (0, table_1.isTableSetCall)(context, expression)) {
-        return (0, table_1.transformTableSetExpression)(context, expression);
-    }
-    if (ts.isVoidExpression(expression)) {
-        return (0, void_1.transformVoidExpressionStatement)(expression, context);
-    }
     const unaryExpressionResult = (0, unary_expression_1.transformUnaryExpressionStatement)(context, node);
     if (unaryExpressionResult) {
         return unaryExpressionResult;
@@ -26,11 +14,25 @@ const transformExpressionStatement = (node, context) => {
     if (binaryExpressionResult) {
         return binaryExpressionResult;
     }
-    const result = context.transformExpression(expression);
-    return lua.isCallExpression(result) || lua.isMethodCallExpression(result)
-        ? lua.createExpressionStatement(result)
-        : // Assign expression statements to dummy to make sure they're legal Lua
-            lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), result);
+    return transformExpressionToStatement(context, node.expression);
 };
 exports.transformExpressionStatement = transformExpressionStatement;
+function transformExpressionToStatement(context, expression) {
+    const result = context.transformExpression(expression);
+    const isTempVariable = lua.isIdentifier(result) && result.symbolId === context_1.tempSymbolId;
+    if (isTempVariable) {
+        return undefined;
+    }
+    // "synthetic": no side effects and no original source
+    const isSyntheticExpression = (lua.isIdentifier(result) || lua.isLiteral(result)) && result.line === undefined;
+    if (isSyntheticExpression) {
+        return undefined;
+    }
+    if (lua.isCallExpression(result) || lua.isMethodCallExpression(result)) {
+        return lua.createExpressionStatement(result);
+    }
+    // Assign expression statements to dummy to make sure they're legal Lua
+    return lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), result);
+}
+exports.transformExpressionToStatement = transformExpressionToStatement;
 //# sourceMappingURL=expression-statement.js.map

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

@@ -2,6 +2,8 @@ import * as ts from "typescript";
 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 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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformYieldExpression = exports.transformFunctionDeclaration = exports.transformFunctionLikeDeclaration = exports.transformFunctionToExpression = exports.transformParameters = exports.transformFunctionBody = exports.transformFunctionBodyHeader = exports.transformFunctionBodyContent = void 0;
+exports.transformYieldExpression = exports.transformFunctionDeclaration = exports.transformFunctionLikeDeclaration = exports.transformFunctionToExpression = exports.transformParameters = exports.transformFunctionBody = exports.transformFunctionBodyHeader = exports.transformFunctionBodyContent = exports.isFunctionTypeWithProperties = exports.createCallableTable = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
@@ -8,9 +8,12 @@ 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");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
+const typescript_1 = require("../utils/typescript");
 const async_await_1 = require("./async-await");
 const identifier_1 = require("./identifier");
 const return_1 = require("./return");
@@ -32,10 +35,43 @@ function isRestParameterReferenced(identifier, scope) {
     const references = scope.referencedSymbols.get(identifier.symbolId);
     return references !== undefined && references.length > 0;
 }
+function createCallableTable(functionExpression) {
+    var _a;
+    // __call metamethod receives the table as the first argument, so we need to add a dummy parameter
+    if (lua.isFunctionExpression(functionExpression)) {
+        (_a = functionExpression.params) === null || _a === void 0 ? void 0 : _a.unshift(lua.createAnonymousIdentifier());
+    }
+    else {
+        // functionExpression may have been replaced (lib functions, etc...),
+        // so we create a forwarding function to eat the extra argument
+        functionExpression = lua.createFunctionExpression(lua.createBlock([
+            lua.createReturnStatement([lua.createCallExpression(functionExpression, [lua.createDotsLiteral()])]),
+        ]), [lua.createAnonymousIdentifier()], lua.createDotsLiteral(), lua.FunctionExpressionFlags.Inline);
+    }
+    return lua.createCallExpression(lua.createIdentifier("setmetatable"), [
+        lua.createTableExpression(),
+        lua.createTableExpression([
+            lua.createTableFieldExpression(functionExpression, lua.createStringLiteral("__call")),
+        ]),
+    ]);
+}
+exports.createCallableTable = createCallableTable;
+function isFunctionTypeWithProperties(functionType) {
+    if (functionType.isUnion()) {
+        return functionType.types.some(isFunctionTypeWithProperties);
+    }
+    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
+        );
+    }
+}
+exports.isFunctionTypeWithProperties = isFunctionTypeWithProperties;
 function transformFunctionBodyContent(context, body) {
     if (!ts.isBlock(body)) {
-        const returnStatement = (0, return_1.transformExpressionBodyToReturnStatement)(context, body);
-        return [returnStatement];
+        const [precedingStatements, returnStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, return_1.transformExpressionBodyToReturnStatement)(context, body));
+        return [...precedingStatements, returnStatement];
     }
     const bodyStatements = (0, scope_1.performHoisting)(context, context.transformStatements(body.statements));
     return bodyStatements;
@@ -54,7 +90,9 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
                 headerStatements.push(transformParameterDefaultValueDeclaration(context, identifier, declaration.initializer));
             }
             // Binding pattern
-            bindingPatternDeclarations.push(...(0, variable_declaration_1.transformBindingPattern)(context, declaration.name, identifier));
+            const name = declaration.name;
+            const [precedingStatements, bindings] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, name, identifier));
+            bindingPatternDeclarations.push(...precedingStatements, ...bindings);
         }
         else if (declaration.initializer !== undefined) {
             // Default parameter
@@ -157,24 +195,32 @@ function transformFunctionLikeDeclaration(node, context) {
         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
-    if (ts.isFunctionExpression(node) && node.name && functionScope.referencedSymbols) {
+    if (isNamedFunctionExpression && functionScope.referencedSymbols) {
         const symbol = context.checker.getSymbolAtLocation(node.name);
         if (symbol) {
             // TODO: Not using symbol ids because of https://github.com/microsoft/TypeScript/issues/37131
             const isReferenced = [...functionScope.referencedSymbols].some(([, nodes]) => nodes.some(n => { var _a; return ((_a = context.checker.getSymbolAtLocation(n)) === null || _a === void 0 ? void 0 : _a.valueDeclaration) === symbol.valueDeclaration; }));
-            // Only wrap if the name is actually referenced inside the function
+            // Only handle if the name is actually referenced inside the function
             if (isReferenced) {
                 const nameIdentifier = (0, identifier_1.transformIdentifier)(context, node.name);
-                // We cannot use transformToImmediatelyInvokedFunctionExpression() here because we need to transpile
-                // the function first to determine if it's self-referencing. Fortunately, this does not cause issues
-                // with var-arg optimization because the IIFE is just wrapping another function which will already push
-                // another scope.
-                return (0, lua_ast_1.createImmediatelyInvokedFunctionExpression)([lua.createVariableDeclarationStatement(nameIdentifier, functionExpression)], lua.cloneIdentifier(nameIdentifier));
+                if (isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))) {
+                    context.addPrecedingStatements([
+                        lua.createVariableDeclarationStatement(nameIdentifier),
+                        lua.createAssignmentStatement(nameIdentifier, createCallableTable(functionExpression)),
+                    ]);
+                }
+                else {
+                    context.addPrecedingStatements(lua.createVariableDeclarationStatement(nameIdentifier, functionExpression));
+                }
+                return lua.cloneIdentifier(nameIdentifier);
             }
         }
     }
-    return functionExpression;
+    return isNamedFunctionExpression && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))
+        ? createCallableTable(functionExpression)
+        : functionExpression;
 }
 exports.transformFunctionLikeDeclaration = transformFunctionLikeDeclaration;
 const transformFunctionDeclaration = (node, context) => {
@@ -201,7 +247,11 @@ const transformFunctionDeclaration = (node, context) => {
         const functionInfo = { referencedSymbols: (_a = functionScope.referencedSymbols) !== null && _a !== void 0 ? _a : new Map() };
         scope.functionDefinitions.set(name.symbolId, functionInfo);
     }
-    return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, name, functionExpression, node);
+    // Wrap functions with properties into a callable table
+    const wrappedFunction = node.name && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node.name))
+        ? createCallableTable(functionExpression)
+        : functionExpression;
+    return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, name, wrappedFunction, node);
 };
 exports.transformFunctionDeclaration = transformFunctionDeclaration;
 const transformYieldExpression = (expression, context) => {

package/dist/transformation/visitors/identifier.js

@@ -5,6 +5,7 @@ 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");
@@ -16,7 +17,11 @@ 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");
 function transformIdentifier(context, identifier) {
+    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);

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

@@ -0,0 +1,4 @@
+import { TransformationContext } from "../../context";
+import * as ts from "typescript";
+import * as lua from "../../../LuaAST";
+export declare function transformLanguageExtensionCallExpression(context: TransformationContext, node: ts.CallExpression, isOptionalCall: boolean): lua.Expression | undefined;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLanguageExtensionCallExpression = void 0;
+const operators_1 = require("./operators");
+const table_1 = require("./table");
+function transformLanguageExtensionCallExpression(context, node, isOptionalCall) {
+    const operatorMapping = (0, operators_1.transformOperatorMappingExpression)(context, node, isOptionalCall);
+    if (operatorMapping) {
+        return operatorMapping;
+    }
+    const tableCall = (0, table_1.transformTableExtensionCall)(context, node, isOptionalCall);
+    if (tableCall) {
+        return tableCall;
+    }
+}
+exports.transformLanguageExtensionCallExpression = transformLanguageExtensionCallExpression;
+//# sourceMappingURL=index.js.map

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

@@ -2,4 +2,4 @@ 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): lua.Expression;
+export declare function transformOperatorMappingExpression(context: TransformationContext, node: ts.CallExpression, isOptionalCall: boolean): lua.Expression | undefined;

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

@@ -77,9 +77,14 @@ function isOperatorMapping(context, node) {
     }
 }
 exports.isOperatorMapping = isOperatorMapping;
-function transformOperatorMappingExpression(context, node) {
+function transformOperatorMappingExpression(context, node, isOptionalCall) {
     const extensionKind = getOperatorMapExtensionKindForCall(context, node);
-    (0, utils_1.assert)(extensionKind);
+    if (!extensionKind)
+        return undefined;
+    if (isOptionalCall) {
+        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        return lua.createNilLiteral();
+    }
     const isBefore53 = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 ||
         context.luaTarget === CompilerOptions_1.LuaTarget.Lua52 ||
         context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT ||

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

@@ -0,0 +1,5 @@
+import * as ts from "typescript";
+import * as lua from "../../../LuaAST";
+import { TransformationContext } from "../../context";
+export declare function isPairsIterableExpression(context: TransformationContext, expression: ts.Expression): boolean;
+export declare function transformForOfPairsIterableStatement(context: TransformationContext, statement: ts.ForOfStatement, block: lua.Block): lua.Statement;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformForOfPairsIterableStatement = exports.isPairsIterableExpression = void 0;
+const ts = require("typescript");
+const lua = require("../../../LuaAST");
+const utils_1 = require("../../../utils");
+const diagnostics_1 = require("../../utils/diagnostics");
+const extensions = require("../../utils/language-extensions");
+const utils_2 = require("../loops/utils");
+const variable_declaration_1 = require("../variable-declaration");
+function isPairsIterableType(type) {
+    return extensions.isExtensionType(type, extensions.ExtensionKind.PairsIterableType);
+}
+function isPairsIterableExpression(context, expression) {
+    const type = context.checker.getTypeAtLocation(expression);
+    return isPairsIterableType(type);
+}
+exports.isPairsIterableExpression = isPairsIterableExpression;
+function transformForOfPairsIterableStatement(context, statement, block) {
+    const pairsCall = lua.createCallExpression(lua.createIdentifier("pairs"), [
+        context.transformExpression(statement.expression),
+    ]);
+    let identifiers = [];
+    if (ts.isVariableDeclarationList(statement.initializer)) {
+        // Variables declared in for loop
+        // for key, value in iterable do
+        const binding = (0, utils_2.getVariableDeclarationBinding)(context, statement.initializer);
+        if (ts.isArrayBindingPattern(binding)) {
+            identifiers = binding.elements.map(e => (0, variable_declaration_1.transformArrayBindingElement)(context, e));
+        }
+        else {
+            context.diagnostics.push((0, diagnostics_1.invalidPairsIterableWithoutDestructuring)(binding));
+        }
+    }
+    else if (ts.isArrayLiteralExpression(statement.initializer)) {
+        // Variables NOT declared in for loop - catch iterator values in temps and assign
+        // for ____key, ____value in iterable do
+        //     key, value = ____key, ____value
+        identifiers = statement.initializer.elements.map(e => context.createTempNameForNode(e));
+        if (identifiers.length > 0) {
+            block.statements.unshift(lua.createAssignmentStatement(statement.initializer.elements.map(e => (0, utils_1.cast)(context.transformExpression(e), lua.isAssignmentLeftHandSideExpression)), identifiers));
+        }
+    }
+    else {
+        context.diagnostics.push((0, diagnostics_1.invalidPairsIterableWithoutDestructuring)(statement.initializer));
+    }
+    if (identifiers.length === 0) {
+        identifiers.push(lua.createAnonymousIdentifier());
+    }
+    return lua.createForInStatement(block, identifiers, [pairsCall], statement);
+}
+exports.transformForOfPairsIterableStatement = transformForOfPairsIterableStatement;
+//# sourceMappingURL=pairsIterable.js.map

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

@@ -2,12 +2,5 @@ import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
 export declare function isTableExtensionIdentifier(context: TransformationContext, node: ts.Identifier): boolean;
-export declare function isTableDeleteCall(context: TransformationContext, node: ts.CallExpression): boolean;
-export declare function isTableGetCall(context: TransformationContext, node: ts.CallExpression): boolean;
-export declare function isTableHasCall(context: TransformationContext, node: ts.CallExpression): boolean;
-export declare function isTableSetCall(context: TransformationContext, node: ts.CallExpression): boolean;
 export declare function isTableNewCall(context: TransformationContext, node: ts.NewExpression): boolean;
-export declare function transformTableDeleteExpression(context: TransformationContext, node: ts.CallExpression): lua.Statement;
-export declare function transformTableGetExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression;
-export declare function transformTableHasExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression;
-export declare function transformTableSetExpression(context: TransformationContext, node: ts.CallExpression): lua.Statement;
+export declare function transformTableExtensionCall(context: TransformationContext, node: ts.CallExpression, isOptionalCall: boolean): lua.Expression | undefined;

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

@@ -1,25 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformTableSetExpression = exports.transformTableHasExpression = exports.transformTableGetExpression = exports.transformTableDeleteExpression = exports.isTableNewCall = exports.isTableSetCall = exports.isTableHasCall = exports.isTableGetCall = exports.isTableDeleteCall = exports.isTableExtensionIdentifier = void 0;
+exports.transformTableExtensionCall = exports.isTableNewCall = exports.isTableExtensionIdentifier = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const extensions = require("../../utils/language-extensions");
 const typescript_1 = require("../../utils/typescript");
-const utils_1 = require("../../../utils");
-const tableDeleteExtensions = [
+const expression_list_1 = require("../expression-list");
+const diagnostics_1 = require("../../utils/diagnostics");
+const tableCallExtensions = [
     extensions.ExtensionKind.TableDeleteType,
     extensions.ExtensionKind.TableDeleteMethodType,
+    extensions.ExtensionKind.TableGetType,
+    extensions.ExtensionKind.TableGetMethodType,
+    extensions.ExtensionKind.TableHasType,
+    extensions.ExtensionKind.TableHasMethodType,
+    extensions.ExtensionKind.TableSetType,
+    extensions.ExtensionKind.TableSetMethodType,
 ];
-const tableGetExtensions = [extensions.ExtensionKind.TableGetType, extensions.ExtensionKind.TableGetMethodType];
-const tableHasExtensions = [extensions.ExtensionKind.TableHasType, extensions.ExtensionKind.TableHasMethodType];
-const tableSetExtensions = [extensions.ExtensionKind.TableSetType, extensions.ExtensionKind.TableSetMethodType];
-const tableExtensions = [
-    extensions.ExtensionKind.TableNewType,
-    ...tableDeleteExtensions,
-    ...tableGetExtensions,
-    ...tableHasExtensions,
-    ...tableSetExtensions,
-];
+const tableExtensions = [extensions.ExtensionKind.TableNewType, ...tableCallExtensions];
 function getTableExtensionKindForCall(context, node, validExtensions) {
     const type = (0, typescript_1.getFunctionTypeForCall)(context, node);
     return type && validExtensions.find(extensionKind => extensions.isExtensionType(type, extensionKind));
@@ -29,79 +27,83 @@ function isTableExtensionIdentifier(context, node) {
     return tableExtensions.some(extensionKind => extensions.isExtensionType(type, extensionKind));
 }
 exports.isTableExtensionIdentifier = isTableExtensionIdentifier;
-function isTableDeleteCall(context, node) {
-    return getTableExtensionKindForCall(context, node, tableDeleteExtensions) !== undefined;
-}
-exports.isTableDeleteCall = isTableDeleteCall;
-function isTableGetCall(context, node) {
-    return getTableExtensionKindForCall(context, node, tableGetExtensions) !== undefined;
-}
-exports.isTableGetCall = isTableGetCall;
-function isTableHasCall(context, node) {
-    return getTableExtensionKindForCall(context, node, tableHasExtensions) !== undefined;
-}
-exports.isTableHasCall = isTableHasCall;
-function isTableSetCall(context, node) {
-    return getTableExtensionKindForCall(context, node, tableSetExtensions) !== undefined;
-}
-exports.isTableSetCall = isTableSetCall;
 function isTableNewCall(context, node) {
     const type = context.checker.getTypeAtLocation(node.expression);
     return extensions.isExtensionType(type, extensions.ExtensionKind.TableNewType);
 }
 exports.isTableNewCall = isTableNewCall;
-function transformTableDeleteExpression(context, node) {
-    const extensionKind = getTableExtensionKindForCall(context, node, tableDeleteExtensions);
-    (0, utils_1.assert)(extensionKind);
+function transformTableExtensionCall(context, node, isOptionalCall) {
+    const extensionType = getTableExtensionKindForCall(context, node, tableCallExtensions);
+    if (!extensionType)
+        return;
+    if (isOptionalCall) {
+        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        return lua.createNilLiteral();
+    }
+    if (extensionType === extensions.ExtensionKind.TableDeleteType ||
+        extensionType === extensions.ExtensionKind.TableDeleteMethodType) {
+        return transformTableDeleteExpression(context, node, extensionType);
+    }
+    if (extensionType === extensions.ExtensionKind.TableGetType ||
+        extensionType === extensions.ExtensionKind.TableGetMethodType) {
+        return transformTableGetExpression(context, node, extensionType);
+    }
+    if (extensionType === extensions.ExtensionKind.TableHasType ||
+        extensionType === extensions.ExtensionKind.TableHasMethodType) {
+        return transformTableHasExpression(context, node, extensionType);
+    }
+    if (extensionType === extensions.ExtensionKind.TableSetType ||
+        extensionType === extensions.ExtensionKind.TableSetMethodType) {
+        return transformTableSetExpression(context, node, extensionType);
+    }
+}
+exports.transformTableExtensionCall = transformTableExtensionCall;
+function transformTableDeleteExpression(context, node, extensionKind) {
     const args = node.arguments.slice();
-    if (args.length === 1 &&
+    if (extensionKind === extensions.ExtensionKind.TableDeleteMethodType &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
         // In case of method (no table argument), push method owner to front of args list
         args.unshift(node.expression.expression);
     }
     // arg0[arg1] = nil
-    return lua.createAssignmentStatement(lua.createTableIndexExpression(context.transformExpression(args[0]), context.transformExpression(args[1])), lua.createNilLiteral(), node);
+    const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), lua.createNilLiteral(), node));
+    return lua.createBooleanLiteral(true);
 }
-exports.transformTableDeleteExpression = transformTableDeleteExpression;
-function transformTableGetExpression(context, node) {
-    const extensionKind = getTableExtensionKindForCall(context, node, tableGetExtensions);
-    (0, utils_1.assert)(extensionKind);
+function transformTableGetExpression(context, node, extensionKind) {
     const args = node.arguments.slice();
-    if (args.length === 1 &&
+    if (extensionKind === extensions.ExtensionKind.TableGetMethodType &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
         // In case of method (no table argument), push method owner to front of args list
         args.unshift(node.expression.expression);
     }
+    const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
     // arg0[arg1]
-    return lua.createTableIndexExpression(context.transformExpression(args[0]), context.transformExpression(args[1]), node);
+    return lua.createTableIndexExpression(table, accessExpression, node);
 }
-exports.transformTableGetExpression = transformTableGetExpression;
-function transformTableHasExpression(context, node) {
-    const extensionKind = getTableExtensionKindForCall(context, node, tableHasExtensions);
-    (0, utils_1.assert)(extensionKind);
+function transformTableHasExpression(context, node, extensionKind) {
     const args = node.arguments.slice();
-    if (args.length === 1 &&
+    if (extensionKind === extensions.ExtensionKind.TableHasMethodType &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
         // In case of method (no table argument), push method owner to front of args list
         args.unshift(node.expression.expression);
     }
     // arg0[arg1]
-    const tableIndexExpression = lua.createTableIndexExpression(context.transformExpression(args[0]), context.transformExpression(args[1]));
+    const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
+    const tableIndexExpression = lua.createTableIndexExpression(table, accessExpression);
     // arg0[arg1] ~= nil
     return lua.createBinaryExpression(tableIndexExpression, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator, node);
 }
-exports.transformTableHasExpression = transformTableHasExpression;
-function transformTableSetExpression(context, node) {
-    const extensionKind = getTableExtensionKindForCall(context, node, tableSetExtensions);
-    (0, utils_1.assert)(extensionKind);
+function transformTableSetExpression(context, node, extensionKind) {
     const args = node.arguments.slice();
-    if (args.length === 2 &&
+    if (extensionKind === extensions.ExtensionKind.TableSetMethodType &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
         // In case of method (no table argument), push method owner to front of args list
         args.unshift(node.expression.expression);
     }
     // arg0[arg1] = arg2
-    return lua.createAssignmentStatement(lua.createTableIndexExpression(context.transformExpression(args[0]), context.transformExpression(args[1])), context.transformExpression(args[2]), node);
+    const [table, accessExpression, value] = (0, expression_list_1.transformExpressionList)(context, args);
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), value, node));
+    return lua.createNilLiteral();
 }
-exports.transformTableSetExpression = transformTableSetExpression;
 //# sourceMappingURL=table.js.map