typescript-to-lua 1.0.1 → 1.3.0

package/dist/transformation/visitors/delete.js

@@ -7,7 +7,11 @@ const lualib_1 = require("../utils/lualib");
 const diagnostics_1 = require("../utils/diagnostics");
 const typescript_1 = require("../utils/typescript");
 const lua_ast_1 = require("../utils/lua-ast");
+const optional_chaining_1 = require("./optional-chaining");
 const transformDeleteExpression = (node, context) => {
+    if (ts.isOptionalChain(node.expression)) {
+        return (0, optional_chaining_1.transformOptionalDeleteExpression)(context, node, node.expression);
+    }
     let ownerExpression;
     let propertyExpression;
     if (ts.isPropertyAccessExpression(node.expression)) {
@@ -21,15 +25,15 @@ const transformDeleteExpression = (node, context) => {
         propertyExpression = context.transformExpression(node.expression.argumentExpression);
         const type = context.checker.getTypeAtLocation(node.expression.expression);
         const argumentType = context.checker.getTypeAtLocation(node.expression.argumentExpression);
-        if (typescript_1.isArrayType(context, type) && typescript_1.isNumberType(context, argumentType)) {
-            propertyExpression = lua_ast_1.addToNumericExpression(propertyExpression, 1);
+        if ((0, typescript_1.isArrayType)(context, type) && (0, typescript_1.isNumberType)(context, argumentType)) {
+            propertyExpression = (0, lua_ast_1.addToNumericExpression)(propertyExpression, 1);
         }
     }
     if (!ownerExpression || !propertyExpression) {
-        context.diagnostics.push(diagnostics_1.unsupportedProperty(node, "delete", ts.SyntaxKind[node.kind]));
+        context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node, "delete", ts.SyntaxKind[node.kind]));
         return lua.createNilLiteral();
     }
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Delete, node, ownerExpression, propertyExpression);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Delete, node, ownerExpression, propertyExpression);
 };
 exports.transformDeleteExpression = transformDeleteExpression;
 //# sourceMappingURL=delete.js.map

package/dist/transformation/visitors/enum.js

@@ -24,16 +24,16 @@ const transformEnumDeclaration = (node, context) => {
         return undefined;
     }
     const type = context.checker.getTypeAtLocation(node);
-    const membersOnly = annotations_1.getTypeAnnotations(type).has(annotations_1.AnnotationKind.CompileMembersOnly);
+    const membersOnly = (0, annotations_1.getTypeAnnotations)(type).has(annotations_1.AnnotationKind.CompileMembersOnly);
     const result = [];
-    if (!membersOnly && typescript_1.isFirstDeclaration(context, node)) {
-        const name = identifier_1.transformIdentifier(context, node.name);
+    if (!membersOnly && (0, typescript_1.isFirstDeclaration)(context, node)) {
+        const name = (0, identifier_1.transformIdentifier)(context, node.name);
         const table = lua.createBinaryExpression(lua.cloneIdentifier(name), lua.createTableExpression(), lua.SyntaxKind.OrOperator);
-        result.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, name, table, node));
+        result.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, name, table, node));
     }
     const enumReference = context.transformExpression(node.name);
     for (const member of node.members) {
-        const memberName = literal_1.transformPropertyName(context, member.name);
+        const memberName = (0, literal_1.transformPropertyName)(context, member.name);
         let valueExpression;
         const constEnumValue = tryGetConstEnumValue(context, member);
         if (constEnumValue) {
@@ -45,7 +45,7 @@ const transformEnumDeclaration = (node, context) => {
                 if ((symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration) &&
                     ts.isEnumMember(symbol.valueDeclaration) &&
                     symbol.valueDeclaration.parent === node) {
-                    const otherMemberName = literal_1.transformPropertyName(context, symbol.valueDeclaration.name);
+                    const otherMemberName = (0, literal_1.transformPropertyName)(context, symbol.valueDeclaration.name);
                     valueExpression = lua.createTableIndexExpression(enumReference, otherMemberName);
                 }
             }
@@ -58,8 +58,8 @@ const transformEnumDeclaration = (node, context) => {
         }
         if (membersOnly) {
             const enumSymbol = context.checker.getSymbolAtLocation(node.name);
-            const exportScope = enumSymbol ? export_1.getSymbolExportScope(context, enumSymbol) : undefined;
-            result.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, lua.isIdentifier(memberName)
+            const exportScope = enumSymbol ? (0, export_1.getSymbolExportScope)(context, enumSymbol) : undefined;
+            result.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, lua.isIdentifier(memberName)
                 ? memberName
                 : lua.createIdentifier(member.name.getText(), member.name), valueExpression, node, exportScope));
         }

package/dist/transformation/visitors/errors.js

@@ -1,52 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformThrowStatement = exports.transformTryStatement = void 0;
+const __1 = require("../..");
 const lua = require("../../LuaAST");
+const diagnostics_1 = require("../utils/diagnostics");
 const lua_ast_1 = require("../utils/lua-ast");
 const scope_1 = require("../utils/scope");
+const typescript_1 = require("../utils/typescript");
 const block_1 = require("./block");
 const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
+const return_1 = require("./return");
 const transformTryStatement = (statement, context) => {
-    const [tryBlock, tryScope] = block_1.transformScopeBlock(context, statement.tryBlock, scope_1.ScopeType.Try);
+    var _a;
+    const [tryBlock, tryScope] = (0, block_1.transformScopeBlock)(context, statement.tryBlock, scope_1.ScopeType.Try);
+    if (context.options.luaTarget === __1.LuaTarget.Lua51 && (0, typescript_1.isInAsyncFunction)(statement)) {
+        context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(statement, "try/catch inside async functions", __1.LuaTarget.Lua51));
+        return tryBlock.statements;
+    }
+    if (context.options.luaTarget === __1.LuaTarget.Lua51 && (0, typescript_1.isInGeneratorFunction)(statement)) {
+        context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(statement, "try/catch inside generator functions", __1.LuaTarget.Lua51));
+        return tryBlock.statements;
+    }
     const tryResultIdentifier = lua.createIdentifier("____try");
     const returnValueIdentifier = lua.createIdentifier("____returnValue");
     const result = [];
-    let returnedIdentifier;
+    const returnedIdentifier = lua.createIdentifier("____hasReturned");
     let returnCondition;
     const pCall = lua.createIdentifier("pcall");
     const tryCall = lua.createCallExpression(pCall, [lua.createFunctionExpression(tryBlock)]);
     if (statement.catchClause && statement.catchClause.block.statements.length > 0) {
         // try with catch
-        let [catchBlock, catchScope] = block_1.transformScopeBlock(context, statement.catchClause.block, scope_1.ScopeType.Catch);
-        if (statement.catchClause.variableDeclaration) {
-            // Replace ____returned with catch variable
-            returnedIdentifier = identifier_1.transformIdentifier(context, statement.catchClause.variableDeclaration.name);
-        }
-        else if (tryScope.functionReturned || catchScope.functionReturned) {
-            returnedIdentifier = lua.createIdentifier("____returned");
-        }
+        const [catchBlock, catchScope] = (0, block_1.transformScopeBlock)(context, statement.catchClause.block, scope_1.ScopeType.Catch);
+        const catchParameter = statement.catchClause.variableDeclaration
+            ? (0, identifier_1.transformIdentifier)(context, statement.catchClause.variableDeclaration.name)
+            : undefined;
+        const catchFunction = lua.createFunctionExpression(catchBlock, catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
+        const catchIdentifier = lua.createIdentifier("____catch");
+        result.push(lua.createVariableDeclarationStatement(catchIdentifier, catchFunction));
+        const hasReturn = (_a = tryScope.functionReturned) !== null && _a !== void 0 ? _a : catchScope.functionReturned;
         const tryReturnIdentifiers = [tryResultIdentifier]; // ____try
-        if (returnedIdentifier) {
-            tryReturnIdentifiers.push(returnedIdentifier); // ____returned or catch variable
-            if (tryScope.functionReturned || catchScope.functionReturned) {
+        if (hasReturn || statement.catchClause.variableDeclaration) {
+            tryReturnIdentifiers.push(returnedIdentifier); // ____returned
+            if (hasReturn) {
                 tryReturnIdentifiers.push(returnValueIdentifier); // ____returnValue
                 returnCondition = lua.cloneIdentifier(returnedIdentifier);
             }
         }
         result.push(lua.createVariableDeclarationStatement(tryReturnIdentifiers, tryCall));
-        if ((tryScope.functionReturned || catchScope.functionReturned) && returnedIdentifier) {
-            // Wrap catch in function if try or catch has return
-            const catchCall = lua.createCallExpression(lua.createFunctionExpression(catchBlock), []);
-            const catchAssign = lua.createAssignmentStatement([lua.cloneIdentifier(returnedIdentifier), lua.cloneIdentifier(returnValueIdentifier)], catchCall);
-            catchBlock = lua.createBlock([catchAssign]);
-        }
+        const catchCall = lua.createCallExpression(catchIdentifier, statement.catchClause.variableDeclaration ? [lua.cloneIdentifier(returnedIdentifier)] : []);
+        const catchCallStatement = hasReturn
+            ? lua.createAssignmentStatement([lua.cloneIdentifier(returnedIdentifier), lua.cloneIdentifier(returnValueIdentifier)], catchCall)
+            : lua.createExpressionStatement(catchCall);
         const notTryCondition = lua.createUnaryExpression(tryResultIdentifier, lua.SyntaxKind.NotOperator);
-        result.push(lua.createIfStatement(notTryCondition, catchBlock));
+        result.push(lua.createIfStatement(notTryCondition, lua.createBlock([catchCallStatement])));
     }
     else if (tryScope.functionReturned) {
         // try with return, but no catch
-        returnedIdentifier = lua.createIdentifier("____returned");
+        // returnedIdentifier = lua.createIdentifier("____returned");
         const returnedVariables = [tryResultIdentifier, returnedIdentifier, returnValueIdentifier];
         result.push(lua.createVariableDeclarationStatement(returnedVariables, tryCall));
         // change return condition from '____returned' to '____try and ____returned'
@@ -60,23 +71,14 @@ const transformTryStatement = (statement, context) => {
         result.push(...context.transformStatements(statement.finallyBlock));
     }
     if (returnCondition && returnedIdentifier) {
-        // With catch clause:
-        //     if ____returned then return ____returnValue end
-        // No catch clause:
-        //     if ____try and ____returned then return ____returnValue end
         const returnValues = [];
-        const parentTryCatch = scope_1.findScope(context, scope_1.ScopeType.Function | scope_1.ScopeType.Try | scope_1.ScopeType.Catch);
-        if (parentTryCatch && parentTryCatch.type !== scope_1.ScopeType.Function) {
-            // Nested try/catch needs to prefix a 'true' return value
-            returnValues.push(lua.createBooleanLiteral(true));
-        }
-        if (multi_1.isInMultiReturnFunction(context, statement)) {
-            returnValues.push(lua_ast_1.createUnpackCall(context, lua.cloneIdentifier(returnValueIdentifier)));
+        if ((0, multi_1.isInMultiReturnFunction)(context, statement)) {
+            returnValues.push((0, lua_ast_1.createUnpackCall)(context, lua.cloneIdentifier(returnValueIdentifier)));
         }
         else {
             returnValues.push(lua.cloneIdentifier(returnValueIdentifier));
         }
-        const returnStatement = lua.createReturnStatement(returnValues);
+        const returnStatement = (0, return_1.createReturnStatement)(context, returnValues, statement);
         const ifReturnedStatement = lua.createIfStatement(returnCondition, lua.createBlock([returnStatement]));
         result.push(ifReturnedStatement);
     }

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

@@ -0,0 +1,7 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+export declare function shouldMoveToTemp(context: TransformationContext, expression: lua.Expression, tsOriginal?: ts.Node): boolean;
+export declare function moveToPrecedingTemp(context: TransformationContext, expression: lua.Expression, tsOriginal?: ts.Node): lua.Expression;
+export declare function transformExpressionList(context: TransformationContext, expressions: readonly ts.Expression[]): lua.Expression[];
+export declare function transformOrderedExpressions(context: TransformationContext, expressions: readonly ts.Expression[]): lua.Expression[];

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

@@ -6,19 +6,23 @@ const lua = require("../../LuaAST");
 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) && table_1.isTableDeleteCall(context, expression)) {
-        return table_1.transformTableDeleteExpression(context, expression);
+    if (ts.isCallExpression(expression) && (0, table_1.isTableDeleteCall)(context, expression)) {
+        return (0, table_1.transformTableDeleteExpression)(context, expression);
     }
-    if (ts.isCallExpression(expression) && table_1.isTableSetCall(context, expression)) {
-        return table_1.transformTableSetExpression(context, expression);
+    if (ts.isCallExpression(expression) && (0, table_1.isTableSetCall)(context, expression)) {
+        return (0, table_1.transformTableSetExpression)(context, expression);
     }
-    const unaryExpressionResult = unary_expression_1.transformUnaryExpressionStatement(context, node);
+    if (ts.isVoidExpression(expression)) {
+        return (0, void_1.transformVoidExpressionStatement)(expression, context);
+    }
+    const unaryExpressionResult = (0, unary_expression_1.transformUnaryExpressionStatement)(context, node);
     if (unaryExpressionResult) {
         return unaryExpressionResult;
     }
-    const binaryExpressionResult = binary_expression_1.transformBinaryExpressionStatement(context, node);
+    const binaryExpressionResult = (0, binary_expression_1.transformBinaryExpressionStatement)(context, node);
     if (binaryExpressionResult) {
         return binaryExpressionResult;
     }

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,12 +35,45 @@ 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 = 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 = scope_1.performHoisting(context, context.transformStatements(body.statements));
+    const bodyStatements = (0, scope_1.performHoisting)(context, context.transformStatements(body.statements));
     return bodyStatements;
 }
 exports.transformFunctionBodyContent = transformFunctionBodyContent;
@@ -54,16 +90,18 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
                 headerStatements.push(transformParameterDefaultValueDeclaration(context, identifier, declaration.initializer));
             }
             // Binding pattern
-            bindingPatternDeclarations.push(...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
-            headerStatements.push(transformParameterDefaultValueDeclaration(context, identifier_1.transformIdentifier(context, declaration.name), declaration.initializer));
+            headerStatements.push(transformParameterDefaultValueDeclaration(context, (0, identifier_1.transformIdentifier)(context, declaration.name), declaration.initializer));
         }
     }
     // Push spread operator here
     if (spreadIdentifier && isRestParameterReferenced(spreadIdentifier, bodyScope)) {
-        const spreadTable = lua_ast_1.wrapInTable(lua.createDotsLiteral());
+        const spreadTable = (0, lua_ast_1.wrapInTable)(lua.createDotsLiteral());
         headerStatements.push(lua.createVariableDeclarationStatement(spreadIdentifier, spreadTable));
     }
     // Binding pattern statements need to be after spread table is declared
@@ -72,14 +110,14 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
 }
 exports.transformFunctionBodyHeader = transformFunctionBodyHeader;
 function transformFunctionBody(context, parameters, body, spreadIdentifier, node) {
-    const scope = scope_1.pushScope(context, scope_1.ScopeType.Function);
+    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
     scope.node = node;
     let bodyStatements = transformFunctionBodyContent(context, body);
-    if (node && async_await_1.isAsyncFunction(node)) {
-        bodyStatements = async_await_1.wrapInAsyncAwaiter(context, bodyStatements);
+    if (node && (0, async_await_1.isAsyncFunction)(node)) {
+        bodyStatements = (0, async_await_1.wrapInAsyncAwaiter)(context, bodyStatements);
     }
     const headerStatements = transformFunctionBodyHeader(context, scope, parameters, spreadIdentifier);
-    scope_1.popScope(context);
+    (0, scope_1.popScope)(context);
     return [[...headerStatements, ...bodyStatements], scope];
 }
 exports.transformFunctionBody = transformFunctionBody;
@@ -101,7 +139,7 @@ function transformParameters(context, parameters, functionContext) {
         // See transformFunctionBody for how these values are destructured
         const paramName = ts.isObjectBindingPattern(param.name) || ts.isArrayBindingPattern(param.name)
             ? lua.createIdentifier(`____bindingPattern${identifierIndex++}`)
-            : identifier_1.transformIdentifier(context, param.name);
+            : (0, identifier_1.transformIdentifier)(context, param.name);
         // This parameter is a spread parameter (...param)
         if (!param.dotDotDotToken) {
             paramNames.push(paramName);
@@ -116,10 +154,10 @@ function transformParameters(context, parameters, functionContext) {
 }
 exports.transformParameters = transformParameters;
 function transformFunctionToExpression(context, node) {
-    utils_1.assert(node.body);
+    (0, utils_1.assert)(node.body);
     const type = context.checker.getTypeAtLocation(node);
     let functionContext;
-    if (function_context_1.getFunctionContextType(context, type) !== function_context_1.ContextType.Void) {
+    if ((0, function_context_1.getFunctionContextType)(context, type) !== function_context_1.ContextType.Void) {
         if (ts.isArrowFunction(node)) {
             // dummy context for arrow functions with parameters
             if (node.parameters.length > 0) {
@@ -128,7 +166,7 @@ function transformFunctionToExpression(context, node) {
         }
         else {
             // self context
-            functionContext = lua_ast_1.createSelfIdentifier();
+            functionContext = (0, lua_ast_1.createSelfIdentifier)();
         }
     }
     let flags = lua.FunctionExpressionFlags.None;
@@ -142,7 +180,7 @@ function transformFunctionToExpression(context, node) {
     const functionExpression = lua.createFunctionExpression(lua.createBlock(transformedBody), paramNames, dotsLiteral, flags, node);
     return [
         node.asteriskToken
-            ? lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Generator, undefined, functionExpression)
+            ? (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Generator, undefined, functionExpression)
             : functionExpression,
         functionScope,
     ];
@@ -153,8 +191,8 @@ function transformFunctionLikeDeclaration(node, context) {
         // This code can be reached only from object methods, which is TypeScript error
         return lua.createNilLiteral();
     }
-    if (annotations_1.getNodeAnnotations(node).has(annotations_1.AnnotationKind.TupleReturn)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.TupleReturn));
+    if ((0, annotations_1.getNodeAnnotations)(node).has(annotations_1.AnnotationKind.TupleReturn)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
     const [functionExpression, functionScope] = transformFunctionToExpression(context, node);
     // Handle named function expressions which reference themselves
@@ -163,14 +201,19 @@ function transformFunctionLikeDeclaration(node, context) {
         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 = 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 lua_ast_1.createImmediatelyInvokedFunctionExpression([lua.createVariableDeclarationStatement(nameIdentifier, functionExpression)], lua.cloneIdentifier(nameIdentifier));
+                const nameIdentifier = (0, identifier_1.transformIdentifier)(context, node.name);
+                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);
             }
         }
     }
@@ -179,35 +222,39 @@ function transformFunctionLikeDeclaration(node, context) {
 exports.transformFunctionLikeDeclaration = transformFunctionLikeDeclaration;
 const transformFunctionDeclaration = (node, context) => {
     var _a;
-    if (annotations_1.getNodeAnnotations(node).has(annotations_1.AnnotationKind.TupleReturn)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.TupleReturn));
+    if ((0, annotations_1.getNodeAnnotations)(node).has(annotations_1.AnnotationKind.TupleReturn)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
     // Don't transform functions without body (overload declarations)
     if (node.body === undefined) {
         return undefined;
     }
-    if (export_1.hasDefaultExportModifier(node)) {
-        return lua.createAssignmentStatement(lua.createTableIndexExpression(lua_ast_1.createExportsIdentifier(), export_1.createDefaultExportStringLiteral(node)), transformFunctionLikeDeclaration(node, context));
+    if ((0, export_1.hasDefaultExportModifier)(node)) {
+        return lua.createAssignmentStatement(lua.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), (0, export_1.createDefaultExportStringLiteral)(node)), transformFunctionLikeDeclaration(node, context));
     }
     const [functionExpression, functionScope] = transformFunctionToExpression(context, node);
     // Name being undefined without default export is a TypeScript error
-    const name = node.name ? identifier_1.transformIdentifier(context, node.name) : lua.createAnonymousIdentifier();
+    const name = node.name ? (0, identifier_1.transformIdentifier)(context, node.name) : lua.createAnonymousIdentifier();
     // Remember symbols referenced in this function for hoisting later
     if (name.symbolId !== undefined) {
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         if (!scope.functionDefinitions) {
             scope.functionDefinitions = new Map();
         }
         const functionInfo = { referencedSymbols: (_a = functionScope.referencedSymbols) !== null && _a !== void 0 ? _a : new Map() };
         scope.functionDefinitions.set(name.symbolId, functionInfo);
     }
-    return 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) => {
     const parameters = expression.expression ? [context.transformExpression(expression.expression)] : [];
     return expression.asteriskToken
-        ? lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.DelegatedYield, expression, ...parameters)
+        ? (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.DelegatedYield, expression, ...parameters)
         : lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("coroutine"), lua.createStringLiteral("yield")), parameters, expression);
 };
 exports.transformYieldExpression = transformYieldExpression;