typescript-to-lua 1.1.0 → 1.3.1

package/dist/transformation/visitors/call.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformArguments = exports.flattenSpreadExpressions = void 0;
+exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformCallAndArguments = exports.transformArguments = exports.validateArguments = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
@@ -8,124 +8,103 @@ const annotations_1 = require("../utils/annotations");
 const assignment_validation_1 = require("../utils/assignment-validation");
 const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
-const lualib_1 = require("../utils/lualib");
 const safe_names_1 = require("../utils/safe-names");
 const typescript_1 = require("../utils/typescript");
 const access_1 = require("./access");
 const multi_1 = require("./language-extensions/multi");
-const operators_1 = require("./language-extensions/operators");
-const table_1 = require("./language-extensions/table");
 const diagnostics_1 = require("../utils/diagnostics");
-const transform_1 = require("../utils/transform");
-function getExpressionsBeforeAndAfterFirstSpread(expressions) {
-    // [a, b, ...c, d, ...e] --> [a, b] and [...c, d, ...e]
-    const index = expressions.findIndex(ts.isSpreadElement);
-    const hasSpreadElement = index !== -1;
-    const before = hasSpreadElement ? expressions.slice(0, index) : expressions;
-    const after = hasSpreadElement ? expressions.slice(index) : [];
-    return [before, after];
-}
-function transformSpreadableExpressionsIntoArrayConcatArguments(context, expressions) {
-    // [...array, a, b, ...tuple()] --> [ [...array], [a, b], [...tuple()] ]
-    // chunk non-spread arguments together so they don't concat
-    const chunks = [];
-    for (const [index, expression] of expressions.entries()) {
-        if (ts.isSpreadElement(expression)) {
-            chunks.push([expression]);
-            const next = expressions[index + 1];
-            if (next && !ts.isSpreadElement(next)) {
-                chunks.push([]);
-            }
-        }
-        else {
-            let lastChunk = chunks[chunks.length - 1];
-            if (!lastChunk) {
-                lastChunk = [];
-                chunks.push(lastChunk);
-            }
-            lastChunk.push(expression);
+const expression_list_1 = require("./expression-list");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const optional_chaining_1 = require("./optional-chaining");
+const language_extensions_1 = require("./language-extensions");
+function validateArguments(context, params, signature) {
+    if (!signature || signature.parameters.length < params.length) {
+        return;
+    }
+    for (const [index, param] of params.entries()) {
+        const signatureParameter = signature.parameters[index];
+        const paramType = context.checker.getTypeAtLocation(param);
+        if (signatureParameter.valueDeclaration !== undefined) {
+            const signatureType = context.checker.getTypeAtLocation(signatureParameter.valueDeclaration);
+            (0, assignment_validation_1.validateAssignment)(context, param, paramType, signatureType, signatureParameter.name);
         }
     }
-    return chunks.map(chunk => (0, lua_ast_1.wrapInTable)(...chunk.map(expression => context.transformExpression(expression))));
 }
-function flattenSpreadExpressions(context, expressions) {
-    const [preSpreadExpressions, postSpreadExpressions] = getExpressionsBeforeAndAfterFirstSpread(expressions);
-    const transformedPreSpreadExpressions = preSpreadExpressions.map(a => context.transformExpression(a));
-    // Nothing special required
-    if (postSpreadExpressions.length === 0) {
-        return transformedPreSpreadExpressions;
-    }
-    // Only one spread element at the end? Will work as expected
-    if (postSpreadExpressions.length === 1) {
-        return [...transformedPreSpreadExpressions, context.transformExpression(postSpreadExpressions[0])];
-    }
-    // Use Array.concat and unpack the result of that as the last Expression
-    const concatArguments = transformSpreadableExpressionsIntoArrayConcatArguments(context, postSpreadExpressions);
-    const lastExpression = (0, lua_ast_1.createUnpackCall)(context, (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayConcat, undefined, ...concatArguments));
-    return [...transformedPreSpreadExpressions, lastExpression];
-}
-exports.flattenSpreadExpressions = flattenSpreadExpressions;
+exports.validateArguments = validateArguments;
 function transformArguments(context, params, signature, callContext) {
-    const parameters = flattenSpreadExpressions(context, params);
-    // Add context as first param if present
+    validateArguments(context, params, signature);
+    return (0, expression_list_1.transformExpressionList)(context, callContext ? [callContext, ...params] : params);
+}
+exports.transformArguments = transformArguments;
+function transformCallWithArguments(context, callExpression, transformedArguments, argPrecedingStatements, callContext) {
+    let call = context.transformExpression(callExpression);
+    let transformedContext;
     if (callContext) {
-        parameters.unshift(context.transformExpression(callContext));
-    }
-    if (signature && signature.parameters.length >= params.length) {
-        for (const [index, param] of params.entries()) {
-            const signatureParameter = signature.parameters[index];
-            const paramType = context.checker.getTypeAtLocation(param);
-            if (signatureParameter.valueDeclaration !== undefined) {
-                const signatureType = context.checker.getTypeAtLocation(signatureParameter.valueDeclaration);
-                (0, assignment_validation_1.validateAssignment)(context, param, paramType, signatureType, signatureParameter.name);
-            }
+        transformedContext = context.transformExpression(callContext);
+    }
+    if (argPrecedingStatements.length > 0) {
+        if (transformedContext) {
+            transformedContext = (0, expression_list_1.moveToPrecedingTemp)(context, transformedContext, callContext);
         }
+        call = (0, expression_list_1.moveToPrecedingTemp)(context, call, callExpression);
+        context.addPrecedingStatements(argPrecedingStatements);
     }
-    return parameters;
+    if (transformedContext) {
+        transformedArguments.unshift(transformedContext);
+    }
+    return [call, transformedArguments];
 }
-exports.transformArguments = transformArguments;
-function transformElementAccessCall(context, left, args, signature) {
-    const transformedArguments = transformArguments(context, args, signature, ts.factory.createIdentifier("____self"));
+function transformCallAndArguments(context, callExpression, params, signature, callContext) {
+    const [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, params, signature, callContext));
+    return transformCallWithArguments(context, callExpression, transformedArguments, argPrecedingStatements);
+}
+exports.transformCallAndArguments = transformCallAndArguments;
+function transformElementAccessCall(context, left, transformedArguments, argPrecedingStatements) {
     // Cache left-side if it has effects
-    // (function() local ____self = context; return ____self[argument](parameters); end)()
+    // local ____self = context; return ____self[argument](parameters);
+    const selfIdentifier = lua.createIdentifier(context.createTempName("self"));
+    const callContext = context.transformExpression(left.expression);
+    const selfAssignment = lua.createVariableDeclarationStatement(selfIdentifier, callContext);
+    context.addPrecedingStatements(selfAssignment);
     const argument = ts.isElementAccessExpression(left)
         ? (0, access_1.transformElementAccessArgument)(context, left)
         : lua.createStringLiteral(left.name.text);
-    const selfIdentifier = lua.createIdentifier("____self");
-    const callContext = context.transformExpression(left.expression);
-    const selfAssignment = lua.createVariableDeclarationStatement(selfIdentifier, callContext);
-    const index = lua.createTableIndexExpression(selfIdentifier, argument);
-    const callExpression = lua.createCallExpression(index, transformedArguments);
-    return { statements: selfAssignment, result: callExpression };
+    let index = lua.createTableIndexExpression(selfIdentifier, argument);
+    if (argPrecedingStatements.length > 0) {
+        // Cache index in temp if args had preceding statements
+        index = (0, expression_list_1.moveToPrecedingTemp)(context, index);
+        context.addPrecedingStatements(argPrecedingStatements);
+    }
+    return lua.createCallExpression(index, [selfIdentifier, ...transformedArguments]);
 }
 function transformContextualCallExpression(context, node, args, signature) {
+    if (ts.isOptionalChain(node)) {
+        return (0, optional_chaining_1.transformOptionalChain)(context, node);
+    }
     const left = ts.isCallExpression(node) ? node.expression : node.tag;
-    if (ts.isPropertyAccessExpression(left) && ts.isIdentifier(left.name) && (0, safe_names_1.isValidLuaIdentifier)(left.name.text)) {
+    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, context.options) &&
+        argPrecedingStatements.length === 0) {
         // table:name()
         const table = context.transformExpression(left.expression);
-        if (ts.isOptionalChain(node)) {
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalMethodCall, node, table, lua.createStringLiteral(left.name.text, left.name), lua.createBooleanLiteral(node.questionDotToken !== undefined), // Require method is present if no ?.() call
-            ...transformArguments(context, args, signature));
-        }
-        else {
-            return lua.createMethodCallExpression(table, lua.createIdentifier(left.name.text, left.name), transformArguments(context, args, signature), node);
-        }
+        return lua.createMethodCallExpression(table, lua.createIdentifier(left.name.text, left.name), transformedArguments, node);
     }
     else if (ts.isElementAccessExpression(left) || ts.isPropertyAccessExpression(left)) {
         if ((0, typescript_1.isExpressionWithEvaluationEffect)(left.expression)) {
-            return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => transformElementAccessCall(context, left, args, signature), node);
+            return transformElementAccessCall(context, left, transformedArguments, argPrecedingStatements);
         }
         else {
-            const callContext = context.transformExpression(left.expression);
-            const expression = context.transformExpression(left);
-            const transformedArguments = transformArguments(context, args, signature);
-            return lua.createCallExpression(expression, [callContext, ...transformedArguments]);
+            let expression;
+            [expression, transformedArguments] = transformCallWithArguments(context, left, transformedArguments, argPrecedingStatements, left.expression);
+            return lua.createCallExpression(expression, transformedArguments, node);
         }
     }
     else if (ts.isIdentifier(left)) {
         const callContext = context.isStrict ? ts.factory.createNull() : ts.factory.createIdentifier("_G");
-        const transformedArguments = transformArguments(context, args, signature, callContext);
-        const expression = context.transformExpression(left);
+        let expression;
+        [expression, transformedArguments] = transformCallWithArguments(context, left, transformedArguments, argPrecedingStatements, callContext);
         return lua.createCallExpression(expression, transformedArguments, node);
     }
     else {
@@ -147,14 +126,8 @@ function transformPropertyCall(context, node) {
     }
     else {
         // table.name()
-        const callPath = context.transformExpression(node.expression);
-        const parameters = transformArguments(context, node.arguments, signature);
-        if (ts.isOptionalChain(node)) {
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, callPath, ...parameters);
-        }
-        else {
-            return lua.createCallExpression(callPath, parameters, node);
-        }
+        const [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
+        return lua.createCallExpression(callPath, parameters, node);
     }
 }
 function transformElementCall(context, node) {
@@ -166,37 +139,26 @@ function transformElementCall(context, node) {
     }
     else {
         // No context
-        const expression = context.transformExpression(node.expression);
-        const parameters = transformArguments(context, node.arguments, signature);
+        const [expression, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
         return lua.createCallExpression(expression, parameters);
     }
 }
 const transformCallExpression = (node, context) => {
-    const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
-    const wrapResultInOptional = ts.isOptionalChain(node);
-    const builtinResult = (0, builtins_1.transformBuiltinCallExpression)(context, node);
-    if (builtinResult) {
-        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinResult) : builtinResult;
+    var _a;
+    if (ts.isOptionalChain(node)) {
+        return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
+    const optionalContinuation = ts.isIdentifier(node.expression)
+        ? (0, optional_chaining_1.getOptionalContinuationData)(node.expression)
+        : undefined;
+    const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
     if ((0, annotations_1.isTupleReturnCall)(context, node)) {
         context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
-    if ((0, operators_1.isOperatorMapping)(context, node)) {
-        return (0, operators_1.transformOperatorMappingExpression)(context, node);
-    }
-    if ((0, table_1.isTableDeleteCall)(context, node)) {
-        context.diagnostics.push((0, diagnostics_1.invalidTableDeleteExpression)(node));
-        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => ({ statements: (0, table_1.transformTableDeleteExpression)(context, node), result: lua.createNilLiteral() }), node);
-    }
-    if ((0, table_1.isTableGetCall)(context, node)) {
-        return (0, table_1.transformTableGetExpression)(context, node);
-    }
-    if ((0, table_1.isTableHasCall)(context, node)) {
-        return (0, table_1.transformTableHasExpression)(context, node);
-    }
-    if ((0, table_1.isTableSetCall)(context, node)) {
-        context.diagnostics.push((0, diagnostics_1.invalidTableSetExpression)(node));
-        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => ({ statements: (0, table_1.transformTableSetExpression)(context, node), result: lua.createNilLiteral() }), node);
+    const builtinOrExtensionResult = (_a = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined)) !== null && _a !== void 0 ? _a : (0, language_extensions_1.transformLanguageExtensionCallExpression)(context, node, optionalContinuation !== undefined);
+    if (builtinOrExtensionResult) {
+        // unsupportedOptionalCall diagnostic already present
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinOrExtensionResult) : builtinOrExtensionResult;
     }
     if (ts.isPropertyAccessExpression(node.expression)) {
         const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
@@ -205,12 +167,11 @@ const transformCallExpression = (node, context) => {
             context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
         }
         const result = transformPropertyCall(context, node);
-        // transformPropertyCall already wraps optional so no need to do so here
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
     if (ts.isElementAccessExpression(node.expression)) {
         const result = transformElementCall(context, node);
-        return wrapIfRequired(context, wrapResultInTable, wrapResultInOptional, result, node);
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
     const signature = context.checker.getResolvedSignature(node);
     // Handle super calls properly
@@ -218,31 +179,24 @@ const transformCallExpression = (node, context) => {
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
         return lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), parameters);
     }
-    const callPath = context.transformExpression(node.expression);
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    let parameters = [];
-    if (signatureDeclaration && (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) === function_context_1.ContextType.Void) {
-        parameters = transformArguments(context, node.arguments, signature);
+    let callPath;
+    let parameters;
+    const isContextualCall = !signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void;
+    if (!isContextualCall) {
+        [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
     }
     else {
-        const callContext = context.isStrict ? ts.factory.createNull() : ts.factory.createIdentifier("_G");
-        parameters = transformArguments(context, node.arguments, signature, callContext);
+        // if is optionalContinuation, context will be handled by transformOptionalChain.
+        const useGlobalContext = !context.isStrict && optionalContinuation === undefined;
+        const callContext = useGlobalContext ? ts.factory.createIdentifier("_G") : ts.factory.createNull();
+        [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature, callContext);
     }
     const callExpression = lua.createCallExpression(callPath, parameters, node);
-    return wrapIfRequired(context, wrapResultInTable, wrapResultInOptional, callExpression, node);
+    if (optionalContinuation && isContextualCall) {
+        optionalContinuation.contextualCall = callExpression;
+    }
+    return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(callExpression) : callExpression;
 };
 exports.transformCallExpression = transformCallExpression;
-function wrapIfRequired(context, shouldWrapInTable, shouldWrapOptional, call, node) {
-    const wrappedOptional = shouldWrapOptional ? wrapOptionalCall(context, call, node) : call;
-    return shouldWrapInTable ? (0, lua_ast_1.wrapInTable)(wrappedOptional) : wrappedOptional;
-}
-function wrapOptionalCall(context, call, node) {
-    if (lua.isMethodCallExpression(call)) {
-        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalMethodCall, node, call.prefixExpression, lua.createStringLiteral(call.name.text), lua.createBooleanLiteral(node.questionDotToken !== undefined), // Require method is present if no ?.() call
-        ...call.params);
-    }
-    else {
-        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, call.expression, ...call.params);
-    }
-}
 //# sourceMappingURL=call.js.map

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

@@ -9,7 +9,6 @@ const diagnostics_1 = require("../../utils/diagnostics");
 const export_1 = require("../../utils/export");
 const lua_ast_1 = require("../../utils/lua-ast");
 const safe_names_1 = require("../../utils/safe-names");
-const transform_1 = require("../../utils/transform");
 const identifier_1 = require("../identifier");
 const decorators_1 = require("./decorators");
 const accessors_1 = require("./members/accessors");
@@ -22,7 +21,7 @@ const utils_2 = require("./utils");
 const transformClassDeclaration = (declaration, context) => {
     // If declaration is a default export, transform to export variable assignment instead
     if ((0, export_1.hasDefaultExportModifier)(declaration)) {
-        const left = (0, export_1.createExportedIdentifier)(context, (0, export_1.createDefaultExportIdentifier)(declaration));
+        const left = (0, export_1.createDefaultExportExpression)(declaration);
         const right = transformClassAsExpression(declaration, context);
         return [lua.createAssignmentStatement(left, right, declaration)];
     }
@@ -33,10 +32,9 @@ exports.transformClassDeclaration = transformClassDeclaration;
 const transformThisExpression = node => (0, lua_ast_1.createSelfIdentifier)(node);
 exports.transformThisExpression = transformThisExpression;
 function transformClassAsExpression(expression, context) {
-    return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => {
-        const { statements, name } = transformClassLikeDeclaration(expression, context);
-        return { statements: (0, lua_ast_1.unwrapVisitorResult)(statements), result: name };
-    }, expression);
+    const { statements, name } = transformClassLikeDeclaration(expression, context);
+    context.addPrecedingStatements(statements);
+    return name;
 }
 exports.transformClassAsExpression = transformClassAsExpression;
 const classSuperInfos = new WeakMap();
@@ -49,8 +47,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         className = (0, identifier_1.transformIdentifier)(context, classDeclaration.name);
     }
     else {
-        // TypeScript error
-        className = lua.createAnonymousIdentifier();
+        className = lua.createIdentifier(context.createTempName("class"), classDeclaration);
     }
     const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(classDeclaration));
     if (annotations.has(annotations_1.AnnotationKind.Extension)) {
@@ -73,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);
     }
@@ -152,6 +149,13 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         const decoratingExpression = (0, decorators_1.createDecoratingExpression)(context, classDeclaration.kind, classDeclaration.decorators.map(d => (0, decorators_1.transformDecoratorExpression)(context, d)), localClassName);
         const decoratingStatement = lua.createAssignmentStatement(localClassName, decoratingExpression);
         result.push(decoratingStatement);
+        if ((0, export_1.hasExportModifier)(classDeclaration)) {
+            const exportExpression = (0, export_1.hasDefaultExportModifier)(classDeclaration)
+                ? (0, export_1.createDefaultExportExpression)(classDeclaration)
+                : (0, export_1.createExportedIdentifier)(context, className);
+            const classAssignment = lua.createAssignmentStatement(exportExpression, localClassName);
+            result.push(classAssignment);
+        }
     }
     superInfo.pop();
     return { statements: result, name: className };

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformNewExpression = exports.checkForLuaLibType = void 0;
+const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const annotations_1 = require("../../utils/annotations");
 const diagnostics_1 = require("../../utils/diagnostics");
@@ -46,7 +47,7 @@ function checkForLuaLibType(context, type) {
 }
 exports.checkForLuaLibType = checkForLuaLibType;
 const transformNewExpression = (node, context) => {
-    var _a;
+    var _a, _b;
     const type = context.checker.getTypeAtLocation(node);
     const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
@@ -56,15 +57,12 @@ const transformNewExpression = (node, context) => {
         return lua.createTableExpression(undefined, node);
     }
     const signature = context.checker.getResolvedSignature(node);
-    const params = node.arguments
-        ? (0, call_1.transformArguments)(context, node.arguments, signature)
-        : [lua.createBooleanLiteral(true)];
+    const [name, params] = (0, call_1.transformCallAndArguments)(context, node.expression, (_a = node.arguments) !== null && _a !== void 0 ? _a : [ts.factory.createTrue()], signature);
     checkForLuaLibType(context, type);
-    const name = context.transformExpression(node.expression);
     const customConstructorAnnotation = annotations.get(annotations_1.AnnotationKind.CustomConstructor);
     if (customConstructorAnnotation) {
         if (customConstructorAnnotation.args.length === 1) {
-            return lua.createCallExpression(lua.createIdentifier(customConstructorAnnotation.args[0]), (0, call_1.transformArguments)(context, (_a = node.arguments) !== null && _a !== void 0 ? _a : []), node);
+            return lua.createCallExpression(lua.createIdentifier(customConstructorAnnotation.args[0]), (0, call_1.transformArguments)(context, (_b = node.arguments) !== null && _b !== void 0 ? _b : []), node);
         }
         else {
             context.diagnostics.push((0, diagnostics_1.annotationInvalidArgumentCount)(node, annotations_1.AnnotationKind.CustomConstructor, customConstructorAnnotation.args.length, 1));

package/dist/transformation/visitors/conditional.js

@@ -3,47 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformIfStatement = exports.transformConditionalExpression = 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 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;
-    }
-}
-function wrapInFunctionCall(expression) {
-    const returnStatement = lua.createReturnStatement([expression]);
-    return lua.createFunctionExpression(lua.createBlock([returnStatement]), undefined, undefined, lua.FunctionExpressionFlags.Inline);
-}
+const typescript_1 = require("../utils/typescript");
 function transformProtectedConditionalExpression(context, expression) {
+    const tempVar = context.createTempNameForNode(expression.condition);
     const condition = context.transformExpression(expression.condition);
-    const val1 = context.transformExpression(expression.whenTrue);
-    const val2 = context.transformExpression(expression.whenFalse);
-    const val1Function = wrapInFunctionCall(val1);
-    const val2Function = wrapInFunctionCall(val2);
-    // (condition and (() => v1) or (() => v2))()
-    const conditionAnd = lua.createBinaryExpression(condition, val1Function, lua.SyntaxKind.AndOperator);
-    const orExpression = lua.createBinaryExpression(conditionAnd, val2Function, lua.SyntaxKind.OrOperator);
-    return lua.createCallExpression(orExpression, [], expression);
+    const [trueStatements, val1] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.whenTrue));
+    trueStatements.push(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), val1, expression.whenTrue));
+    const [falseStatements, val2] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.whenFalse));
+    falseStatements.push(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), val2, expression.whenFalse));
+    context.addPrecedingStatements([
+        lua.createVariableDeclarationStatement(tempVar, undefined, expression.condition),
+        lua.createIfStatement(condition, lua.createBlock(trueStatements, expression.whenTrue), lua.createBlock(falseStatements, expression.whenFalse), 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);
@@ -62,8 +40,23 @@ function transformIfStatement(statement, context) {
     const ifBlock = lua.createBlock(statements);
     if (statement.elseStatement) {
         if (ts.isIfStatement(statement.elseStatement)) {
-            const elseStatement = transformIfStatement(statement.elseStatement, context);
-            return lua.createIfStatement(condition, ifBlock, elseStatement);
+            const tsElseStatement = statement.elseStatement;
+            const [precedingStatements, elseStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformIfStatement(tsElseStatement, context));
+            // If else-if condition generates preceding statements, we can't use elseif, we have to break it down:
+            // if conditionA then
+            //     ...
+            // else
+            //     conditionB's preceding statements
+            //     if conditionB then
+            //     end
+            // end
+            if (precedingStatements.length > 0) {
+                const elseBlock = lua.createBlock([...precedingStatements, elseStatement]);
+                return lua.createIfStatement(condition, ifBlock, elseBlock);
+            }
+            else {
+                return lua.createIfStatement(condition, ifBlock, elseStatement);
+            }
         }
         else {
             (0, scope_1.pushScope)(context, scope_1.ScopeType.Conditional);

package/dist/transformation/visitors/delete.js

@@ -7,7 +7,11 @@ const lualib_1 = require("../utils/lualib");
 const diagnostics_1 = require("../utils/diagnostics");
 const typescript_1 = require("../utils/typescript");
 const lua_ast_1 = require("../utils/lua-ast");
+const optional_chaining_1 = require("./optional-chaining");
 const transformDeleteExpression = (node, context) => {
+    if (ts.isOptionalChain(node.expression)) {
+        return (0, optional_chaining_1.transformOptionalDeleteExpression)(context, node, node.expression);
+    }
     let ownerExpression;
     let propertyExpression;
     if (ts.isPropertyAccessExpression(node.expression)) {

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/expression-list.d.ts

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