typescript-to-lua 1.2.0 → 1.3.3

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,10 +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");
@@ -33,6 +35,39 @@ 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 [precedingStatements, returnStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, return_1.transformExpressionBodyToReturnStatement)(context, body));
@@ -55,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
@@ -158,8 +195,9 @@ 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
@@ -167,12 +205,22 @@ 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);
-                context.addPrecedingStatements(lua.createVariableDeclarationStatement(nameIdentifier, functionExpression));
+                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) => {
@@ -199,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");
@@ -19,7 +20,7 @@ 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);
+        return lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
     }
     if ((0, multi_1.isMultiFunctionNode)(context, identifier)) {
         context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(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

package/dist/transformation/visitors/loops/for-of.js

@@ -8,6 +8,7 @@ const diagnostics_1 = require("../../utils/diagnostics");
 const lualib_1 = require("../../utils/lualib");
 const typescript_1 = require("../../utils/typescript");
 const iterable_1 = require("../language-extensions/iterable");
+const pairsIterable_1 = require("../language-extensions/pairsIterable");
 const range_1 = require("../language-extensions/range");
 const utils_1 = require("./utils");
 function transformForOfArrayStatement(context, statement, block) {
@@ -33,6 +34,9 @@ const transformForOfStatement = (node, context) => {
     else if ((0, iterable_1.isIterableExpression)(context, node.expression)) {
         return (0, iterable_1.transformForOfIterableStatement)(context, node, body);
     }
+    else if ((0, pairsIterable_1.isPairsIterableExpression)(context, node.expression)) {
+        return (0, pairsIterable_1.transformForOfPairsIterableStatement)(context, node, body);
+    }
     else if ((0, annotations_1.isLuaIteratorType)(context, node.expression)) {
         context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node.expression, annotations_1.AnnotationKind.LuaIterator));
     }

package/dist/transformation/visitors/loops/utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.invertCondition = exports.transformForInitializer = exports.getVariableDeclarationBinding = exports.transformLoopBody = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
+const preceding_statements_1 = require("../../utils/preceding-statements");
 const scope_1 = require("../../utils/scope");
 const typescript_1 = require("../../utils/typescript");
 const assignments_1 = require("../binary-expression/assignments");
@@ -34,14 +35,17 @@ function getVariableDeclarationBinding(context, node) {
 exports.getVariableDeclarationBinding = getVariableDeclarationBinding;
 function transformForInitializer(context, initializer, block) {
     const valueVariable = lua.createIdentifier("____value");
+    (0, scope_1.pushScope)(context, scope_1.ScopeType.LoopInitializer);
     if (ts.isVariableDeclarationList(initializer)) {
         // Declaration of new variable
         const binding = getVariableDeclarationBinding(context, initializer);
         if (ts.isArrayBindingPattern(binding) || ts.isObjectBindingPattern(binding)) {
-            block.statements.unshift(...(0, variable_declaration_1.transformBindingPattern)(context, binding, valueVariable));
+            const [precedingStatements, bindings] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, binding, valueVariable));
+            block.statements.unshift(...precedingStatements, ...bindings);
         }
         else {
             // Single variable declared in for loop
+            (0, scope_1.popScope)(context);
             return (0, identifier_1.transformIdentifier)(context, binding);
         }
     }
@@ -51,6 +55,7 @@ function transformForInitializer(context, initializer, block) {
             ? (0, destructuring_assignments_1.transformAssignmentPattern)(context, initializer, valueVariable, false)
             : (0, assignments_1.transformAssignment)(context, initializer, valueVariable)));
     }
+    (0, scope_1.popScope)(context);
     return valueVariable;
 }
 exports.transformForInitializer = transformForInitializer;

package/dist/transformation/visitors/namespace.js

@@ -13,7 +13,7 @@ const symbols_1 = require("../utils/symbols");
 const identifier_1 = require("./identifier");
 function createModuleLocalNameIdentifier(context, declaration) {
     const moduleSymbol = context.checker.getSymbolAtLocation(declaration.name);
-    if (moduleSymbol !== undefined && (0, safe_names_1.isUnsafeName)(moduleSymbol.name)) {
+    if (moduleSymbol !== undefined && (0, safe_names_1.isUnsafeName)(moduleSymbol.name, context.options)) {
         return lua.createIdentifier((0, safe_names_1.createSafeName)(declaration.name.text), declaration.name, moduleSymbol && (0, symbols_1.getSymbolIdOfSymbol)(context, moduleSymbol), declaration.name.text);
     }
     // TODO: Should synthetic name nodes be escaped as well?

package/dist/transformation/visitors/spread.js

@@ -11,9 +11,15 @@ const typescript_1 = require("../utils/typescript");
 const multi_1 = require("./language-extensions/multi");
 const diagnostics_1 = require("../utils/diagnostics");
 const vararg_1 = require("./language-extensions/vararg");
+function skipOuterExpressionParents(node) {
+    while (ts.isOuterExpression(node)) {
+        node = node.parent;
+    }
+    return node;
+}
 function isOptimizedVarArgSpread(context, symbol, identifier) {
     var _a;
-    if (!ts.isSpreadElement(identifier.parent)) {
+    if (!ts.isSpreadElement(skipOuterExpressionParents(identifier.parent))) {
         return false;
     }
     // Walk up, stopping at any scope types which could stop optimization
@@ -51,19 +57,20 @@ function isOptimizedVarArgSpread(context, symbol, identifier) {
 exports.isOptimizedVarArgSpread = isOptimizedVarArgSpread;
 // TODO: Currently it's also used as an array member
 const transformSpreadElement = (node, context) => {
-    if (ts.isIdentifier(node.expression)) {
-        if ((0, annotations_1.isVarargType)(context, node.expression)) {
+    const tsInnerExpression = ts.skipOuterExpressions(node.expression);
+    if (ts.isIdentifier(tsInnerExpression)) {
+        if ((0, annotations_1.isVarargType)(context, tsInnerExpression)) {
             context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.Vararg));
         }
-        const symbol = context.checker.getSymbolAtLocation(node.expression);
-        if (symbol && isOptimizedVarArgSpread(context, symbol, node.expression)) {
+        const symbol = context.checker.getSymbolAtLocation(tsInnerExpression);
+        if (symbol && isOptimizedVarArgSpread(context, symbol, tsInnerExpression)) {
             return lua.createDotsLiteral(node);
         }
     }
     const innerExpression = context.transformExpression(node.expression);
-    if ((0, multi_1.isMultiReturnCall)(context, node.expression))
+    if ((0, multi_1.isMultiReturnCall)(context, tsInnerExpression))
         return innerExpression;
-    const type = context.checker.getTypeAtLocation(node.expression);
+    const type = context.checker.getTypeAtLocation(node.expression); // not ts-inner expression, in case of casts
     if ((0, typescript_1.isArrayType)(context, type)) {
         return (0, lua_ast_1.createUnpackCall)(context, innerExpression, node);
     }