typescript-to-lua 1.0.0 → 1.2.0

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,7 +8,6 @@ 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");
@@ -16,116 +15,97 @@ 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");
+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 => 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 = lua_ast_1.createUnpackCall(context, 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);
-                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)()
-    const argument = ts.isElementAccessExpression(left)
-        ? access_1.transformElementAccessArgument(context, left)
-        : lua.createStringLiteral(left.name.text);
-    const selfIdentifier = lua.createIdentifier("____self");
+    // 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);
-    const index = lua.createTableIndexExpression(selfIdentifier, argument);
-    const callExpression = lua.createCallExpression(index, transformedArguments);
-    return { statements: selfAssignment, result: callExpression };
+    context.addPrecedingStatements(selfAssignment);
+    const argument = ts.isElementAccessExpression(left)
+        ? (0, access_1.transformElementAccessArgument)(context, left)
+        : lua.createStringLiteral(left.name.text);
+    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) && 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) &&
+        argPrecedingStatements.length === 0) {
         // table:name()
         const table = context.transformExpression(left.expression);
-        if (ts.isOptionalChain(node)) {
-            return 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 (typescript_1.isExpressionWithEvaluationEffect(left.expression)) {
-            return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => transformElementAccessCall(context, left, args, signature), node);
+        if ((0, typescript_1.isExpressionWithEvaluationEffect)(left.expression)) {
+            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 {
@@ -141,76 +121,90 @@ function transformPropertyCall(context, node) {
         return lua.createCallExpression(context.transformExpression(node.expression), parameters);
     }
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    if (!signatureDeclaration || function_context_1.getDeclarationContextType(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
+    if (!signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
         // table:name()
         return transformContextualCallExpression(context, node, node.arguments, signature);
     }
     else {
         // table.name()
-        const callPath = context.transformExpression(node.expression);
-        const parameters = transformArguments(context, node.arguments, signature);
-        if (ts.isOptionalChain(node)) {
-            return 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) {
     const signature = context.checker.getResolvedSignature(node);
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    if (!signatureDeclaration || function_context_1.getDeclarationContextType(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
+    if (!signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
         // A contextual parameter must be given to this call expression
         return transformContextualCallExpression(context, node, node.arguments, signature);
     }
     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 = multi_1.isMultiReturnCall(context, node) && multi_1.shouldMultiReturnCallBeWrapped(context, node);
-    const wrapResultInOptional = ts.isOptionalChain(node);
-    const builtinResult = builtins_1.transformBuiltinCallExpression(context, node);
+    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);
+    const builtinResult = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined);
     if (builtinResult) {
-        return wrapResultInTable ? lua_ast_1.wrapInTable(builtinResult) : builtinResult;
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        }
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinResult) : builtinResult;
     }
-    if (annotations_1.isTupleReturnCall(context, node)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.TupleReturn));
+    if ((0, annotations_1.isTupleReturnCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
-    if (operators_1.isOperatorMapping(context, node)) {
-        return operators_1.transformOperatorMappingExpression(context, node);
+    if ((0, operators_1.isOperatorMapping)(context, node)) {
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+            return lua.createNilLiteral();
+        }
+        return (0, operators_1.transformOperatorMappingExpression)(context, node);
     }
-    if (table_1.isTableDeleteCall(context, node)) {
-        context.diagnostics.push(diagnostics_1.invalidTableDeleteExpression(node));
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => ({ statements: table_1.transformTableDeleteExpression(context, node), result: lua.createNilLiteral() }), node);
+    if ((0, table_1.isTableDeleteCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.invalidTableDeleteExpression)(node));
+        context.addPrecedingStatements((0, table_1.transformTableDeleteExpression)(context, node));
+        return lua.createNilLiteral();
     }
-    if (table_1.isTableGetCall(context, node)) {
-        return table_1.transformTableGetExpression(context, node);
+    if ((0, table_1.isTableGetCall)(context, node)) {
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+            return lua.createNilLiteral();
+        }
+        return (0, table_1.transformTableGetExpression)(context, node);
     }
-    if (table_1.isTableHasCall(context, node)) {
-        return table_1.transformTableHasExpression(context, node);
+    if ((0, table_1.isTableHasCall)(context, node)) {
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+            return lua.createNilLiteral();
+        }
+        return (0, table_1.transformTableHasExpression)(context, node);
     }
-    if (table_1.isTableSetCall(context, node)) {
-        context.diagnostics.push(diagnostics_1.invalidTableSetExpression(node));
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => ({ statements: table_1.transformTableSetExpression(context, node), result: lua.createNilLiteral() }), node);
+    if ((0, table_1.isTableSetCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.invalidTableSetExpression)(node));
+        context.addPrecedingStatements((0, table_1.transformTableSetExpression)(context, node));
+        return lua.createNilLiteral();
     }
     if (ts.isPropertyAccessExpression(node.expression)) {
         const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
-        const annotations = annotations_1.getTypeAnnotations(ownerType);
+        const annotations = (0, annotations_1.getTypeAnnotations)(ownerType);
         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));
         }
         const result = transformPropertyCall(context, node);
-        // transformPropertyCall already wraps optional so no need to do so here
-        return wrapResultInTable ? lua_ast_1.wrapInTable(result) : result;
+        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 +212,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 && 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 ? lua_ast_1.wrapInTable(wrappedOptional) : wrappedOptional;
-}
-function wrapOptionalCall(context, call, node) {
-    if (lua.isMethodCallExpression(call)) {
-        return 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 lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, call.expression, ...call.params);
-    }
-}
 //# sourceMappingURL=call.js.map

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

@@ -9,9 +9,9 @@ const lualib_1 = require("../../utils/lualib");
 function transformDecoratorExpression(context, decorator) {
     const expression = decorator.expression;
     const type = context.checker.getTypeAtLocation(expression);
-    const callContext = function_context_1.getFunctionContextType(context, type);
+    const callContext = (0, function_context_1.getFunctionContextType)(context, type);
     if (callContext === function_context_1.ContextType.Void) {
-        context.diagnostics.push(diagnostics_1.decoratorInvalidContext(decorator));
+        context.diagnostics.push((0, diagnostics_1.decoratorInvalidContext)(decorator));
     }
     return context.transformExpression(expression);
 }
@@ -26,7 +26,7 @@ function createDecoratingExpression(context, kind, decorators, targetTableName,
             kind === ts.SyntaxKind.SetAccessor;
         trailingExpressions.push(isMethodOrAccessor ? lua.createBooleanLiteral(true) : lua.createNilLiteral());
     }
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Decorate, undefined, ...trailingExpressions);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Decorate, undefined, ...trailingExpressions);
 }
 exports.createDecoratingExpression = createDecoratingExpression;
 //# sourceMappingURL=decorators.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");
@@ -21,8 +20,8 @@ const setup_1 = require("./setup");
 const utils_2 = require("./utils");
 const transformClassDeclaration = (declaration, context) => {
     // If declaration is a default export, transform to export variable assignment instead
-    if (export_1.hasDefaultExportModifier(declaration)) {
-        const left = export_1.createExportedIdentifier(context, export_1.createDefaultExportIdentifier(declaration));
+    if ((0, export_1.hasDefaultExportModifier)(declaration)) {
+        const left = (0, export_1.createDefaultExportExpression)(declaration);
         const right = transformClassAsExpression(declaration, context);
         return [lua.createAssignmentStatement(left, right, declaration)];
     }
@@ -30,13 +29,12 @@ const transformClassDeclaration = (declaration, context) => {
     return statements;
 };
 exports.transformClassDeclaration = transformClassDeclaration;
-const transformThisExpression = node => lua_ast_1.createSelfIdentifier(node);
+const transformThisExpression = node => (0, lua_ast_1.createSelfIdentifier)(node);
 exports.transformThisExpression = transformThisExpression;
 function transformClassAsExpression(expression, context) {
-    return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => {
-        const { statements, name } = transformClassLikeDeclaration(expression, context);
-        return { statements: 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();
@@ -46,52 +44,51 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         className = nameOverride;
     }
     else if (classDeclaration.name !== undefined) {
-        className = identifier_1.transformIdentifier(context, classDeclaration.name);
+        className = (0, identifier_1.transformIdentifier)(context, classDeclaration.name);
     }
     else {
-        // TypeScript error
-        className = lua.createAnonymousIdentifier();
+        className = lua.createIdentifier(context.createTempName("class"), classDeclaration);
     }
-    const annotations = annotations_1.getTypeAnnotations(context.checker.getTypeAtLocation(classDeclaration));
+    const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(classDeclaration));
     if (annotations.has(annotations_1.AnnotationKind.Extension)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(classDeclaration, annotations_1.AnnotationKind.Extension));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(classDeclaration, annotations_1.AnnotationKind.Extension));
     }
     if (annotations.has(annotations_1.AnnotationKind.MetaExtension)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(classDeclaration, annotations_1.AnnotationKind.MetaExtension));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(classDeclaration, annotations_1.AnnotationKind.MetaExtension));
     }
     // Get type that is extended
-    const extendedTypeNode = utils_2.getExtendedNode(context, classDeclaration);
-    const extendedType = utils_2.getExtendedType(context, classDeclaration);
-    const superInfo = utils_1.getOrUpdate(classSuperInfos, context, () => []);
+    const extendedTypeNode = (0, utils_2.getExtendedNode)(context, classDeclaration);
+    const extendedType = (0, utils_2.getExtendedType)(context, classDeclaration);
+    const superInfo = (0, utils_1.getOrUpdate)(classSuperInfos, context, () => []);
     superInfo.push({ className, extendedTypeNode });
     if (extendedType) {
-        new_1.checkForLuaLibType(context, extendedType);
+        (0, new_1.checkForLuaLibType)(context, extendedType);
     }
     // Get all properties with value
     const properties = classDeclaration.members.filter(ts.isPropertyDeclaration).filter(member => member.initializer);
     // Divide properties into static and non-static
-    const instanceFields = properties.filter(prop => !utils_2.isStaticNode(prop));
+    const instanceFields = properties.filter(prop => !(0, utils_2.isStaticNode)(prop));
     const result = [];
     let localClassName;
-    if (safe_names_1.isUnsafeName(className.text)) {
-        localClassName = lua.createIdentifier(safe_names_1.createSafeName(className.text), undefined, className.symbolId, className.text);
+    if ((0, safe_names_1.isUnsafeName)(className.text)) {
+        localClassName = lua.createIdentifier((0, safe_names_1.createSafeName)(className.text), undefined, className.symbolId, className.text);
         lua.setNodePosition(localClassName, className);
     }
     else {
         localClassName = className;
     }
-    result.push(...setup_1.createClassSetup(context, classDeclaration, className, localClassName, extendedType));
+    result.push(...(0, setup_1.createClassSetup)(context, classDeclaration, className, localClassName, extendedType));
     // Find first constructor with body
     const constructor = classDeclaration.members.find((n) => ts.isConstructorDeclaration(n) && n.body !== undefined);
     if (constructor) {
         // Add constructor plus initialization of instance fields
-        const constructorResult = constructor_1.transformConstructorDeclaration(context, constructor, localClassName, instanceFields, classDeclaration);
+        const constructorResult = (0, constructor_1.transformConstructorDeclaration)(context, constructor, localClassName, instanceFields, classDeclaration);
         if (constructorResult)
             result.push(constructorResult);
     }
     else if (!extendedType) {
         // Generate a constructor if none was defined in a base class
-        const constructorResult = constructor_1.transformConstructorDeclaration(context, ts.factory.createConstructorDeclaration([], [], [], ts.factory.createBlock([], true)), localClassName, instanceFields, classDeclaration);
+        const constructorResult = (0, constructor_1.transformConstructorDeclaration)(context, ts.factory.createConstructorDeclaration([], [], [], ts.factory.createBlock([], true)), localClassName, instanceFields, classDeclaration);
         if (constructorResult)
             result.push(constructorResult);
     }
@@ -100,11 +97,11 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         // localClassName.prototype.____constructor = function(self, ...)
         //     baseClassName.prototype.____constructor(self, ...)
         //     ...
-        const constructorBody = fields_1.transformClassInstanceFields(context, instanceFields);
-        const superCall = lua.createExpressionStatement(lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), [lua_ast_1.createSelfIdentifier(), lua.createDotsLiteral()]));
+        const constructorBody = (0, fields_1.transformClassInstanceFields)(context, instanceFields);
+        const superCall = lua.createExpressionStatement(lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), [(0, lua_ast_1.createSelfIdentifier)(), lua.createDotsLiteral()]));
         constructorBody.unshift(superCall);
-        const constructorFunction = lua.createFunctionExpression(lua.createBlock(constructorBody), [lua_ast_1.createSelfIdentifier()], lua.createDotsLiteral(), lua.FunctionExpressionFlags.Declaration);
-        result.push(lua.createAssignmentStatement(constructor_1.createConstructorName(localClassName), constructorFunction, classDeclaration));
+        const constructorFunction = lua.createFunctionExpression(lua.createBlock(constructorBody), [(0, lua_ast_1.createSelfIdentifier)()], lua.createDotsLiteral(), lua.FunctionExpressionFlags.Declaration);
+        result.push(lua.createAssignmentStatement((0, constructor_1.createConstructorName)(localClassName), constructorFunction, classDeclaration));
     }
     // Transform accessors
     for (const member of classDeclaration.members) {
@@ -113,7 +110,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         const accessors = context.resolver.getAllAccessorDeclarations(member);
         if (accessors.firstAccessor !== member)
             continue;
-        const accessorsResult = accessors_1.transformAccessorDeclarations(context, accessors, localClassName);
+        const accessorsResult = (0, accessors_1.transformAccessorDeclarations)(context, accessors, localClassName);
         if (accessorsResult) {
             result.push(accessorsResult);
         }
@@ -121,27 +118,27 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
     const decorationStatements = [];
     for (const member of classDeclaration.members) {
         if (ts.isAccessor(member)) {
-            const expression = fields_1.createPropertyDecoratingExpression(context, member, localClassName);
+            const expression = (0, fields_1.createPropertyDecoratingExpression)(context, member, localClassName);
             if (expression)
                 decorationStatements.push(lua.createExpressionStatement(expression));
         }
         else if (ts.isMethodDeclaration(member)) {
-            const statement = method_1.transformMethodDeclaration(context, member, localClassName);
+            const statement = (0, method_1.transformMethodDeclaration)(context, member, localClassName);
             if (statement)
                 result.push(statement);
             if (member.body) {
-                const statement = method_1.createMethodDecoratingExpression(context, member, localClassName);
+                const statement = (0, method_1.createMethodDecoratingExpression)(context, member, localClassName);
                 if (statement)
                     decorationStatements.push(statement);
             }
         }
         else if (ts.isPropertyDeclaration(member)) {
-            if (utils_2.isStaticNode(member)) {
-                const statement = fields_1.transformStaticPropertyDeclaration(context, member, localClassName);
+            if ((0, utils_2.isStaticNode)(member)) {
+                const statement = (0, fields_1.transformStaticPropertyDeclaration)(context, member, localClassName);
                 if (statement)
                     decorationStatements.push(statement);
             }
-            const expression = fields_1.createPropertyDecoratingExpression(context, member, localClassName);
+            const expression = (0, fields_1.createPropertyDecoratingExpression)(context, member, localClassName);
             if (expression)
                 decorationStatements.push(lua.createExpressionStatement(expression));
         }
@@ -149,15 +146,22 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
     result.push(...decorationStatements);
     // Decorate the class
     if (classDeclaration.decorators) {
-        const decoratingExpression = decorators_1.createDecoratingExpression(context, classDeclaration.kind, classDeclaration.decorators.map(d => decorators_1.transformDecoratorExpression(context, d)), localClassName);
+        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 };
 }
 const transformSuperExpression = (expression, context) => {
-    const superInfos = utils_1.getOrUpdate(classSuperInfos, context, () => []);
+    const superInfos = (0, utils_1.getOrUpdate)(classSuperInfos, context, () => []);
     const superInfo = superInfos[superInfos.length - 1];
     if (!superInfo)
         return lua.createAnonymousIdentifier(expression);
@@ -167,9 +171,9 @@ const transformSuperExpression = (expression, context) => {
     let baseClassName;
     if (extendsExpression && ts.isIdentifier(extendsExpression)) {
         const symbol = context.checker.getSymbolAtLocation(extendsExpression);
-        if (symbol && !export_1.isSymbolExported(context, symbol)) {
+        if (symbol && !(0, export_1.isSymbolExported)(context, symbol)) {
             // Use "baseClassName" if base is a simple identifier
-            baseClassName = identifier_1.transformIdentifier(context, extendsExpression);
+            baseClassName = (0, identifier_1.transformIdentifier)(context, extendsExpression);
         }
     }
     if (!baseClassName) {

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

@@ -9,12 +9,12 @@ const literal_1 = require("../../literal");
 const utils_1 = require("../utils");
 const constructor_1 = require("./constructor");
 function transformAccessor(context, node) {
-    const [params, dot, restParam] = function_1.transformParameters(context, node.parameters, lua_ast_1.createSelfIdentifier());
-    const body = node.body ? function_1.transformFunctionBody(context, node.parameters, node.body, restParam)[0] : [];
+    const [params, dot, restParam] = (0, function_1.transformParameters)(context, node.parameters, (0, lua_ast_1.createSelfIdentifier)());
+    const body = node.body ? (0, function_1.transformFunctionBody)(context, node.parameters, node.body, restParam)[0] : [];
     return lua.createFunctionExpression(lua.createBlock(body), params, dot, lua.FunctionExpressionFlags.Declaration);
 }
 function transformAccessorDeclarations(context, { firstAccessor, getAccessor, setAccessor }, className) {
-    const propertyName = literal_1.transformPropertyName(context, firstAccessor.name);
+    const propertyName = (0, literal_1.transformPropertyName)(context, firstAccessor.name);
     const descriptor = lua.createTableExpression([]);
     if (getAccessor) {
         const getterFunction = transformAccessor(context, getAccessor);
@@ -24,13 +24,13 @@ function transformAccessorDeclarations(context, { firstAccessor, getAccessor, se
         const setterFunction = transformAccessor(context, setAccessor);
         descriptor.fields.push(lua.createTableFieldExpression(setterFunction, lua.createStringLiteral("set")));
     }
-    const isStatic = utils_1.isStaticNode(firstAccessor);
-    const target = isStatic ? lua.cloneIdentifier(className) : constructor_1.createPrototypeName(className);
+    const isStatic = (0, utils_1.isStaticNode)(firstAccessor);
+    const target = isStatic ? lua.cloneIdentifier(className) : (0, constructor_1.createPrototypeName)(className);
     const feature = isStatic ? lualib_1.LuaLibFeature.ObjectDefineProperty : lualib_1.LuaLibFeature.SetDescriptor;
     const parameters = [target, propertyName, descriptor];
     if (!isStatic)
         parameters.push(lua.createBooleanLiteral(true));
-    const call = lualib_1.transformLuaLibFunction(context, feature, undefined, ...parameters);
+    const call = (0, lualib_1.transformLuaLibFunction)(context, feature, undefined, ...parameters);
     return lua.createExpressionStatement(call);
 }
 exports.transformAccessorDeclarations = transformAccessorDeclarations;