typescript-to-lua 1.0.0 → 1.2.0

package/dist/transformation/visitors/class/members/constructor.js

@@ -22,14 +22,14 @@ function transformConstructorDeclaration(context, statement, className, instance
         return undefined;
     }
     // Transform body
-    const scope = scope_1.pushScope(context, scope_1.ScopeType.Function);
-    const body = function_1.transformFunctionBodyContent(context, statement.body);
-    const [params, dotsLiteral, restParamName] = function_1.transformParameters(context, statement.parameters, lua_ast_1.createSelfIdentifier());
+    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
+    const body = (0, function_1.transformFunctionBodyContent)(context, statement.body);
+    const [params, dotsLiteral, restParamName] = (0, function_1.transformParameters)(context, statement.parameters, (0, lua_ast_1.createSelfIdentifier)());
     // Make sure default parameters are assigned before fields are initialized
-    const bodyWithFieldInitializers = function_1.transformFunctionBodyHeader(context, scope, statement.parameters, restParamName);
+    const bodyWithFieldInitializers = (0, function_1.transformFunctionBodyHeader)(context, scope, statement.parameters, restParamName);
     // Check for field declarations in constructor
     const constructorFieldsDeclarations = statement.parameters.filter(p => p.modifiers !== undefined);
-    const classInstanceFields = fields_1.transformClassInstanceFields(context, instanceFields);
+    const classInstanceFields = (0, fields_1.transformClassInstanceFields)(context, instanceFields);
     // If there are field initializers and the first statement is a super call,
     // move super call between default assignments and initializers
     if ((constructorFieldsDeclarations.length > 0 || classInstanceFields.length > 0) &&
@@ -49,7 +49,7 @@ function transformConstructorDeclaration(context, statement, className, instance
     for (const declaration of constructorFieldsDeclarations) {
         if (ts.isIdentifier(declaration.name)) {
             // self.declarationName = declarationName
-            const assignment = lua.createAssignmentStatement(lua.createTableIndexExpression(lua_ast_1.createSelfIdentifier(), lua.createStringLiteral(declaration.name.text)), identifier_1.transformIdentifier(context, declaration.name));
+            const assignment = lua.createAssignmentStatement(lua.createTableIndexExpression((0, lua_ast_1.createSelfIdentifier)(), lua.createStringLiteral(declaration.name.text)), (0, identifier_1.transformIdentifier)(context, declaration.name));
             bodyWithFieldInitializers.push(assignment);
         }
         // else { TypeScript error: A parameter property may not be declared using a binding pattern }
@@ -58,7 +58,7 @@ function transformConstructorDeclaration(context, statement, className, instance
     bodyWithFieldInitializers.push(...body);
     const block = lua.createBlock(bodyWithFieldInitializers);
     const constructorWasGenerated = statement.pos === -1;
-    scope_1.popScope(context);
+    (0, scope_1.popScope)(context);
     return lua.createAssignmentStatement(createConstructorName(className), lua.createFunctionExpression(block, params, dotsLiteral, lua.FunctionExpressionFlags.Declaration), constructorWasGenerated ? classDeclaration : statement);
 }
 exports.transformConstructorDeclaration = transformConstructorDeclaration;

package/dist/transformation/visitors/class/members/fields.js

@@ -9,19 +9,19 @@ const method_1 = require("./method");
 function createPropertyDecoratingExpression(context, node, className) {
     if (!node.decorators)
         return;
-    const propertyName = literal_1.transformPropertyName(context, node.name);
-    const propertyOwnerTable = method_1.transformMemberExpressionOwnerName(node, className);
-    return decorators_1.createDecoratingExpression(context, node.kind, node.decorators.map(d => decorators_1.transformDecoratorExpression(context, d)), propertyOwnerTable, propertyName);
+    const propertyName = (0, literal_1.transformPropertyName)(context, node.name);
+    const propertyOwnerTable = (0, method_1.transformMemberExpressionOwnerName)(node, className);
+    return (0, decorators_1.createDecoratingExpression)(context, node.kind, node.decorators.map(d => (0, decorators_1.transformDecoratorExpression)(context, d)), propertyOwnerTable, propertyName);
 }
 exports.createPropertyDecoratingExpression = createPropertyDecoratingExpression;
 function transformClassInstanceFields(context, instanceFields) {
     const statements = [];
     for (const f of instanceFields) {
         // Get identifier
-        const fieldName = literal_1.transformPropertyName(context, f.name);
+        const fieldName = (0, literal_1.transformPropertyName)(context, f.name);
         const value = f.initializer ? context.transformExpression(f.initializer) : undefined;
         // self[fieldName]
-        const selfIndex = lua.createTableIndexExpression(lua_ast_1.createSelfIdentifier(), fieldName);
+        const selfIndex = lua.createTableIndexExpression((0, lua_ast_1.createSelfIdentifier)(), fieldName);
         // self[fieldName] = value
         const assignClassField = lua.createAssignmentStatement(selfIndex, value, f);
         statements.push(assignClassField);
@@ -32,7 +32,7 @@ exports.transformClassInstanceFields = transformClassInstanceFields;
 function transformStaticPropertyDeclaration(context, field, className) {
     if (!field.initializer)
         return;
-    const fieldName = literal_1.transformPropertyName(context, field.name);
+    const fieldName = (0, literal_1.transformPropertyName)(context, field.name);
     const value = context.transformExpression(field.initializer);
     const classField = lua.createTableIndexExpression(lua.cloneIdentifier(className), fieldName);
     return lua.createAssignmentStatement(classField, value);

package/dist/transformation/visitors/class/members/method.js

@@ -10,11 +10,11 @@ const constructor_1 = require("./constructor");
 const lualib_1 = require("../../../utils/lualib");
 const utils_2 = require("../../../../utils");
 function transformMemberExpressionOwnerName(node, className) {
-    return utils_1.isStaticNode(node) ? lua.cloneIdentifier(className) : constructor_1.createPrototypeName(className);
+    return (0, utils_1.isStaticNode)(node) ? lua.cloneIdentifier(className) : (0, constructor_1.createPrototypeName)(className);
 }
 exports.transformMemberExpressionOwnerName = transformMemberExpressionOwnerName;
 function transformMethodName(context, node) {
-    const methodName = literal_1.transformPropertyName(context, node.name);
+    const methodName = (0, literal_1.transformPropertyName)(context, node.name);
     if (lua.isStringLiteral(methodName) && methodName.value === "toString") {
         return lua.createStringLiteral("__tostring", node.name);
     }
@@ -27,7 +27,7 @@ function transformMethodDeclaration(context, node, className) {
         return;
     const methodTable = transformMemberExpressionOwnerName(node, className);
     const methodName = transformMethodName(context, node);
-    const [functionExpression] = function_1.transformFunctionToExpression(context, node);
+    const [functionExpression] = (0, function_1.transformFunctionToExpression)(context, node);
     return lua.createAssignmentStatement(lua.createTableIndexExpression(methodTable, methodName), functionExpression, node);
 }
 exports.transformMethodDeclaration = transformMethodDeclaration;
@@ -38,12 +38,12 @@ function createMethodDecoratingExpression(context, node, className) {
     const parameterDecorators = node.parameters
         .flatMap((parameter, index) => {
         var _a;
-        return (_a = parameter.decorators) === null || _a === void 0 ? void 0 : _a.map(decorator => lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.DecorateParam, node, lua.createNumericLiteral(index), decorators_1.transformDecoratorExpression(context, decorator)));
+        return (_a = parameter.decorators) === null || _a === void 0 ? void 0 : _a.map(decorator => (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.DecorateParam, node, lua.createNumericLiteral(index), (0, decorators_1.transformDecoratorExpression)(context, decorator)));
     })
         .filter(utils_2.isNonNull);
-    const methodDecorators = (_b = (_a = node.decorators) === null || _a === void 0 ? void 0 : _a.map(d => decorators_1.transformDecoratorExpression(context, d))) !== null && _b !== void 0 ? _b : [];
+    const methodDecorators = (_b = (_a = node.decorators) === null || _a === void 0 ? void 0 : _a.map(d => (0, decorators_1.transformDecoratorExpression)(context, d))) !== null && _b !== void 0 ? _b : [];
     if (methodDecorators.length > 0 || parameterDecorators.length > 0) {
-        const decorateMethod = decorators_1.createDecoratingExpression(context, node.kind, [...methodDecorators, ...parameterDecorators], methodTable, methodName);
+        const decorateMethod = (0, decorators_1.createDecoratingExpression)(context, node.kind, [...methodDecorators, ...parameterDecorators], methodTable, methodName);
         return lua.createExpressionStatement(decorateMethod);
     }
 }

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");
@@ -28,49 +29,46 @@ function checkForLuaLibType(context, type) {
     const name = context.checker.getFullyQualifiedName(type.symbol);
     switch (name) {
         case "Map":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Map);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Map);
             return;
         case "Set":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Set);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Set);
             return;
         case "WeakMap":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.WeakMap);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.WeakMap);
             return;
         case "WeakSet":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.WeakSet);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.WeakSet);
             return;
     }
     if (builtinErrorTypeNames.has(name)) {
-        lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Error);
+        (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Error);
     }
 }
 exports.checkForLuaLibType = checkForLuaLibType;
 const transformNewExpression = (node, context) => {
-    var _a;
+    var _a, _b;
     const type = context.checker.getTypeAtLocation(node);
-    const annotations = annotations_1.getTypeAnnotations(type);
+    const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.LuaTable));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
     }
-    if (table_1.isTableNewCall(context, node)) {
+    if ((0, table_1.isTableNewCall)(context, node)) {
         return lua.createTableExpression(undefined, node);
     }
     const signature = context.checker.getResolvedSignature(node);
-    const params = node.arguments
-        ? 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]), 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(diagnostics_1.annotationInvalidArgumentCount(node, annotations_1.AnnotationKind.CustomConstructor, customConstructorAnnotation.args.length, 1));
+            context.diagnostics.push((0, diagnostics_1.annotationInvalidArgumentCount)(node, annotations_1.AnnotationKind.CustomConstructor, customConstructorAnnotation.args.length, 1));
         }
     }
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.New, node, name, ...params);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.New, node, name, ...params);
 };
 exports.transformNewExpression = transformNewExpression;
 //# sourceMappingURL=new.js.map

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

@@ -11,34 +11,34 @@ const utils_2 = require("./utils");
 function createClassSetup(context, statement, className, localClassName, extendsType) {
     const result = [];
     // __TS__Class()
-    const classInitializer = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Class, statement);
-    const defaultExportLeftHandSide = export_1.hasDefaultExportModifier(statement)
-        ? lua.createTableIndexExpression(lua_ast_1.createExportsIdentifier(), export_1.createDefaultExportStringLiteral(statement))
+    const classInitializer = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Class, statement);
+    const defaultExportLeftHandSide = (0, export_1.hasDefaultExportModifier)(statement)
+        ? lua.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), (0, export_1.createDefaultExportStringLiteral)(statement))
         : undefined;
     // [____exports.]className = __TS__Class()
     if (defaultExportLeftHandSide) {
         result.push(lua.createAssignmentStatement(defaultExportLeftHandSide, classInitializer, statement));
     }
     else {
-        result.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, className, classInitializer, statement));
+        result.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, className, classInitializer, statement));
     }
     if (defaultExportLeftHandSide) {
         // local localClassName = ____exports.default
         result.push(lua.createVariableDeclarationStatement(localClassName, defaultExportLeftHandSide));
     }
     else {
-        const exportScope = export_1.getIdentifierExportScope(context, className);
+        const exportScope = (0, export_1.getIdentifierExportScope)(context, className);
         if (exportScope) {
             // local localClassName = ____exports.className
-            result.push(lua.createVariableDeclarationStatement(localClassName, export_1.createExportedIdentifier(context, lua.cloneIdentifier(className), exportScope)));
+            result.push(lua.createVariableDeclarationStatement(localClassName, (0, export_1.createExportedIdentifier)(context, lua.cloneIdentifier(className), exportScope)));
         }
     }
     // localClassName.name = className
     result.push(lua.createAssignmentStatement(lua.createTableIndexExpression(lua.cloneIdentifier(localClassName), lua.createStringLiteral("name")), getReflectionClassName(context, statement, className), statement));
     if (extendsType) {
-        const extendedNode = utils_2.getExtendedNode(context, statement);
-        utils_1.assert(extendedNode);
-        result.push(lua.createExpressionStatement(lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ClassExtends, utils_2.getExtendsClause(statement), lua.cloneIdentifier(localClassName), context.transformExpression(extendedNode.expression))));
+        const extendedNode = (0, utils_2.getExtendedNode)(context, statement);
+        (0, utils_1.assert)(extendedNode);
+        result.push(lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ClassExtends, (0, utils_2.getExtendsClause)(statement), lua.cloneIdentifier(localClassName), context.transformExpression(extendedNode.expression))));
     }
     return result;
 }
@@ -50,10 +50,10 @@ function getReflectionClassName(context, declaration, className) {
     else if (ts.isVariableDeclaration(declaration.parent) && ts.isIdentifier(declaration.parent.name)) {
         return lua.createStringLiteral(declaration.parent.name.text);
     }
-    else if (export_1.hasDefaultExportModifier(declaration)) {
+    else if ((0, export_1.hasDefaultExportModifier)(declaration)) {
         return lua.createStringLiteral("default");
     }
-    if (utils_2.getExtendedNode(context, declaration)) {
+    if ((0, utils_2.getExtendedNode)(context, declaration)) {
         return lua.createTableIndexExpression(className, lua.createStringLiteral("name"));
     }
     return lua.createStringLiteral("");

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

@@ -19,9 +19,9 @@ function getExtendedNode(context, node) {
     if (!extendsClause)
         return;
     const superType = context.checker.getTypeAtLocation(extendsClause.types[0]);
-    const annotations = annotations_1.getTypeAnnotations(superType);
+    const annotations = (0, annotations_1.getTypeAnnotations)(superType);
     if (annotations.has(annotations_1.AnnotationKind.PureAbstract)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(extendsClause, annotations_1.AnnotationKind.PureAbstract));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(extendsClause, annotations_1.AnnotationKind.PureAbstract));
     }
     return extendsClause.types[0];
 }

package/dist/transformation/visitors/conditional.js

@@ -3,6 +3,7 @@ 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) {
@@ -27,20 +28,18 @@ function canBeFalsy(context, type) {
         return false;
     }
 }
-function wrapInFunctionCall(expression) {
-    const returnStatement = lua.createReturnStatement([expression]);
-    return lua.createFunctionExpression(lua.createBlock([returnStatement]), undefined, undefined, lua.FunctionExpressionFlags.Inline);
-}
 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))) {
@@ -55,20 +54,35 @@ const transformConditionalExpression = (expression, context) => {
 };
 exports.transformConditionalExpression = transformConditionalExpression;
 function transformIfStatement(statement, context) {
-    scope_1.pushScope(context, scope_1.ScopeType.Conditional);
+    (0, scope_1.pushScope)(context, scope_1.ScopeType.Conditional);
     const condition = context.transformExpression(statement.expression);
-    const statements = scope_1.performHoisting(context, block_1.transformBlockOrStatement(context, statement.thenStatement));
-    scope_1.popScope(context);
+    const statements = (0, scope_1.performHoisting)(context, (0, block_1.transformBlockOrStatement)(context, statement.thenStatement));
+    (0, scope_1.popScope)(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 {
-            scope_1.pushScope(context, scope_1.ScopeType.Conditional);
-            const elseStatements = scope_1.performHoisting(context, block_1.transformBlockOrStatement(context, statement.elseStatement));
-            scope_1.popScope(context);
+            (0, scope_1.pushScope)(context, scope_1.ScopeType.Conditional);
+            const elseStatements = (0, scope_1.performHoisting)(context, (0, block_1.transformBlockOrStatement)(context, statement.elseStatement));
+            (0, scope_1.popScope)(context);
             const elseBlock = lua.createBlock(elseStatements);
             return lua.createIfStatement(condition, ifBlock, elseBlock);
         }

package/dist/transformation/visitors/delete.js

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

package/dist/transformation/visitors/enum.js

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

package/dist/transformation/visitors/errors.js

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

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

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