typescript-to-lua 1.2.0 → 1.3.0

package/dist/transformation/utils/language-extensions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExtensionValue = exports.isExtensionType = exports.ExtensionKind = void 0;
+exports.isExtensionValue = exports.getExtensionKinds = exports.isExtensionType = exports.ExtensionKind = void 0;
 var ExtensionKind;
 (function (ExtensionKind) {
     ExtensionKind["MultiFunction"] = "MultiFunction";
@@ -8,6 +8,7 @@ var ExtensionKind;
     ExtensionKind["RangeFunction"] = "RangeFunction";
     ExtensionKind["VarargConstant"] = "VarargConstant";
     ExtensionKind["IterableType"] = "IterableType";
+    ExtensionKind["PairsIterableType"] = "PairsIterableType";
     ExtensionKind["AdditionOperatorType"] = "AdditionOperatorType";
     ExtensionKind["AdditionOperatorMethodType"] = "AdditionOperatorMethodType";
     ExtensionKind["SubtractionOperatorType"] = "SubtractionOperatorType";
@@ -65,6 +66,7 @@ const extensionKindToTypeBrand = {
     [ExtensionKind.RangeFunction]: "__luaRangeFunctionBrand",
     [ExtensionKind.VarargConstant]: "__luaVarargConstantBrand",
     [ExtensionKind.IterableType]: "__luaIterableBrand",
+    [ExtensionKind.PairsIterableType]: "__luaPairsIterableBrand",
     [ExtensionKind.AdditionOperatorType]: "__luaAdditionBrand",
     [ExtensionKind.AdditionOperatorMethodType]: "__luaAdditionMethodBrand",
     [ExtensionKind.SubtractionOperatorType]: "__luaSubtractionBrand",
@@ -116,6 +118,10 @@ function isExtensionType(type, extensionKind) {
     return typeBrand !== undefined && type.getProperty(typeBrand) !== undefined;
 }
 exports.isExtensionType = isExtensionType;
+function getExtensionKinds(type) {
+    return Object.keys(extensionKindToTypeBrand).filter(e => type.getProperty(extensionKindToTypeBrand[e]) !== undefined);
+}
+exports.getExtensionKinds = getExtensionKinds;
 function isExtensionValue(context, symbol, extensionKind) {
     var _a;
     return (symbol.getName() === extensionKindToValueName[extensionKind] &&

package/dist/transformation/utils/lua-ast.js

@@ -119,7 +119,9 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
         const scope = (0, scope_1.peekScope)(context);
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
         if (context.isModule || !isTopLevelVariable) {
-            if (!isFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
+            const isLuaFunctionExpression = rhs && !Array.isArray(rhs) && lua.isFunctionExpression(rhs);
+            const isSafeRecursiveFunctionDeclaration = isFunctionDeclaration && isLuaFunctionExpression;
+            if (!isSafeRecursiveFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
                 // Split declaration and assignment of identifiers that reference themselves in their declaration.
                 // Put declaration above preceding statements in case the identifier is referenced in those.
                 const precedingDeclaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
@@ -127,10 +129,8 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
                 if (rhs) {
                     assignment = lua.createAssignmentStatement(lhs, rhs, tsOriginal);
                 }
-                if (!isFunctionDeclaration) {
-                    // Remember local variable declarations for hoisting later
-                    (0, scope_1.addScopeVariableDeclaration)(scope, precedingDeclaration);
-                }
+                // Remember local variable declarations for hoisting later
+                (0, scope_1.addScopeVariableDeclaration)(scope, precedingDeclaration);
             }
             else {
                 declaration = lua.createVariableDeclarationStatement(lhs, rhs, tsOriginal);

package/dist/transformation/utils/safe-names.d.ts

@@ -1,8 +1,10 @@
 import * as ts from "typescript";
+import { CompilerOptions } from "../..";
 import { TransformationContext } from "../context";
-export declare const isValidLuaIdentifier: (name: string) => boolean;
+export declare const shouldAllowUnicode: (options: CompilerOptions) => boolean;
+export declare const isValidLuaIdentifier: (name: string, options: CompilerOptions) => boolean;
 export declare const luaKeywords: ReadonlySet<string>;
-export declare const isUnsafeName: (name: string) => boolean;
+export declare const isUnsafeName: (name: string, options: CompilerOptions) => boolean;
 export declare function hasUnsafeSymbolName(context: TransformationContext, symbol: ts.Symbol, tsOriginal: ts.Identifier): boolean;
 export declare function hasUnsafeIdentifierName(context: TransformationContext, identifier: ts.Identifier, checkSymbol?: boolean): boolean;
 export declare const createSafeName: (name: string) => string;

package/dist/transformation/utils/safe-names.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSafeName = exports.hasUnsafeIdentifierName = exports.hasUnsafeSymbolName = exports.isUnsafeName = exports.luaKeywords = exports.isValidLuaIdentifier = void 0;
+exports.createSafeName = exports.hasUnsafeIdentifierName = exports.hasUnsafeSymbolName = exports.isUnsafeName = exports.luaKeywords = exports.isValidLuaIdentifier = exports.shouldAllowUnicode = void 0;
+const __1 = require("../..");
 const diagnostics_1 = require("./diagnostics");
 const export_1 = require("./export");
 const typescript_1 = require("./typescript");
-const isValidLuaIdentifier = (name) => !exports.luaKeywords.has(name) && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+const shouldAllowUnicode = (options) => options.luaTarget === __1.LuaTarget.LuaJIT;
+exports.shouldAllowUnicode = shouldAllowUnicode;
+const isValidLuaIdentifier = (name, options) => !exports.luaKeywords.has(name) &&
+    ((0, exports.shouldAllowUnicode)(options)
+        ? /^[a-zA-Z_\u007F-\uFFFD][a-zA-Z0-9_\u007F-\uFFFD]*$/
+        : /^[a-zA-Z_][a-zA-Z0-9_]*$/).test(name);
 exports.isValidLuaIdentifier = isValidLuaIdentifier;
 exports.luaKeywords = new Set([
     "and",
@@ -51,10 +57,10 @@ const luaBuiltins = new Set([
     "type",
     "unpack",
 ]);
-const isUnsafeName = (name) => !(0, exports.isValidLuaIdentifier)(name) || luaBuiltins.has(name);
+const isUnsafeName = (name, options) => !(0, exports.isValidLuaIdentifier)(name, options) || luaBuiltins.has(name);
 exports.isUnsafeName = isUnsafeName;
 function checkName(context, name, node) {
-    const isInvalid = !(0, exports.isValidLuaIdentifier)(name);
+    const isInvalid = !(0, exports.isValidLuaIdentifier)(name, context.options);
     if (isInvalid) {
         // Empty identifier is a TypeScript error
         if (name !== "") {
@@ -71,7 +77,7 @@ function hasUnsafeSymbolName(context, symbol, tsOriginal) {
         return true;
     }
     // only unsafe when non-ambient and not exported
-    return (0, exports.isUnsafeName)(symbol.name) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
+    return (0, exports.isUnsafeName)(symbol.name, context.options) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
 }
 exports.hasUnsafeSymbolName = hasUnsafeSymbolName;
 function hasUnsafeIdentifierName(context, identifier, checkSymbol = true) {

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

@@ -9,7 +9,8 @@ export declare enum ScopeType {
     Conditional = 16,
     Block = 32,
     Try = 64,
-    Catch = 128
+    Catch = 128,
+    LoopInitializer = 256
 }
 interface FunctionDefinitionInfo {
     referencedSymbols: Map<lua.SymbolId, ts.Node[]>;

package/dist/transformation/utils/scope.js

@@ -16,6 +16,7 @@ var ScopeType;
     ScopeType[ScopeType["Block"] = 32] = "Block";
     ScopeType[ScopeType["Try"] = 64] = "Try";
     ScopeType[ScopeType["Catch"] = 128] = "Catch";
+    ScopeType[ScopeType["LoopInitializer"] = 256] = "LoopInitializer";
 })(ScopeType = exports.ScopeType || (exports.ScopeType = {}));
 const scopeStacks = new WeakMap();
 function getScopeStack(context) {

package/dist/transformation/utils/typescript/types.d.ts

@@ -10,4 +10,6 @@ export declare function isNumberType(context: TransformationContext, type: ts.Ty
  */
 export declare function forTypeOrAnySupertype(context: TransformationContext, type: ts.Type, predicate: (type: ts.Type) => boolean): boolean;
 export declare function isArrayType(context: TransformationContext, type: ts.Type): boolean;
-export declare function isFunctionType(context: TransformationContext, type: ts.Type): boolean;
+export declare function isFunctionType(type: ts.Type): boolean;
+export declare function canBeFalsy(context: TransformationContext, type: ts.Type): boolean;
+export declare function canBeFalsyWhenNotNull(context: TransformationContext, type: ts.Type): boolean;

package/dist/transformation/utils/typescript/types.js

@@ -1,21 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
+exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
 const ts = require("typescript");
 function isTypeWithFlags(context, type, flags) {
-    const predicate = (type) => {
-        if (type.symbol) {
-            const baseConstraint = context.checker.getBaseConstraintOfType(type);
-            if (baseConstraint && baseConstraint !== type) {
-                return isTypeWithFlags(context, baseConstraint, flags);
-            }
-        }
-        return (type.flags & flags) !== 0;
-    };
+    const predicate = (type) => (type.flags & flags) !== 0;
     return typeAlwaysSatisfies(context, type, predicate);
 }
 exports.isTypeWithFlags = isTypeWithFlags;
 function typeAlwaysSatisfies(context, type, predicate) {
+    const baseConstraint = context.checker.getBaseConstraintOfType(type);
+    if (baseConstraint) {
+        type = baseConstraint;
+    }
     if (predicate(type)) {
         return true;
     }
@@ -29,6 +25,15 @@ function typeAlwaysSatisfies(context, type, predicate) {
 }
 exports.typeAlwaysSatisfies = typeAlwaysSatisfies;
 function typeCanSatisfy(context, type, predicate) {
+    const baseConstraint = context.checker.getBaseConstraintOfType(type);
+    if (!baseConstraint) {
+        // type parameter with no constraint can be anything, assume it might satisfy predicate
+        if (type.isTypeParameter())
+            return true;
+    }
+    else {
+        type = baseConstraint;
+    }
     if (predicate(type)) {
         return true;
     }
@@ -84,9 +89,31 @@ function isArrayType(context, type) {
     return forTypeOrAnySupertype(context, type, t => isExplicitArrayType(context, t));
 }
 exports.isArrayType = isArrayType;
-function isFunctionType(context, type) {
-    const typeNode = context.checker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.InTypeAlias);
-    return typeNode !== undefined && ts.isFunctionTypeNode(typeNode);
+function isFunctionType(type) {
+    return type.getCallSignatures().length > 0;
 }
 exports.isFunctionType = isFunctionType;
+function canBeFalsy(context, type) {
+    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
+    const falsyFlags = ts.TypeFlags.Boolean |
+        ts.TypeFlags.BooleanLiteral |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Any |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Null;
+    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0 || (!strictNullChecks && !type.isLiteral()));
+}
+exports.canBeFalsy = canBeFalsy;
+function canBeFalsyWhenNotNull(context, type) {
+    const falsyFlags = ts.TypeFlags.Boolean |
+        ts.TypeFlags.BooleanLiteral |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Any;
+    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0);
+}
+exports.canBeFalsyWhenNotNull = canBeFalsyWhenNotNull;
 //# sourceMappingURL=types.js.map

package/dist/transformation/visitors/binary-expression/index.js

@@ -167,9 +167,7 @@ exports.transformBinaryExpressionStatement = transformBinaryExpressionStatement;
 function transformNullishCoalescingOperationNoPrecedingStatements(context, node, transformedLeft, transformedRight) {
     const lhsType = context.checker.getTypeAtLocation(node.left);
     // Check if we can take a shortcut to 'lhs or rhs' if the left-hand side cannot be 'false'.
-    const typeCanBeFalse = (type) => (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Boolean)) !== 0 ||
-        (type.flags & ts.TypeFlags.BooleanLiteral & ts.TypeFlags.PossiblyFalsy) !== 0;
-    if ((0, typescript_1.typeCanSatisfy)(context, lhsType, typeCanBeFalse)) {
+    if ((0, typescript_1.canBeFalsyWhenNotNull)(context, lhsType)) {
         // reuse logic from case with preceding statements
         const [precedingStatements, result] = createShortCircuitBinaryExpressionPrecedingStatements(context, transformedLeft, transformedRight, [], ts.SyntaxKind.QuestionQuestionToken, node);
         context.addPrecedingStatements(precedingStatements);

package/dist/transformation/visitors/call.js

@@ -86,7 +86,7 @@ function transformContextualCallExpression(context, node, args, signature) {
     let [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
     if (ts.isPropertyAccessExpression(left) &&
         ts.isIdentifier(left.name) &&
-        (0, safe_names_1.isValidLuaIdentifier)(left.name.text) &&
+        (0, safe_names_1.isValidLuaIdentifier)(left.name.text, context.options) &&
         argPrecedingStatements.length === 0) {
         // table:name()
         const table = context.transformExpression(left.expression);

package/dist/transformation/visitors/class/index.js

@@ -70,7 +70,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
     const instanceFields = properties.filter(prop => !(0, utils_2.isStaticNode)(prop));
     const result = [];
     let localClassName;
-    if ((0, safe_names_1.isUnsafeName)(className.text)) {
+    if ((0, safe_names_1.isUnsafeName)(className.text, context.options)) {
         localClassName = lua.createIdentifier((0, safe_names_1.createSafeName)(className.text), undefined, className.symbolId, className.text);
         lua.setNodePosition(localClassName, className);
     }

package/dist/transformation/visitors/conditional.js

@@ -6,28 +6,7 @@ const lua = require("../../LuaAST");
 const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const block_1 = require("./block");
-function canBeFalsy(context, type) {
-    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
-    const falsyFlags = ts.TypeFlags.Boolean |
-        ts.TypeFlags.BooleanLiteral |
-        ts.TypeFlags.Undefined |
-        ts.TypeFlags.Null |
-        ts.TypeFlags.Never |
-        ts.TypeFlags.Void |
-        ts.TypeFlags.Any;
-    if (type.flags & falsyFlags) {
-        return true;
-    }
-    else if (!strictNullChecks && !type.isLiteral()) {
-        return true;
-    }
-    else if (type.isUnion()) {
-        return type.types.some(subType => canBeFalsy(context, subType));
-    }
-    else {
-        return false;
-    }
-}
+const typescript_1 = require("../utils/typescript");
 function transformProtectedConditionalExpression(context, expression) {
     const tempVar = context.createTempNameForNode(expression.condition);
     const condition = context.transformExpression(expression.condition);
@@ -42,7 +21,7 @@ function transformProtectedConditionalExpression(context, expression) {
     return lua.cloneIdentifier(tempVar);
 }
 const transformConditionalExpression = (expression, context) => {
-    if (canBeFalsy(context, context.checker.getTypeAtLocation(expression.whenTrue))) {
+    if ((0, typescript_1.canBeFalsy)(context, context.checker.getTypeAtLocation(expression.whenTrue))) {
         return transformProtectedConditionalExpression(context, expression);
     }
     const condition = context.transformExpression(expression.condition);

package/dist/transformation/visitors/errors.js

@@ -12,6 +12,7 @@ const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const return_1 = require("./return");
 const transformTryStatement = (statement, context) => {
+    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));
@@ -34,24 +35,25 @@ const transformTryStatement = (statement, context) => {
         const catchParameter = statement.catchClause.variableDeclaration
             ? (0, identifier_1.transformIdentifier)(context, statement.catchClause.variableDeclaration.name)
             : undefined;
-        const catchParameters = () => (catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
+        const catchFunction = lua.createFunctionExpression(catchBlock, catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
         const catchIdentifier = lua.createIdentifier("____catch");
-        const catchFunction = lua.createFunctionExpression(catchBlock, catchParameters());
         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));
-        // Wrap catch in function if try or catch has return
-        const catchCall = lua.createCallExpression(catchIdentifier, [lua.cloneIdentifier(returnedIdentifier)]);
-        const catchAssign = lua.createAssignmentStatement([lua.cloneIdentifier(returnedIdentifier), lua.cloneIdentifier(returnValueIdentifier)], catchCall);
+        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, lua.createBlock([catchAssign])));
+        result.push(lua.createIfStatement(notTryCondition, lua.createBlock([catchCallStatement])));
     }
     else if (tryScope.functionReturned) {
         // try with return, but no catch

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
@@ -167,7 +204,15 @@ 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);
             }
         }
@@ -199,7 +244,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/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/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);
     }