typescript-to-lua 1.3.0 → 1.3.1

package/dist/transformation/builtins/index.js

@@ -42,12 +42,18 @@ function transformBuiltinPropertyAccessExpression(context, node) {
 }
 exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAccessExpression;
 function transformBuiltinCallExpression(context, node, isOptionalCall) {
+    const unsupportedOptionalCall = () => {
+        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        return lua.createNilLiteral();
+    };
     const expressionType = context.checker.getTypeAtLocation(node.expression);
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, expressionType, undefined)) {
         // TODO:
         (0, new_1.checkForLuaLibType)(context, expressionType);
         const result = (0, global_1.transformGlobalCall)(context, node);
         if (result) {
+            if (isOptionalCall)
+                return unsupportedOptionalCall();
             return result;
         }
     }
@@ -55,12 +61,8 @@ function transformBuiltinCallExpression(context, node, isOptionalCall) {
     if (!ts.isPropertyAccessExpression(expression)) {
         return;
     }
-    (0, utils_1.assume)(node);
     const isOptionalAccess = expression.questionDotToken;
-    const unsupportedOptionalCall = () => {
-        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-        return lua.createNilLiteral();
-    };
+    (0, utils_1.assume)(node);
     // If the function being called is of type owner.func, get the type of owner
     const ownerType = context.checker.getTypeAtLocation(expression.expression);
     if ((0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {

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

@@ -76,12 +76,6 @@ export declare const invalidOperatorMappingUse: ((node: ts.Node, ...args: any[])
 export declare const invalidTableExtensionUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
-export declare const invalidTableDeleteExpression: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
-    code: number;
-};
-export declare const invalidTableSetExpression: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
-    code: number;
-};
 export declare const annotationRemoved: ((node: ts.Node, kind: AnnotationKind) => ts.Diagnostic) & {
     code: number;
 };

package/dist/transformation/utils/diagnostics.js

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

package/dist/transformation/visitors/call.js

@@ -12,12 +12,11 @@ const safe_names_1 = require("../utils/safe-names");
 const typescript_1 = require("../utils/typescript");
 const access_1 = require("./access");
 const multi_1 = require("./language-extensions/multi");
-const operators_1 = require("./language-extensions/operators");
-const table_1 = require("./language-extensions/table");
 const diagnostics_1 = require("../utils/diagnostics");
 const expression_list_1 = require("./expression-list");
 const preceding_statements_1 = require("../utils/preceding-statements");
 const optional_chaining_1 = require("./optional-chaining");
+const language_extensions_1 = require("./language-extensions");
 function validateArguments(context, params, signature) {
     if (!signature || signature.parameters.length < params.length) {
         return;
@@ -145,6 +144,7 @@ function transformElementCall(context, node) {
     }
 }
 const transformCallExpression = (node, context) => {
+    var _a;
     if (ts.isOptionalChain(node)) {
         return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
@@ -152,46 +152,13 @@ const transformCallExpression = (node, context) => {
         ? (0, optional_chaining_1.getOptionalContinuationData)(node.expression)
         : undefined;
     const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
-    const builtinResult = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined);
-    if (builtinResult) {
-        if (optionalContinuation) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-        }
-        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinResult) : builtinResult;
-    }
     if ((0, annotations_1.isTupleReturnCall)(context, node)) {
         context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
-    if ((0, operators_1.isOperatorMapping)(context, node)) {
-        if (optionalContinuation) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-            return lua.createNilLiteral();
-        }
-        return (0, operators_1.transformOperatorMappingExpression)(context, node);
-    }
-    if ((0, table_1.isTableDeleteCall)(context, node)) {
-        context.diagnostics.push((0, diagnostics_1.invalidTableDeleteExpression)(node));
-        context.addPrecedingStatements((0, table_1.transformTableDeleteExpression)(context, node));
-        return lua.createNilLiteral();
-    }
-    if ((0, table_1.isTableGetCall)(context, node)) {
-        if (optionalContinuation) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-            return lua.createNilLiteral();
-        }
-        return (0, table_1.transformTableGetExpression)(context, node);
-    }
-    if ((0, table_1.isTableHasCall)(context, node)) {
-        if (optionalContinuation) {
-            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-            return lua.createNilLiteral();
-        }
-        return (0, table_1.transformTableHasExpression)(context, node);
-    }
-    if ((0, table_1.isTableSetCall)(context, node)) {
-        context.diagnostics.push((0, diagnostics_1.invalidTableSetExpression)(node));
-        context.addPrecedingStatements((0, table_1.transformTableSetExpression)(context, node));
-        return lua.createNilLiteral();
+    const builtinOrExtensionResult = (_a = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined)) !== null && _a !== void 0 ? _a : (0, language_extensions_1.transformLanguageExtensionCallExpression)(context, node, optionalContinuation !== undefined);
+    if (builtinOrExtensionResult) {
+        // unsupportedOptionalCall diagnostic already present
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinOrExtensionResult) : builtinOrExtensionResult;
     }
     if (ts.isPropertyAccessExpression(node.expression)) {
         const ownerType = context.checker.getTypeAtLocation(node.expression.expression);

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.js

@@ -195,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
@@ -217,7 +218,9 @@ function transformFunctionLikeDeclaration(node, context) {
             }
         }
     }
-    return functionExpression;
+    return isNamedFunctionExpression && isFunctionTypeWithProperties(context.checker.getTypeAtLocation(node))
+        ? createCallableTable(functionExpression)
+        : functionExpression;
 }
 exports.transformFunctionLikeDeclaration = transformFunctionLikeDeclaration;
 const transformFunctionDeclaration = (node, 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/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/variable-declaration.js

@@ -186,12 +186,7 @@ function transformVariableDeclaration(context, statement) {
         const value = statement.initializer && context.transformExpression(statement.initializer);
         // Wrap functions being assigned to a type that contains additional properties in a callable table
         // This catches 'const foo = function() {}; foo.bar = "FOOBAR";'
-        const wrappedValue = value &&
-            // Skip named function expressions because they will have been wrapped already
-            !(statement.initializer && ts.isFunctionExpression(statement.initializer) && statement.initializer.name) &&
-            (0, function_1.isFunctionTypeWithProperties)(context.checker.getTypeAtLocation(statement.name))
-            ? (0, function_1.createCallableTable)(value)
-            : value;
+        const wrappedValue = value && shouldWrapInitializerInCallableTable() ? (0, function_1.createCallableTable)(value) : value;
         return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, identifierName, wrappedValue, statement);
     }
     else if (ts.isArrayBindingPattern(statement.name) || ts.isObjectBindingPattern(statement.name)) {
@@ -200,6 +195,17 @@ function transformVariableDeclaration(context, statement) {
     else {
         return (0, utils_1.assertNever)(statement.name);
     }
+    function shouldWrapInitializerInCallableTable() {
+        (0, utils_1.assert)(statement.initializer);
+        const initializer = ts.skipOuterExpressions(statement.initializer);
+        // do not wrap if not a function expression
+        if (!ts.isFunctionExpression(initializer) && !ts.isArrowFunction(initializer))
+            return false;
+        // Skip named function expressions because they will have been wrapped already
+        if (ts.isFunctionExpression(initializer) && initializer.name)
+            return false;
+        return (0, function_1.isFunctionTypeWithProperties)(context.checker.getTypeAtLocation(statement.name));
+    }
 }
 exports.transformVariableDeclaration = transformVariableDeclaration;
 function checkVariableDeclarationList(context, node) {

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

@@ -1,6 +1,3 @@
 import * as ts from "typescript";
-import * as lua from "../../LuaAST";
-import { TransformationContext } from "../context";
-import { FunctionVisitor } from "../context/visitors";
+import { FunctionVisitor } from "../context";
 export declare const transformVoidExpression: FunctionVisitor<ts.VoidExpression>;
-export declare const transformVoidExpressionStatement: (node: ts.VoidExpression, context: TransformationContext) => lua.VariableDeclarationStatement;

package/dist/transformation/visitors/void.js

@@ -1,20 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformVoidExpressionStatement = exports.transformVoidExpression = void 0;
+exports.transformVoidExpression = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
+const expression_statement_1 = require("./expression-statement");
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void
 const transformVoidExpression = (node, context) => {
     // If content is a literal it is safe to replace the entire expression with nil
     if (!ts.isLiteralExpression(node.expression)) {
-        // local ____ = <expression>
-        context.addPrecedingStatements(lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression)));
+        const statements = (0, expression_statement_1.transformExpressionToStatement)(context, node.expression);
+        if (statements)
+            context.addPrecedingStatements(statements);
     }
-    return lua.createNilLiteral(node);
+    return lua.createNilLiteral();
 };
 exports.transformVoidExpression = transformVoidExpression;
-const transformVoidExpressionStatement = (node, context) => 
-// In case of a void expression statement we can omit the IIFE
-lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression), node);
-exports.transformVoidExpressionStatement = transformVoidExpressionStatement;
 //# sourceMappingURL=void.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.3.0",
+    "version": "1.3.1",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
     "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",
     "homepage": "https://typescripttolua.github.io/",