typescript-to-lua 1.0.0 → 1.2.0

package/dist/transformation/builtins/string.js

@@ -13,35 +13,36 @@ function createStringCall(methodName, tsOriginal, ...params) {
 function transformStringPrototypeCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = 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":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringReplace, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringReplace, node, caller, ...params);
+        case "replaceAll":
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringReplaceAll, node, caller, ...params);
         case "concat":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringConcat, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringConcat, node, caller, ...params);
         case "indexOf": {
             const stringExpression = createStringCall("find", node, caller, params[0], params[1]
                 ? // string.find handles negative indexes by making it relative to string end, but for indexOf it's the same as 0
-                    lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("math"), lua.createStringLiteral("max")), [lua_ast_1.addToNumericExpression(params[1], 1), lua.createNumericLiteral(1)])
+                    lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("math"), lua.createStringLiteral("max")), [(0, lua_ast_1.addToNumericExpression)(params[1], 1), lua.createNumericLiteral(1)])
                 : lua.createNilLiteral(), lua.createBooleanLiteral(true));
             return lua.createBinaryExpression(lua.createBinaryExpression(stringExpression, lua.createNumericLiteral(0), lua.SyntaxKind.OrOperator), lua.createNumericLiteral(1), lua.SyntaxKind.SubtractionOperator, node);
         }
         case "substr":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSubstr, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSubstr, node, caller, ...params);
         case "substring":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSubstring, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSubstring, node, caller, ...params);
         case "slice": {
-            const literalArg1 = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalArg1 = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             if (params[0] && literalArg1 !== undefined) {
                 let stringSubArgs = [
-                    lua_ast_1.addToNumericExpression(params[0], literalArg1 < 0 ? 0 : 1),
+                    (0, lua_ast_1.addToNumericExpression)(params[0], literalArg1 < 0 ? 0 : 1),
                 ];
                 if (params[1]) {
-                    const literalArg2 = lua_ast_1.getNumberLiteralValue(params[1]);
+                    const literalArg2 = (0, lua_ast_1.getNumberLiteralValue)(params[1]);
                     if (literalArg2 !== undefined) {
-                        stringSubArgs.push(lua_ast_1.addToNumericExpression(params[1], literalArg2 < 0 ? -1 : 0));
+                        stringSubArgs.push((0, lua_ast_1.addToNumericExpression)(params[1], literalArg2 < 0 ? -1 : 0));
                     }
                     else {
                         stringSubArgs = undefined;
@@ -52,69 +53,69 @@ function transformStringPrototypeCall(context, node) {
                     return createStringCall("sub", node, caller, ...stringSubArgs);
                 }
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSlice, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSlice, node, caller, ...params);
         }
         case "toLowerCase":
             return createStringCall("lower", node, caller);
         case "toUpperCase":
             return createStringCall("upper", node, caller);
         case "trim":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrim, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrim, node, caller);
         case "trimEnd":
         case "trimRight":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrimEnd, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrimEnd, node, caller);
         case "trimStart":
         case "trimLeft":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrimStart, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrimStart, node, caller);
         case "split":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSplit, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSplit, node, caller, ...params);
         case "charAt": {
-            const literalValue = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalValue = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             // Inline string.sub call if we know that parameter is pure and isn't negative
             if (literalValue !== undefined && literalValue >= 0) {
-                const firstParamPlusOne = lua_ast_1.addToNumericExpression(params[0], 1);
+                const firstParamPlusOne = (0, lua_ast_1.addToNumericExpression)(params[0], 1);
                 return createStringCall("sub", node, caller, firstParamPlusOne, firstParamPlusOne);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringCharAt, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringCharAt, node, caller, ...params);
         }
         case "charCodeAt": {
-            const literalValue = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalValue = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             // Inline string.sub call if we know that parameter is pure and isn't negative
             if (literalValue !== undefined && literalValue >= 0) {
-                return lua.createBinaryExpression(createStringCall("byte", node, caller, lua_ast_1.addToNumericExpression(params[0], 1)), lua_ast_1.createNaN(), lua.SyntaxKind.OrOperator);
+                return lua.createBinaryExpression(createStringCall("byte", node, caller, (0, lua_ast_1.addToNumericExpression)(params[0], 1)), (0, lua_ast_1.createNaN)(), lua.SyntaxKind.OrOperator);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringCharCodeAt, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringCharCodeAt, node, caller, ...params);
         }
         case "startsWith":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringStartsWith, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringStartsWith, node, caller, ...params);
         case "endsWith":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringEndsWith, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringEndsWith, node, caller, ...params);
         case "includes":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringIncludes, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringIncludes, node, caller, ...params);
         case "repeat":
             const math = lua.createIdentifier("math");
             const floor = lua.createStringLiteral("floor");
             const parameter = lua.createCallExpression(lua.createTableIndexExpression(math, floor), [params[0]]);
             return createStringCall("rep", node, caller, parameter);
         case "padStart":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringPadStart, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadStart, node, caller, ...params);
         case "padEnd":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "string", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "string", expressionName));
     }
 }
 exports.transformStringPrototypeCall = transformStringPrototypeCall;
 function transformStringConstructorCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "fromCharCode":
             return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("string"), lua.createStringLiteral("char")), params, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "String", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "String", expressionName));
     }
 }
 exports.transformStringConstructorCall = transformStringConstructorCall;
@@ -124,7 +125,7 @@ function transformStringProperty(context, node) {
             const expression = context.transformExpression(node.expression);
             return lua.createUnaryExpression(expression, lua.SyntaxKind.LengthOperator, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(node.name, "string", node.name.text));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node.name, "string", node.name.text));
     }
 }
 exports.transformStringProperty = transformStringProperty;

package/dist/transformation/builtins/symbol.js

@@ -8,17 +8,17 @@ const call_1 = require("../visitors/call");
 function transformSymbolConstructorCall(context, expression) {
     const method = expression.expression;
     const signature = context.checker.getResolvedSignature(expression);
-    const parameters = call_1.transformArguments(context, expression.arguments, signature);
+    const parameters = (0, call_1.transformArguments)(context, expression.arguments, signature);
     const methodName = method.name.text;
     switch (methodName) {
         case "for":
         case "keyFor":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.SymbolRegistry);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.SymbolRegistry);
             const upperMethodName = methodName[0].toUpperCase() + methodName.slice(1);
             const functionIdentifier = lua.createIdentifier(`__TS__SymbolRegistry${upperMethodName}`);
             return lua.createCallExpression(functionIdentifier, parameters, expression);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(method.name, "Symbol", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Symbol", methodName));
     }
 }
 exports.transformSymbolConstructorCall = transformSymbolConstructorCall;

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.
@@ -35,13 +39,13 @@ class TransformationContext {
         }
         const nodeVisitors = this.visitorMap.get(node.kind);
         if (!nodeVisitors || nodeVisitors.length === 0) {
-            this.diagnostics.push(diagnostics_1.unsupportedNodeKind(node, node.kind));
+            this.diagnostics.push((0, diagnostics_1.unsupportedNodeKind)(node, node.kind));
             return isExpression ? [lua.createNilLiteral()] : [];
         }
         const previousNodeVisitors = this.currentNodeVisitors;
         this.currentNodeVisitors = [...nodeVisitors];
         const visitor = this.currentNodeVisitors.pop();
-        const result = lua_ast_1.unwrapVisitorResult(visitor.transform(node, this));
+        const result = (0, lua_ast_1.unwrapVisitorResult)(visitor.transform(node, this));
         this.currentNodeVisitors = previousNodeVisitors;
         return result;
     }
@@ -50,7 +54,7 @@ class TransformationContext {
             throw new Error(`There is no super transform for ${ts.SyntaxKind[node.kind]} visitor`);
         }
         const visitor = this.currentNodeVisitors.pop();
-        return lua_ast_1.unwrapVisitorResult(visitor.transform(node, this));
+        return (0, lua_ast_1.unwrapVisitorResult)(visitor.transform(node, this));
     }
     transformExpression(node) {
         const [result] = this.transformNode(node, true);
@@ -67,10 +71,105 @@ class TransformationContext {
         return result;
     }
     transformStatements(node) {
-        return 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 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/index.js

@@ -12,7 +12,7 @@ function createVisitorMap(customVisitors) {
             if (!visitor)
                 continue;
             const syntaxKind = Number(syntaxKindKey);
-            const nodeVisitors = utils_1.getOrUpdate(visitorMap, syntaxKind, () => []);
+            const nodeVisitors = (0, utils_1.getOrUpdate)(visitorMap, syntaxKind, () => []);
             const objectVisitor = typeof visitor === "function" ? { transform: visitor, priority } : visitor;
             nodeVisitors.push(objectVisitor);
         }

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

@@ -14,9 +14,7 @@ export declare enum AnnotationKind {
     NoSelf = "noSelf",
     NoSelfInFile = "noSelfInFile",
     Vararg = "vararg",
-    ForRange = "forRange",
-    Jsx = "jsx",
-    JsxFrag = "jsxFrag"
+    ForRange = "forRange"
 }
 export interface Annotation {
     kind: AnnotationKind;

package/dist/transformation/utils/annotations.js

@@ -18,8 +18,6 @@ var AnnotationKind;
     AnnotationKind["NoSelfInFile"] = "noSelfInFile";
     AnnotationKind["Vararg"] = "vararg";
     AnnotationKind["ForRange"] = "forRange";
-    AnnotationKind["Jsx"] = "jsx";
-    AnnotationKind["JsxFrag"] = "jsxFrag";
 })(AnnotationKind = exports.AnnotationKind || (exports.AnnotationKind = {}));
 function createAnnotation(name, args) {
     const kind = Object.values(AnnotationKind).find(k => k.toLowerCase() === name.toLowerCase());

package/dist/transformation/utils/assignment-validation.js

@@ -16,7 +16,7 @@ function validateAssignment(context, node, fromType, toType, toName) {
         return;
     }
     // Use cache to avoid repeating check for same types (protects against infinite loop in recursive types)
-    const fromTypeCache = utils_1.getOrUpdate(typeValidationCache, fromType, () => new Set());
+    const fromTypeCache = (0, utils_1.getOrUpdate)(typeValidationCache, fromType, () => new Set());
     if (fromTypeCache.has(toType))
         return;
     fromTypeCache.add(toType);
@@ -40,7 +40,8 @@ function validateAssignment(context, node, fromType, toType, toName) {
         }
     }
     if ((toType.flags & ts.TypeFlags.Object) !== 0 &&
-        (toType.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0 &&
+        (ts.isTypeLiteralNode(toTypeNode) ||
+            (toType.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0) &&
         toType.symbol &&
         toType.symbol.members &&
         fromType.symbol &&
@@ -61,15 +62,15 @@ function validateAssignment(context, node, fromType, toType, toName) {
 }
 exports.validateAssignment = validateAssignment;
 function validateFunctionAssignment(context, node, fromType, toType, toName) {
-    const fromContext = function_context_1.getFunctionContextType(context, fromType);
-    const toContext = function_context_1.getFunctionContextType(context, toType);
+    const fromContext = (0, function_context_1.getFunctionContextType)(context, fromType);
+    const toContext = (0, function_context_1.getFunctionContextType)(context, toType);
     if (fromContext === function_context_1.ContextType.Mixed || toContext === function_context_1.ContextType.Mixed) {
-        context.diagnostics.push(diagnostics_1.unsupportedOverloadAssignment(node, toName));
+        context.diagnostics.push((0, diagnostics_1.unsupportedOverloadAssignment)(node, toName));
     }
     else if (fromContext !== toContext && fromContext !== function_context_1.ContextType.None && toContext !== function_context_1.ContextType.None) {
         context.diagnostics.push(toContext === function_context_1.ContextType.Void
-            ? diagnostics_1.unsupportedNoSelfFunctionConversion(node, toName)
-            : diagnostics_1.unsupportedSelfFunctionConversion(node, toName));
+            ? (0, diagnostics_1.unsupportedNoSelfFunctionConversion)(node, toName)
+            : (0, diagnostics_1.unsupportedSelfFunctionConversion)(node, toName));
     }
 }
 //# sourceMappingURL=assignment-validation.js.map

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

@@ -91,3 +91,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,13 +1,13 @@
 "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.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;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const utils_1 = require("../../utils");
-const createDiagnosticFactory = (category, message) => utils_1.createSerialDiagnosticFactory((node, ...args) => ({
-    file: node.getSourceFile(),
-    start: node.getStart(),
-    length: node.getWidth(),
+const createDiagnosticFactory = (category, message) => (0, utils_1.createSerialDiagnosticFactory)((node, ...args) => ({
+    file: ts.getOriginalNode(node).getSourceFile(),
+    start: ts.getOriginalNode(node).getStart(),
+    length: ts.getOriginalNode(node).getWidth(),
     messageText: typeof message === "string" ? message : message(...args),
     category,
 }));
@@ -58,4 +58,6 @@ exports.annotationDeprecated = createWarningDiagnosticFactory((kind) => `'@${kin
     `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/export.d.ts

@@ -2,8 +2,8 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 export declare function hasDefaultExportModifier(node: ts.Node): boolean;
-export declare const createDefaultExportIdentifier: (original: ts.Node) => lua.Identifier;
-export declare const createDefaultExportStringLiteral: (original: ts.Node) => lua.StringLiteral;
+export declare function hasExportModifier(node: ts.Node): boolean;
+export declare const createDefaultExportStringLiteral: (original?: ts.Node | undefined) => lua.StringLiteral;
 export declare function getExportedSymbolDeclaration(symbol: ts.Symbol): ts.Declaration | undefined;
 export declare function getSymbolFromIdentifier(context: TransformationContext, identifier: lua.Identifier): ts.Symbol | undefined;
 export declare function getIdentifierExportScope(context: TransformationContext, identifier: lua.Identifier): ts.SourceFile | ts.ModuleDeclaration | undefined;
@@ -14,3 +14,4 @@ export declare function isSymbolExported(context: TransformationContext, symbol:
 export declare function isSymbolExportedFromScope(context: TransformationContext, symbol: ts.Symbol, scope: ts.SourceFile | ts.ModuleDeclaration): boolean;
 export declare function addExportToIdentifier(context: TransformationContext, identifier: lua.Identifier): lua.AssignmentLeftHandSideExpression;
 export declare function createExportedIdentifier(context: TransformationContext, identifier: lua.Identifier, exportScope?: ts.SourceFile | ts.ModuleDeclaration): lua.AssignmentLeftHandSideExpression;
+export declare function createDefaultExportExpression(node: ts.Node): lua.AssignmentLeftHandSideExpression;

package/dist/transformation/utils/export.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExportedIdentifier = exports.addExportToIdentifier = exports.isSymbolExportedFromScope = exports.isSymbolExported = exports.getDependenciesOfSymbol = exports.getExportedSymbolsFromScope = exports.getSymbolExportScope = exports.getIdentifierExportScope = exports.getSymbolFromIdentifier = exports.getExportedSymbolDeclaration = exports.createDefaultExportStringLiteral = exports.createDefaultExportIdentifier = exports.hasDefaultExportModifier = void 0;
+exports.createDefaultExportExpression = exports.createExportedIdentifier = exports.addExportToIdentifier = exports.isSymbolExportedFromScope = exports.isSymbolExported = exports.getDependenciesOfSymbol = exports.getExportedSymbolsFromScope = exports.getSymbolExportScope = exports.getIdentifierExportScope = exports.getSymbolFromIdentifier = exports.getExportedSymbolDeclaration = exports.createDefaultExportStringLiteral = exports.hasExportModifier = exports.hasDefaultExportModifier = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const namespace_1 = require("../visitors/namespace");
@@ -12,8 +12,11 @@ function hasDefaultExportModifier(node) {
     return ((_a = node.modifiers) !== null && _a !== void 0 ? _a : []).some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword);
 }
 exports.hasDefaultExportModifier = hasDefaultExportModifier;
-const createDefaultExportIdentifier = (original) => lua.createIdentifier("default", original);
-exports.createDefaultExportIdentifier = createDefaultExportIdentifier;
+function hasExportModifier(node) {
+    var _a;
+    return ((_a = node.modifiers) !== null && _a !== void 0 ? _a : []).some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+exports.hasExportModifier = hasExportModifier;
 const createDefaultExportStringLiteral = (original) => lua.createStringLiteral("default", original);
 exports.createDefaultExportStringLiteral = createDefaultExportStringLiteral;
 function getExportedSymbolDeclaration(symbol) {
@@ -25,7 +28,7 @@ function getExportedSymbolDeclaration(symbol) {
 exports.getExportedSymbolDeclaration = getExportedSymbolDeclaration;
 function getSymbolFromIdentifier(context, identifier) {
     if (identifier.symbolId !== undefined) {
-        const symbolInfo = symbols_1.getSymbolInfo(context, identifier.symbolId);
+        const symbolInfo = (0, symbols_1.getSymbolInfo)(context, identifier.symbolId);
         if (symbolInfo !== undefined) {
             return symbolInfo.symbol;
         }
@@ -48,7 +51,7 @@ function getSymbolExportScope(context, symbol) {
     if (!exportedDeclaration) {
         return undefined;
     }
-    const scope = typescript_1.findFirstNodeAbove(exportedDeclaration, (n) => ts.isSourceFile(n) || ts.isModuleDeclaration(n));
+    const scope = (0, typescript_1.findFirstNodeAbove)(exportedDeclaration, (n) => ts.isSourceFile(n) || ts.isModuleDeclaration(n));
     if (!scope) {
         return undefined;
     }
@@ -98,9 +101,13 @@ function createExportedIdentifier(context, identifier, exportScope) {
         return identifier;
     }
     const exportTable = exportScope && ts.isModuleDeclaration(exportScope)
-        ? namespace_1.createModuleLocalNameIdentifier(context, exportScope)
-        : lua_ast_1.createExportsIdentifier();
+        ? (0, namespace_1.createModuleLocalNameIdentifier)(context, exportScope)
+        : (0, lua_ast_1.createExportsIdentifier)();
     return lua.createTableIndexExpression(exportTable, lua.createStringLiteral(identifier.text));
 }
 exports.createExportedIdentifier = createExportedIdentifier;
+function createDefaultExportExpression(node) {
+    return lua.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), (0, exports.createDefaultExportStringLiteral)(node), node);
+}
+exports.createDefaultExportExpression = createDefaultExportExpression;
 //# sourceMappingURL=export.js.map

package/dist/transformation/utils/function-context.js

@@ -12,14 +12,14 @@ var ContextType;
     ContextType[ContextType["Mixed"] = 3] = "Mixed";
 })(ContextType = exports.ContextType || (exports.ContextType = {}));
 function hasNoSelfAncestor(declaration) {
-    const scopeDeclaration = typescript_1.findFirstNodeAbove(declaration, (node) => ts.isSourceFile(node) || ts.isModuleDeclaration(node));
+    const scopeDeclaration = (0, typescript_1.findFirstNodeAbove)(declaration, (node) => ts.isSourceFile(node) || ts.isModuleDeclaration(node));
     if (!scopeDeclaration) {
         return false;
     }
     else if (ts.isSourceFile(scopeDeclaration)) {
-        return annotations_1.getFileAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelfInFile);
+        return (0, annotations_1.getFileAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelfInFile);
     }
-    else if (annotations_1.getNodeAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+    else if ((0, annotations_1.getNodeAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
         return true;
     }
     else {
@@ -38,7 +38,7 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
             : ContextType.NonVoid;
     }
     // noSelf declaration on function signature
-    if (annotations_1.getNodeAnnotations(signatureDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+    if ((0, annotations_1.getNodeAnnotations)(signatureDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
         return ContextType.Void;
     }
     if (ts.isMethodSignature(signatureDeclaration) ||
@@ -48,11 +48,11 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
         (signatureDeclaration.parent && ts.isPropertyDeclaration(signatureDeclaration.parent)) ||
         (signatureDeclaration.parent && ts.isPropertySignature(signatureDeclaration.parent))) {
         // Class/interface methods only respect @noSelf on their parent
-        const scopeDeclaration = typescript_1.findFirstNodeAbove(signatureDeclaration, (n) => ts.isClassDeclaration(n) || ts.isClassExpression(n) || ts.isInterfaceDeclaration(n));
+        const scopeDeclaration = (0, typescript_1.findFirstNodeAbove)(signatureDeclaration, (n) => ts.isClassDeclaration(n) || ts.isClassExpression(n) || ts.isInterfaceDeclaration(n));
         if (scopeDeclaration === undefined) {
             return ContextType.NonVoid;
         }
-        if (annotations_1.getNodeAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+        if ((0, annotations_1.getNodeAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
             return ContextType.Void;
         }
         return ContextType.NonVoid;
@@ -98,10 +98,10 @@ function getSignatureDeclarations(context, signatures) {
         else if ((ts.isFunctionExpression(signatureDeclaration) || ts.isArrowFunction(signatureDeclaration)) &&
             !getExplicitThisParameter(signatureDeclaration)) {
             // Infer type of function expressions/arrow functions
-            inferredType = typescript_1.inferAssignedType(context, signatureDeclaration);
+            inferredType = (0, typescript_1.inferAssignedType)(context, signatureDeclaration);
         }
         if (inferredType) {
-            const inferredSignatures = typescript_1.getAllCallSignatures(inferredType);
+            const inferredSignatures = (0, typescript_1.getAllCallSignatures)(inferredType);
             if (inferredSignatures.length > 0) {
                 return inferredSignatures.map(s => s.getDeclaration());
             }

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;