typescript-to-lua 1.1.1 → 1.3.2

package/dist/transformation/builtins/array.js

@@ -22,8 +22,7 @@ exports.transformArrayConstructorCall = transformArrayConstructorCall;
 function transformArrayPrototypeCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "concat":

package/dist/transformation/builtins/function.js

@@ -15,8 +15,7 @@ function transformFunctionPrototypeCall(context, node) {
         context.diagnostics.push((0, diagnostics_1.unsupportedSelfFunctionConversion)(node));
     }
     const signature = context.checker.getResolvedSignature(node);
-    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "apply":
@@ -25,7 +24,7 @@ function transformFunctionPrototypeCall(context, node) {
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.FunctionBind, node, caller, ...params);
         case "call":
             return lua.createCallExpression(caller, params, node);
-        default:
+        case "toString":
             context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "function", expressionName));
     }
 }
@@ -43,7 +42,10 @@ function transformFunctionProperty(context, node) {
             return contextType === function_context_1.ContextType.NonVoid
                 ? lua.createBinaryExpression(nparams, lua.createNumericLiteral(1), lua.SyntaxKind.SubtractionOperator)
                 : nparams;
-        default:
+        case "arguments":
+        case "caller":
+        case "displayName":
+        case "name":
             context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node.name, "function", node.name.text));
     }
 }

package/dist/transformation/builtins/index.d.ts

@@ -2,5 +2,5 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 export declare function transformBuiltinPropertyAccessExpression(context: TransformationContext, node: ts.PropertyAccessExpression): lua.Expression | undefined;
-export declare function transformBuiltinCallExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression | undefined;
+export declare function transformBuiltinCallExpression(context: TransformationContext, node: ts.CallExpression, isOptionalCall: boolean): lua.Expression | undefined;
 export declare function transformBuiltinIdentifierExpression(context: TransformationContext, node: ts.Identifier): lua.Expression | undefined;

package/dist/transformation/builtins/index.js

@@ -19,6 +19,7 @@ const object_1 = require("./object");
 const promise_1 = require("./promise");
 const string_1 = require("./string");
 const symbol_1 = require("./symbol");
+const diagnostics_1 = require("../utils/diagnostics");
 function transformBuiltinPropertyAccessExpression(context, node) {
     const ownerType = context.checker.getTypeAtLocation(node.expression);
     if ((0, typescript_1.isStringType)(context, ownerType)) {
@@ -27,7 +28,7 @@ function transformBuiltinPropertyAccessExpression(context, node) {
     if ((0, typescript_1.isArrayType)(context, ownerType)) {
         return (0, array_1.transformArrayProperty)(context, node);
     }
-    if ((0, typescript_1.isFunctionType)(context, ownerType)) {
+    if ((0, typescript_1.isFunctionType)(ownerType)) {
         return (0, function_1.transformFunctionProperty)(context, node);
     }
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
@@ -40,57 +41,91 @@ function transformBuiltinPropertyAccessExpression(context, node) {
     }
 }
 exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAccessExpression;
-function transformBuiltinCallExpression(context, node) {
+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;
         }
     }
-    if (!ts.isPropertyAccessExpression(node.expression)) {
+    const expression = ts.getOriginalNode(node.expression);
+    if (!ts.isPropertyAccessExpression(expression)) {
         return;
     }
+    const isOptionalAccess = expression.questionDotToken;
     (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(node.expression.expression);
+    const ownerType = context.checker.getTypeAtLocation(expression.expression);
     if ((0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
         const symbol = ownerType.getSymbol();
         switch (symbol === null || symbol === void 0 ? void 0 : symbol.name) {
             case "ArrayConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, array_1.transformArrayConstructorCall)(context, node);
             case "Console":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, console_1.transformConsoleCall)(context, node);
             case "Math":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, math_1.transformMathCall)(context, node);
             case "StringConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, string_1.transformStringConstructorCall)(context, node);
             case "ObjectConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, object_1.transformObjectConstructorCall)(context, node);
             case "SymbolConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, symbol_1.transformSymbolConstructorCall)(context, node);
             case "NumberConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, number_1.transformNumberConstructorCall)(context, node);
             case "PromiseConstructor":
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
                 return (0, promise_1.transformPromiseConstructorCall)(context, node);
         }
     }
     if ((0, typescript_1.isStringType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return (0, string_1.transformStringPrototypeCall)(context, node);
     }
     if ((0, typescript_1.isNumberType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return (0, number_1.transformNumberPrototypeCall)(context, node);
     }
     if ((0, typescript_1.isArrayType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return (0, array_1.transformArrayPrototypeCall)(context, node);
     }
-    if ((0, typescript_1.isFunctionType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+    if ((0, typescript_1.isFunctionType)(ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return (0, function_1.transformFunctionPrototypeCall)(context, node);
     }
-    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node);
+    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node, expression);
     if (objectResult) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return objectResult;
     }
 }

package/dist/transformation/builtins/math.js

@@ -57,6 +57,10 @@ function transformMathCall(context, node) {
             const add = lua.createBinaryExpression(one, params[0], lua.SyntaxKind.AdditionOperator);
             return lua.createCallExpression(lua.createTableIndexExpression(math, log), [add], node);
         }
+        case "pow": {
+            // Translate to base ^ power
+            return lua.createBinaryExpression(params[0], params[1], lua.SyntaxKind.PowerOperator, node);
+        }
         // math.floor(x + 0.5)
         case "round": {
             const floor = lua.createStringLiteral("floor");
@@ -64,6 +68,9 @@ function transformMathCall(context, node) {
             const add = lua.createBinaryExpression(params[0], half, lua.SyntaxKind.AdditionOperator);
             return lua.createCallExpression(lua.createTableIndexExpression(math, floor), [add], node);
         }
+        case "sign": {
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.MathSign, node, ...params);
+        }
         case "abs":
         case "acos":
         case "asin":
@@ -75,7 +82,6 @@ function transformMathCall(context, node) {
         case "log":
         case "max":
         case "min":
-        case "pow":
         case "random":
         case "sin":
         case "sqrt":

package/dist/transformation/builtins/object.d.ts

@@ -1,5 +1,6 @@
 import * as lua from "../../LuaAST";
+import * as ts from "typescript";
 import { TransformationContext } from "../context";
 import { PropertyCallExpression } from "../visitors/call";
 export declare function transformObjectConstructorCall(context: TransformationContext, expression: PropertyCallExpression): lua.Expression | undefined;
-export declare function transformObjectPrototypeCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformObjectPrototypeCall(context: TransformationContext, node: ts.CallExpression, expression: ts.PropertyAccessExpression): lua.Expression | undefined;

package/dist/transformation/builtins/object.js

@@ -31,8 +31,7 @@ function transformObjectConstructorCall(context, expression) {
     }
 }
 exports.transformObjectConstructorCall = transformObjectConstructorCall;
-function transformObjectPrototypeCall(context, node) {
-    const expression = node.expression;
+function transformObjectPrototypeCall(context, node, expression) {
     const signature = context.checker.getResolvedSignature(node);
     const name = expression.name.text;
     switch (name) {

package/dist/transformation/builtins/string.js

@@ -13,8 +13,7 @@ function createStringCall(methodName, tsOriginal, ...params) {
 function transformStringPrototypeCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "replace":

package/dist/transformation/context/context.d.ts

@@ -2,6 +2,7 @@ import * as ts from "typescript";
 import { CompilerOptions, LuaTarget } from "../../CompilerOptions";
 import * as lua from "../../LuaAST";
 import { ExpressionLikeNode, StatementLikeNode, VisitorMap } from "./visitors";
+export declare const tempSymbolId: lua.SymbolId;
 export interface AllAccessorDeclarations {
     firstAccessor: ts.AccessorDeclaration;
     secondAccessor: ts.AccessorDeclaration | undefined;
@@ -25,16 +26,27 @@ export declare class TransformationContext {
     readonly diagnostics: ts.Diagnostic[];
     readonly checker: DiagnosticsProducingTypeChecker;
     readonly resolver: EmitResolver;
+    readonly precedingStatementsStack: lua.Statement[][];
     readonly options: CompilerOptions;
     readonly luaTarget: LuaTarget;
     readonly isModule: boolean;
     readonly isStrict: boolean;
     constructor(program: ts.Program, sourceFile: ts.SourceFile, visitorMap: VisitorMap);
     private currentNodeVisitors;
+    private nextTempId;
     transformNode(node: ts.Node): lua.Node[];
     superTransformNode(node: ts.Node): lua.Node[];
     transformExpression(node: ExpressionLikeNode): lua.Expression;
     superTransformExpression(node: ExpressionLikeNode): lua.Expression;
     transformStatements(node: StatementLikeNode | readonly StatementLikeNode[]): lua.Statement[];
     superTransformStatements(node: StatementLikeNode | readonly StatementLikeNode[]): lua.Statement[];
+    pushPrecedingStatements(): void;
+    popPrecedingStatements(): lua.Statement[];
+    addPrecedingStatements(statements: lua.Statement | lua.Statement[]): void;
+    prependPrecedingStatements(statements: lua.Statement | lua.Statement[]): void;
+    createTempName(prefix?: string): string;
+    private getTempNameForLuaExpression;
+    createTempNameForLuaExpression(expression: lua.Expression): lua.Identifier;
+    private getTempNameForNode;
+    createTempNameForNode(node: ts.Node): lua.Identifier;
 }

package/dist/transformation/context/context.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransformationContext = void 0;
+exports.TransformationContext = exports.tempSymbolId = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
 const diagnostics_1 = require("../utils/diagnostics");
 const lua_ast_1 = require("../utils/lua-ast");
+const safe_names_1 = require("../utils/safe-names");
+exports.tempSymbolId = -1;
 class TransformationContext {
     constructor(program, sourceFile, visitorMap) {
         var _a, _b, _c;
@@ -15,12 +17,14 @@ class TransformationContext {
         this.visitorMap = visitorMap;
         this.diagnostics = [];
         this.checker = this.program.getDiagnosticsProducingTypeChecker();
+        this.precedingStatementsStack = [];
         this.options = this.program.getCompilerOptions();
         this.luaTarget = (_a = this.options.luaTarget) !== null && _a !== void 0 ? _a : CompilerOptions_1.LuaTarget.Universal;
         this.isModule = ts.isExternalModule(this.sourceFile);
         this.isStrict = ((_b = this.options.alwaysStrict) !== null && _b !== void 0 ? _b : this.options.strict) ||
             (this.isModule && this.options.target !== undefined && this.options.target >= ts.ScriptTarget.ES2015);
         this.currentNodeVisitors = [];
+        this.nextTempId = 0;
         // Use `getParseTreeNode` to get original SourceFile node, before it was substituted by custom transformers.
         // It's required because otherwise `getEmitResolver` won't use cached diagnostics, produced in `emitWorker`
         // and would try to re-analyze the file, which would fail because of replaced nodes.
@@ -67,10 +71,105 @@ class TransformationContext {
         return result;
     }
     transformStatements(node) {
-        return (0, utils_1.castArray)(node).flatMap(n => this.transformNode(n));
+        return (0, utils_1.castArray)(node).flatMap(n => {
+            this.pushPrecedingStatements();
+            const statements = this.transformNode(n);
+            statements.unshift(...this.popPrecedingStatements());
+            return statements;
+        });
     }
     superTransformStatements(node) {
-        return (0, utils_1.castArray)(node).flatMap(n => this.superTransformNode(n));
+        return (0, utils_1.castArray)(node).flatMap(n => {
+            this.pushPrecedingStatements();
+            const statements = this.superTransformNode(n);
+            statements.unshift(...this.popPrecedingStatements());
+            return statements;
+        });
+    }
+    pushPrecedingStatements() {
+        this.precedingStatementsStack.push([]);
+    }
+    popPrecedingStatements() {
+        const precedingStatements = this.precedingStatementsStack.pop();
+        (0, utils_1.assert)(precedingStatements);
+        return precedingStatements;
+    }
+    addPrecedingStatements(statements) {
+        const precedingStatements = this.precedingStatementsStack[this.precedingStatementsStack.length - 1];
+        (0, utils_1.assert)(precedingStatements);
+        if (!Array.isArray(statements)) {
+            statements = [statements];
+        }
+        precedingStatements.push(...statements);
+    }
+    prependPrecedingStatements(statements) {
+        const precedingStatements = this.precedingStatementsStack[this.precedingStatementsStack.length - 1];
+        (0, utils_1.assert)(precedingStatements);
+        if (!Array.isArray(statements)) {
+            statements = [statements];
+        }
+        precedingStatements.unshift(...statements);
+    }
+    createTempName(prefix = "temp") {
+        prefix = prefix.replace(/^_*/, ""); // Strip leading underscores because createSafeName will add them again
+        return (0, safe_names_1.createSafeName)(`${prefix}_${this.nextTempId++}`);
+    }
+    getTempNameForLuaExpression(expression) {
+        if (lua.isStringLiteral(expression)) {
+            return expression.value;
+        }
+        else if (lua.isNumericLiteral(expression)) {
+            return `_${expression.value.toString()}`;
+        }
+        else if (lua.isIdentifier(expression)) {
+            return expression.text;
+        }
+        else if (lua.isCallExpression(expression)) {
+            const name = this.getTempNameForLuaExpression(expression.expression);
+            if (name) {
+                return `${name}_result`;
+            }
+        }
+        else if (lua.isTableIndexExpression(expression)) {
+            const tableName = this.getTempNameForLuaExpression(expression.table);
+            const indexName = this.getTempNameForLuaExpression(expression.index);
+            if (tableName || indexName) {
+                return `${tableName !== null && tableName !== void 0 ? tableName : "table"}_${indexName !== null && indexName !== void 0 ? indexName : "index"}`;
+            }
+        }
+    }
+    createTempNameForLuaExpression(expression) {
+        const name = this.getTempNameForLuaExpression(expression);
+        const identifier = lua.createIdentifier(this.createTempName(name), undefined, exports.tempSymbolId);
+        lua.setNodePosition(identifier, lua.getOriginalPos(expression));
+        return identifier;
+    }
+    getTempNameForNode(node) {
+        if (ts.isStringLiteral(node) || ts.isIdentifier(node) || ts.isMemberName(node)) {
+            return node.text;
+        }
+        else if (ts.isNumericLiteral(node)) {
+            return `_${node.text}`;
+        }
+        else if (ts.isCallExpression(node)) {
+            const name = this.getTempNameForNode(node.expression);
+            if (name) {
+                return `${name}_result`;
+            }
+        }
+        else if (ts.isElementAccessExpression(node) || ts.isPropertyAccessExpression(node)) {
+            const tableName = this.getTempNameForNode(node.expression);
+            const indexName = ts.isElementAccessExpression(node)
+                ? this.getTempNameForNode(node.argumentExpression)
+                : node.name.text;
+            if (tableName || indexName) {
+                return `${tableName !== null && tableName !== void 0 ? tableName : "table"}_${indexName !== null && indexName !== void 0 ? indexName : "index"}`;
+            }
+        }
+    }
+    createTempNameForNode(node) {
+        const name = this.getTempNameForNode(node);
+        return lua.createIdentifier(this.createTempName(name), node, exports.tempSymbolId);
     }
 }
 exports.TransformationContext = TransformationContext;

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

@@ -34,6 +34,9 @@ export declare const invalidRangeControlVariable: ((node: ts.Node, ...args: any[
 export declare const invalidMultiIterableWithoutDestructuring: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
+export declare const invalidPairsIterableWithoutDestructuring: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};
 export declare const unsupportedAccessorInObjectLiteral: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
@@ -73,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;
 };
@@ -91,3 +88,9 @@ export declare const notAllowedOptionalAssignment: ((node: ts.Node, ...args: any
 export declare const awaitMustBeInAsyncFunction: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
+export declare const unsupportedBuiltinOptionalCall: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};
+export declare const unsupportedOptionalCompileMembersOnly: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+    code: number;
+};

package/dist/transformation/utils/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.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");
@@ -36,6 +36,7 @@ exports.invalidRangeUse = createErrorDiagnosticFactory("$range can only be used
 exports.invalidVarargUse = createErrorDiagnosticFactory("$vararg can only be used in a spread element ('...$vararg') in global scope.");
 exports.invalidRangeControlVariable = createErrorDiagnosticFactory("For loop using $range must declare a single control variable.");
 exports.invalidMultiIterableWithoutDestructuring = createErrorDiagnosticFactory("LuaIterable with a LuaMultiReturn return value type must be destructured.");
+exports.invalidPairsIterableWithoutDestructuring = createErrorDiagnosticFactory("LuaPairsIterable type must be destructured in a for...of statement.");
 exports.unsupportedAccessorInObjectLiteral = createErrorDiagnosticFactory("Accessors in object literal are not supported.");
 exports.unsupportedRightShiftOperator = createErrorDiagnosticFactory("Right shift operator is not supported for target Lua 5.3. Use `>>>` instead.");
 const getLuaTargetName = (version) => (version === CompilerOptions_1.LuaTarget.LuaJIT ? "LuaJIT" : `Lua ${version}`);
@@ -50,12 +51,12 @@ 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. ` +
     `See https://typescripttolua.github.io/docs/advanced/compiler-annotations#${kind.toLowerCase()} for more information.`);
 exports.notAllowedOptionalAssignment = createErrorDiagnosticFactory("The left-hand side of an assignment expression may not be an optional property access.");
 exports.awaitMustBeInAsyncFunction = createErrorDiagnosticFactory("Await can only be used inside async functions.");
+exports.unsupportedBuiltinOptionalCall = createErrorDiagnosticFactory("Optional calls are not supported for builtin or language extension functions.");
+exports.unsupportedOptionalCompileMembersOnly = createErrorDiagnosticFactory("Optional calls are not supported on enums marked with @compileMembersOnly.");
 //# sourceMappingURL=diagnostics.js.map

package/dist/transformation/utils/language-extensions.d.ts

@@ -6,6 +6,7 @@ export declare enum ExtensionKind {
     RangeFunction = "RangeFunction",
     VarargConstant = "VarargConstant",
     IterableType = "IterableType",
+    PairsIterableType = "PairsIterableType",
     AdditionOperatorType = "AdditionOperatorType",
     AdditionOperatorMethodType = "AdditionOperatorMethodType",
     SubtractionOperatorType = "SubtractionOperatorType",
@@ -53,4 +54,5 @@ export declare enum ExtensionKind {
     TableSetMethodType = "TableSetMethodType"
 }
 export declare function isExtensionType(type: ts.Type, extensionKind: ExtensionKind): boolean;
+export declare function getExtensionKinds(type: ts.Type): ExtensionKind[];
 export declare function isExtensionValue(context: TransformationContext, symbol: ts.Symbol, extensionKind: ExtensionKind): boolean;

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.d.ts

@@ -7,7 +7,6 @@ export declare function createSelfIdentifier(tsOriginal?: ts.Node): lua.Identifi
 export declare function createExportsIdentifier(): lua.Identifier;
 export declare function addToNumericExpression(expression: lua.Expression, change: number): lua.Expression;
 export declare function getNumberLiteralValue(expression?: lua.Expression): number | undefined;
-export declare function createImmediatelyInvokedFunctionExpression(statements: lua.Statement[], result: lua.Expression | lua.Expression[], tsOriginal?: ts.Node): lua.CallExpression;
 export declare function createUnpackCall(context: TransformationContext, expression: lua.Expression, tsOriginal?: ts.Node): lua.Expression;
 export declare function wrapInTable(...expressions: lua.Expression[]): lua.TableExpression;
 export declare function wrapInToStringForConcat(expression: lua.Expression): lua.Expression;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNaN = exports.createLocalOrExportedOrGlobalDeclaration = exports.createHoistableVariableDeclarationStatement = exports.wrapInToStringForConcat = exports.wrapInTable = exports.createUnpackCall = exports.createImmediatelyInvokedFunctionExpression = exports.getNumberLiteralValue = exports.addToNumericExpression = exports.createExportsIdentifier = exports.createSelfIdentifier = exports.unwrapVisitorResult = void 0;
+exports.createNaN = exports.createLocalOrExportedOrGlobalDeclaration = exports.createHoistableVariableDeclarationStatement = exports.wrapInToStringForConcat = exports.wrapInTable = exports.createUnpackCall = exports.getNumberLiteralValue = exports.addToNumericExpression = exports.createExportsIdentifier = exports.createSelfIdentifier = exports.unwrapVisitorResult = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const lua = require("../../LuaAST");
@@ -55,15 +55,6 @@ function getNumberLiteralValue(expression) {
     return undefined;
 }
 exports.getNumberLiteralValue = getNumberLiteralValue;
-// Prefer use of transformToImmediatelyInvokedFunctionExpression to maintain correct scope. If you use this directly,
-// ensure you push/pop a function scope appropriately to avoid incorrect vararg optimization.
-function createImmediatelyInvokedFunctionExpression(statements, result, tsOriginal) {
-    const body = [...statements, lua.createReturnStatement((0, utils_1.castArray)(result))];
-    const flags = statements.length === 0 ? lua.FunctionExpressionFlags.Inline : lua.FunctionExpressionFlags.None;
-    const iife = lua.createFunctionExpression(lua.createBlock(body), undefined, undefined, flags);
-    return lua.createCallExpression(iife, [], tsOriginal);
-}
-exports.createImmediatelyInvokedFunctionExpression = createImmediatelyInvokedFunctionExpression;
 function createUnpackCall(context, expression, tsOriginal) {
     if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
         return (0, lualib_1.transformLuaLibFunction)(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
@@ -93,10 +84,7 @@ function createHoistableVariableDeclarationStatement(context, identifier, initia
     if (identifier.symbolId !== undefined) {
         const scope = (0, scope_1.peekScope)(context);
         (0, utils_1.assert)(scope.type !== scope_1.ScopeType.Switch);
-        if (!scope.variableDeclarations) {
-            scope.variableDeclarations = [];
-        }
-        scope.variableDeclarations.push(declaration);
+        (0, scope_1.addScopeVariableDeclaration)(scope, declaration);
     }
     return declaration;
 }
@@ -131,22 +119,25 @@ 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)) {
-                // Split declaration and assignment of identifiers that reference themselves in their declaration
-                declaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
+            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);
+                context.prependPrecedingStatements(precedingDeclaration);
                 if (rhs) {
                     assignment = lua.createAssignmentStatement(lhs, rhs, tsOriginal);
                 }
+                // Remember local variable declarations for hoisting later
+                (0, scope_1.addScopeVariableDeclaration)(scope, precedingDeclaration);
             }
             else {
                 declaration = lua.createVariableDeclarationStatement(lhs, rhs, tsOriginal);
-            }
-            if (!isFunctionDeclaration) {
-                // Remember local variable declarations for hoisting later
-                if (!scope.variableDeclarations) {
-                    scope.variableDeclarations = [];
+                if (!isFunctionDeclaration) {
+                    // Remember local variable declarations for hoisting later
+                    (0, scope_1.addScopeVariableDeclaration)(scope, declaration);
                 }
-                scope.variableDeclarations.push(declaration);
             }
         }
         else if (rhs) {

package/dist/transformation/utils/preceding-statements.d.ts

@@ -0,0 +1,3 @@
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+export declare function transformInPrecedingStatementScope<TReturn extends lua.Statement | lua.Statement[] | lua.Expression | lua.Expression[]>(context: TransformationContext, transformer: () => TReturn): [lua.Statement[], TReturn];

package/dist/transformation/utils/preceding-statements.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformInPrecedingStatementScope = void 0;
+function transformInPrecedingStatementScope(context, transformer) {
+    context.pushPrecedingStatements();
+    const statementOrStatements = transformer();
+    const precedingStatements = context.popPrecedingStatements();
+    return [precedingStatements, statementOrStatements];
+}
+exports.transformInPrecedingStatementScope = transformInPrecedingStatementScope;
+//# sourceMappingURL=preceding-statements.js.map

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;