typescript-to-lua 1.0.0 → 1.2.0

package/dist/transformation/visitors/expression-list.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOrderedExpressions = exports.transformExpressionList = exports.moveToPrecedingTemp = exports.shouldMoveToTemp = void 0;
+const assert = require("assert");
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+const context_1 = require("../context");
+const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const typescript_1 = require("../utils/typescript");
+const optional_chaining_1 = require("./optional-chaining");
+function shouldMoveToTemp(context, expression, tsOriginal) {
+    return (!lua.isLiteral(expression) &&
+        !(lua.isIdentifier(expression) && expression.symbolId === context_1.tempSymbolId) && // Treat generated temps as consts
+        !(tsOriginal && ((0, typescript_1.isConstIdentifier)(context, tsOriginal) || (0, optional_chaining_1.isOptionalContinuation)(tsOriginal))));
+}
+exports.shouldMoveToTemp = shouldMoveToTemp;
+// Cache an expression in a preceding statement and return the temp identifier
+function moveToPrecedingTemp(context, expression, tsOriginal) {
+    if (!shouldMoveToTemp(context, expression, tsOriginal)) {
+        return expression;
+    }
+    const tempIdentifier = context.createTempNameForLuaExpression(expression);
+    const tempDeclaration = lua.createVariableDeclarationStatement(tempIdentifier, expression, tsOriginal);
+    context.addPrecedingStatements(tempDeclaration);
+    return lua.cloneIdentifier(tempIdentifier, tsOriginal);
+}
+exports.moveToPrecedingTemp = moveToPrecedingTemp;
+function transformExpressions(context, expressions) {
+    const precedingStatements = [];
+    const transformedExpressions = [];
+    let lastPrecedingStatementsIndex = -1;
+    for (let i = 0; i < expressions.length; ++i) {
+        const [expressionPrecedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expressions[i]));
+        transformedExpressions.push(expression);
+        if (expressionPrecedingStatements.length > 0) {
+            lastPrecedingStatementsIndex = i;
+        }
+        precedingStatements.push(expressionPrecedingStatements);
+    }
+    return { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex };
+}
+function transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex) {
+    for (let i = 0; i < transformedExpressions.length; ++i) {
+        context.addPrecedingStatements(precedingStatements[i]);
+        if (i < lastPrecedingStatementsIndex) {
+            transformedExpressions[i] = moveToPrecedingTemp(context, transformedExpressions[i], expressions[i]);
+        }
+    }
+    return transformedExpressions;
+}
+function pushToSparseArray(context, arrayIdentifier, expressions) {
+    if (!arrayIdentifier) {
+        arrayIdentifier = lua.createIdentifier(context.createTempName("array"));
+        const libCall = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArrayNew, undefined, ...expressions);
+        const declaration = lua.createVariableDeclarationStatement(arrayIdentifier, libCall);
+        context.addPrecedingStatements(declaration);
+    }
+    else {
+        const libCall = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArrayPush, undefined, arrayIdentifier, ...expressions);
+        context.addPrecedingStatements(lua.createExpressionStatement(libCall));
+    }
+    return arrayIdentifier;
+}
+function transformExpressionsUsingSparseArray(context, expressions, transformedExpressions, precedingStatements) {
+    let arrayIdentifier;
+    let expressionBatch = [];
+    for (let i = 0; i < expressions.length; ++i) {
+        // Expressions with preceding statements should always be at the start of a batch
+        if (precedingStatements[i].length > 0 && expressionBatch.length > 0) {
+            arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+            expressionBatch = [];
+        }
+        context.addPrecedingStatements(precedingStatements[i]);
+        expressionBatch.push(transformedExpressions[i]);
+        // Spread expressions should always be at the end of a batch
+        if (ts.isSpreadElement(expressions[i])) {
+            arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+            expressionBatch = [];
+        }
+    }
+    if (expressionBatch.length > 0) {
+        arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+    }
+    assert(arrayIdentifier);
+    return [(0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArraySpread, undefined, arrayIdentifier)];
+}
+function countNeededTemps(context, expressions, transformedExpressions, lastPrecedingStatementsIndex) {
+    if (lastPrecedingStatementsIndex < 0) {
+        return 0;
+    }
+    return transformedExpressions
+        .slice(0, lastPrecedingStatementsIndex)
+        .filter((e, i) => shouldMoveToTemp(context, e, expressions[i])).length;
+}
+// Transforms a list of expressions while flattening spreads and maintaining execution order
+function transformExpressionList(context, expressions) {
+    const { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex } = transformExpressions(context, expressions);
+    // If more than this number of temps are required to preserve execution order, we'll fall back to using the
+    // sparse array lib functions instead to prevent excessive locals.
+    const maxTemps = 2;
+    // Use sparse array lib if there are spreads before the last expression
+    // or if too many temps are needed to preserve order
+    const lastSpread = expressions.findIndex(e => ts.isSpreadElement(e));
+    if ((lastSpread >= 0 && lastSpread < expressions.length - 1) ||
+        countNeededTemps(context, expressions, transformedExpressions, lastPrecedingStatementsIndex) > maxTemps) {
+        return transformExpressionsUsingSparseArray(context, expressions, transformedExpressions, precedingStatements);
+    }
+    else {
+        return transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex);
+    }
+}
+exports.transformExpressionList = transformExpressionList;
+// Transforms a series of expressions while maintaining execution order
+function transformOrderedExpressions(context, expressions) {
+    const { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex } = transformExpressions(context, expressions);
+    return transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex);
+}
+exports.transformOrderedExpressions = transformOrderedExpressions;
+//# sourceMappingURL=expression-list.js.map

package/dist/transformation/visitors/expression-statement.js

@@ -6,19 +6,23 @@ const lua = require("../../LuaAST");
 const binary_expression_1 = require("./binary-expression");
 const table_1 = require("./language-extensions/table");
 const unary_expression_1 = require("./unary-expression");
+const void_1 = require("./void");
 const transformExpressionStatement = (node, context) => {
     const expression = node.expression;
-    if (ts.isCallExpression(expression) && table_1.isTableDeleteCall(context, expression)) {
-        return table_1.transformTableDeleteExpression(context, expression);
+    if (ts.isCallExpression(expression) && (0, table_1.isTableDeleteCall)(context, expression)) {
+        return (0, table_1.transformTableDeleteExpression)(context, expression);
     }
-    if (ts.isCallExpression(expression) && table_1.isTableSetCall(context, expression)) {
-        return table_1.transformTableSetExpression(context, expression);
+    if (ts.isCallExpression(expression) && (0, table_1.isTableSetCall)(context, expression)) {
+        return (0, table_1.transformTableSetExpression)(context, expression);
     }
-    const unaryExpressionResult = unary_expression_1.transformUnaryExpressionStatement(context, node);
+    if (ts.isVoidExpression(expression)) {
+        return (0, void_1.transformVoidExpressionStatement)(expression, context);
+    }
+    const unaryExpressionResult = (0, unary_expression_1.transformUnaryExpressionStatement)(context, node);
     if (unaryExpressionResult) {
         return unaryExpressionResult;
     }
-    const binaryExpressionResult = binary_expression_1.transformBinaryExpressionStatement(context, node);
+    const binaryExpressionResult = (0, binary_expression_1.transformBinaryExpressionStatement)(context, node);
     if (binaryExpressionResult) {
         return binaryExpressionResult;
     }

package/dist/transformation/visitors/function.js

@@ -10,6 +10,7 @@ const export_1 = require("../utils/export");
 const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const async_await_1 = require("./async-await");
 const identifier_1 = require("./identifier");
@@ -34,10 +35,10 @@ function isRestParameterReferenced(identifier, scope) {
 }
 function transformFunctionBodyContent(context, body) {
     if (!ts.isBlock(body)) {
-        const returnStatement = return_1.transformExpressionBodyToReturnStatement(context, body);
-        return [returnStatement];
+        const [precedingStatements, returnStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, return_1.transformExpressionBodyToReturnStatement)(context, body));
+        return [...precedingStatements, returnStatement];
     }
-    const bodyStatements = scope_1.performHoisting(context, context.transformStatements(body.statements));
+    const bodyStatements = (0, scope_1.performHoisting)(context, context.transformStatements(body.statements));
     return bodyStatements;
 }
 exports.transformFunctionBodyContent = transformFunctionBodyContent;
@@ -54,16 +55,16 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
                 headerStatements.push(transformParameterDefaultValueDeclaration(context, identifier, declaration.initializer));
             }
             // Binding pattern
-            bindingPatternDeclarations.push(...variable_declaration_1.transformBindingPattern(context, declaration.name, identifier));
+            bindingPatternDeclarations.push(...(0, variable_declaration_1.transformBindingPattern)(context, declaration.name, identifier));
         }
         else if (declaration.initializer !== undefined) {
             // Default parameter
-            headerStatements.push(transformParameterDefaultValueDeclaration(context, identifier_1.transformIdentifier(context, declaration.name), declaration.initializer));
+            headerStatements.push(transformParameterDefaultValueDeclaration(context, (0, identifier_1.transformIdentifier)(context, declaration.name), declaration.initializer));
         }
     }
     // Push spread operator here
     if (spreadIdentifier && isRestParameterReferenced(spreadIdentifier, bodyScope)) {
-        const spreadTable = lua_ast_1.wrapInTable(lua.createDotsLiteral());
+        const spreadTable = (0, lua_ast_1.wrapInTable)(lua.createDotsLiteral());
         headerStatements.push(lua.createVariableDeclarationStatement(spreadIdentifier, spreadTable));
     }
     // Binding pattern statements need to be after spread table is declared
@@ -72,14 +73,14 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
 }
 exports.transformFunctionBodyHeader = transformFunctionBodyHeader;
 function transformFunctionBody(context, parameters, body, spreadIdentifier, node) {
-    const scope = scope_1.pushScope(context, scope_1.ScopeType.Function);
+    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
     scope.node = node;
     let bodyStatements = transformFunctionBodyContent(context, body);
-    if (node && async_await_1.isAsyncFunction(node)) {
-        bodyStatements = async_await_1.wrapInAsyncAwaiter(context, bodyStatements);
+    if (node && (0, async_await_1.isAsyncFunction)(node)) {
+        bodyStatements = (0, async_await_1.wrapInAsyncAwaiter)(context, bodyStatements);
     }
     const headerStatements = transformFunctionBodyHeader(context, scope, parameters, spreadIdentifier);
-    scope_1.popScope(context);
+    (0, scope_1.popScope)(context);
     return [[...headerStatements, ...bodyStatements], scope];
 }
 exports.transformFunctionBody = transformFunctionBody;
@@ -101,7 +102,7 @@ function transformParameters(context, parameters, functionContext) {
         // See transformFunctionBody for how these values are destructured
         const paramName = ts.isObjectBindingPattern(param.name) || ts.isArrayBindingPattern(param.name)
             ? lua.createIdentifier(`____bindingPattern${identifierIndex++}`)
-            : identifier_1.transformIdentifier(context, param.name);
+            : (0, identifier_1.transformIdentifier)(context, param.name);
         // This parameter is a spread parameter (...param)
         if (!param.dotDotDotToken) {
             paramNames.push(paramName);
@@ -116,10 +117,10 @@ function transformParameters(context, parameters, functionContext) {
 }
 exports.transformParameters = transformParameters;
 function transformFunctionToExpression(context, node) {
-    utils_1.assert(node.body);
+    (0, utils_1.assert)(node.body);
     const type = context.checker.getTypeAtLocation(node);
     let functionContext;
-    if (function_context_1.getFunctionContextType(context, type) !== function_context_1.ContextType.Void) {
+    if ((0, function_context_1.getFunctionContextType)(context, type) !== function_context_1.ContextType.Void) {
         if (ts.isArrowFunction(node)) {
             // dummy context for arrow functions with parameters
             if (node.parameters.length > 0) {
@@ -128,7 +129,7 @@ function transformFunctionToExpression(context, node) {
         }
         else {
             // self context
-            functionContext = lua_ast_1.createSelfIdentifier();
+            functionContext = (0, lua_ast_1.createSelfIdentifier)();
         }
     }
     let flags = lua.FunctionExpressionFlags.None;
@@ -142,7 +143,7 @@ function transformFunctionToExpression(context, node) {
     const functionExpression = lua.createFunctionExpression(lua.createBlock(transformedBody), paramNames, dotsLiteral, flags, node);
     return [
         node.asteriskToken
-            ? lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Generator, undefined, functionExpression)
+            ? (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Generator, undefined, functionExpression)
             : functionExpression,
         functionScope,
     ];
@@ -153,8 +154,8 @@ function transformFunctionLikeDeclaration(node, context) {
         // This code can be reached only from object methods, which is TypeScript error
         return lua.createNilLiteral();
     }
-    if (annotations_1.getNodeAnnotations(node).has(annotations_1.AnnotationKind.TupleReturn)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.TupleReturn));
+    if ((0, annotations_1.getNodeAnnotations)(node).has(annotations_1.AnnotationKind.TupleReturn)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
     const [functionExpression, functionScope] = transformFunctionToExpression(context, node);
     // Handle named function expressions which reference themselves
@@ -163,14 +164,11 @@ function transformFunctionLikeDeclaration(node, context) {
         if (symbol) {
             // TODO: Not using symbol ids because of https://github.com/microsoft/TypeScript/issues/37131
             const isReferenced = [...functionScope.referencedSymbols].some(([, nodes]) => nodes.some(n => { var _a; return ((_a = context.checker.getSymbolAtLocation(n)) === null || _a === void 0 ? void 0 : _a.valueDeclaration) === symbol.valueDeclaration; }));
-            // Only wrap if the name is actually referenced inside the function
+            // Only handle if the name is actually referenced inside the function
             if (isReferenced) {
-                const nameIdentifier = identifier_1.transformIdentifier(context, node.name);
-                // We cannot use transformToImmediatelyInvokedFunctionExpression() here because we need to transpile
-                // the function first to determine if it's self-referencing. Fortunately, this does not cause issues
-                // with var-arg optimization because the IIFE is just wrapping another function which will already push
-                // another scope.
-                return lua_ast_1.createImmediatelyInvokedFunctionExpression([lua.createVariableDeclarationStatement(nameIdentifier, functionExpression)], lua.cloneIdentifier(nameIdentifier));
+                const nameIdentifier = (0, identifier_1.transformIdentifier)(context, node.name);
+                context.addPrecedingStatements(lua.createVariableDeclarationStatement(nameIdentifier, functionExpression));
+                return lua.cloneIdentifier(nameIdentifier);
             }
         }
     }
@@ -179,35 +177,35 @@ function transformFunctionLikeDeclaration(node, context) {
 exports.transformFunctionLikeDeclaration = transformFunctionLikeDeclaration;
 const transformFunctionDeclaration = (node, context) => {
     var _a;
-    if (annotations_1.getNodeAnnotations(node).has(annotations_1.AnnotationKind.TupleReturn)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.TupleReturn));
+    if ((0, annotations_1.getNodeAnnotations)(node).has(annotations_1.AnnotationKind.TupleReturn)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
     // Don't transform functions without body (overload declarations)
     if (node.body === undefined) {
         return undefined;
     }
-    if (export_1.hasDefaultExportModifier(node)) {
-        return lua.createAssignmentStatement(lua.createTableIndexExpression(lua_ast_1.createExportsIdentifier(), export_1.createDefaultExportStringLiteral(node)), transformFunctionLikeDeclaration(node, context));
+    if ((0, export_1.hasDefaultExportModifier)(node)) {
+        return lua.createAssignmentStatement(lua.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), (0, export_1.createDefaultExportStringLiteral)(node)), transformFunctionLikeDeclaration(node, context));
     }
     const [functionExpression, functionScope] = transformFunctionToExpression(context, node);
     // Name being undefined without default export is a TypeScript error
-    const name = node.name ? identifier_1.transformIdentifier(context, node.name) : lua.createAnonymousIdentifier();
+    const name = node.name ? (0, identifier_1.transformIdentifier)(context, node.name) : lua.createAnonymousIdentifier();
     // Remember symbols referenced in this function for hoisting later
     if (name.symbolId !== undefined) {
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         if (!scope.functionDefinitions) {
             scope.functionDefinitions = new Map();
         }
         const functionInfo = { referencedSymbols: (_a = functionScope.referencedSymbols) !== null && _a !== void 0 ? _a : new Map() };
         scope.functionDefinitions.set(name.symbolId, functionInfo);
     }
-    return lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, name, functionExpression, node);
+    return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, name, functionExpression, node);
 };
 exports.transformFunctionDeclaration = transformFunctionDeclaration;
 const transformYieldExpression = (expression, context) => {
     const parameters = expression.expression ? [context.transformExpression(expression.expression)] : [];
     return expression.asteriskToken
-        ? lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.DelegatedYield, expression, ...parameters)
+        ? (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.DelegatedYield, expression, ...parameters)
         : lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("coroutine"), lua.createStringLiteral("yield")), parameters, expression);
 };
 exports.transformYieldExpression = transformYieldExpression;

package/dist/transformation/visitors/identifier.js

@@ -16,53 +16,57 @@ const operators_1 = require("./language-extensions/operators");
 const range_1 = require("./language-extensions/range");
 const table_1 = require("./language-extensions/table");
 const vararg_1 = require("./language-extensions/vararg");
+const optional_chaining_1 = require("./optional-chaining");
 function transformIdentifier(context, identifier) {
-    if (multi_1.isMultiFunctionNode(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidMultiFunctionUse(identifier));
+    if ((0, optional_chaining_1.isOptionalContinuation)(identifier)) {
+        return lua.createIdentifier(identifier.text);
+    }
+    if ((0, multi_1.isMultiFunctionNode)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(identifier));
         return lua.createAnonymousIdentifier(identifier);
     }
-    if (operators_1.isOperatorMapping(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidOperatorMappingUse(identifier));
+    if ((0, operators_1.isOperatorMapping)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidOperatorMappingUse)(identifier));
     }
-    if (table_1.isTableExtensionIdentifier(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidTableExtensionUse(identifier));
+    if ((0, table_1.isTableExtensionIdentifier)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidTableExtensionUse)(identifier));
     }
-    if (range_1.isRangeFunctionNode(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidRangeUse(identifier));
+    if ((0, range_1.isRangeFunctionNode)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidRangeUse)(identifier));
         return lua.createAnonymousIdentifier(identifier);
     }
-    if (vararg_1.isVarargConstantNode(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidVarargUse(identifier));
+    if ((0, vararg_1.isVarargConstantNode)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidVarargUse)(identifier));
         return lua.createAnonymousIdentifier(identifier);
     }
-    if (annotations_1.isForRangeType(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(identifier, annotations_1.AnnotationKind.ForRange));
+    if ((0, annotations_1.isForRangeType)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(identifier, annotations_1.AnnotationKind.ForRange));
     }
-    if (promise_1.isPromiseClass(context, identifier)) {
-        lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Promise);
-        return promise_1.createPromiseIdentifier(identifier);
+    if ((0, promise_1.isPromiseClass)(context, identifier)) {
+        (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
+        return (0, promise_1.createPromiseIdentifier)(identifier);
     }
-    const text = safe_names_1.hasUnsafeIdentifierName(context, identifier) ? safe_names_1.createSafeName(identifier.text) : identifier.text;
-    const symbolId = symbols_1.getIdentifierSymbolId(context, identifier);
+    const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, identifier) ? (0, safe_names_1.createSafeName)(identifier.text) : identifier.text;
+    const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, identifier);
     return lua.createIdentifier(text, identifier, symbolId, identifier.text);
 }
 exports.transformIdentifier = transformIdentifier;
 const transformIdentifierExpression = (node, context) => {
     const symbol = context.checker.getSymbolAtLocation(node);
     if (symbol) {
-        const exportScope = export_1.getSymbolExportScope(context, symbol);
+        const exportScope = (0, export_1.getSymbolExportScope)(context, symbol);
         if (exportScope) {
             const name = symbol.name;
-            const text = safe_names_1.hasUnsafeIdentifierName(context, node) ? safe_names_1.createSafeName(name) : name;
-            const symbolId = symbols_1.getIdentifierSymbolId(context, node);
+            const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, node) ? (0, safe_names_1.createSafeName)(name) : name;
+            const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, node);
             const identifier = lua.createIdentifier(text, node, symbolId, name);
-            return export_1.createExportedIdentifier(context, identifier, exportScope);
+            return (0, export_1.createExportedIdentifier)(context, identifier, exportScope);
         }
     }
     if (node.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
         return lua.createNilLiteral();
     }
-    const builtinResult = builtins_1.transformBuiltinIdentifierExpression(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinIdentifierExpression)(context, node);
     if (builtinResult) {
         return builtinResult;
     }

package/dist/transformation/visitors/index.js

@@ -33,14 +33,13 @@ const typeof_1 = require("./typeof");
 const typescript_1 = require("./typescript");
 const unary_expression_1 = require("./unary-expression");
 const variable_declaration_1 = require("./variable-declaration");
-const jsx_1 = require("./jsx/jsx");
 const async_await_1 = require("./async-await");
+const void_1 = require("./void");
 const transformEmptyStatement = () => undefined;
 const transformParenthesizedExpression = (node, context) => context.transformExpression(node.expression);
 exports.standardVisitors = {
     ...literal_1.literalVisitors,
     ...typescript_1.typescriptVisitors,
-    ...jsx_1.jsxVisitors,
     [ts.SyntaxKind.ArrowFunction]: function_1.transformFunctionLikeDeclaration,
     [ts.SyntaxKind.AwaitExpression]: async_await_1.transformAwaitExpression,
     [ts.SyntaxKind.BinaryExpression]: binary_expression_1.transformBinaryExpression,
@@ -90,5 +89,6 @@ exports.standardVisitors = {
     [ts.SyntaxKind.VariableStatement]: variable_declaration_1.transformVariableStatement,
     [ts.SyntaxKind.WhileStatement]: do_while_1.transformWhileStatement,
     [ts.SyntaxKind.YieldExpression]: function_1.transformYieldExpression,
+    [ts.SyntaxKind.VoidExpression]: void_1.transformVoidExpression,
 };
 //# sourceMappingURL=index.js.map

package/dist/transformation/visitors/language-extensions/iterable.js

@@ -30,12 +30,12 @@ function transformForOfMultiIterableStatement(context, statement, block) {
     if (ts.isVariableDeclarationList(statement.initializer)) {
         // Variables declared in for loop
         // for ${initializer} in ${iterable} do
-        const binding = utils_1.getVariableDeclarationBinding(context, statement.initializer);
+        const binding = (0, utils_1.getVariableDeclarationBinding)(context, statement.initializer);
         if (ts.isArrayBindingPattern(binding)) {
-            identifiers = binding.elements.map(e => variable_declaration_1.transformArrayBindingElement(context, e));
+            identifiers = binding.elements.map(e => (0, variable_declaration_1.transformArrayBindingElement)(context, e));
         }
         else {
-            context.diagnostics.push(diagnostics_1.invalidMultiIterableWithoutDestructuring(binding));
+            context.diagnostics.push((0, diagnostics_1.invalidMultiIterableWithoutDestructuring)(binding));
         }
     }
     else if (ts.isArrayLiteralExpression(statement.initializer)) {
@@ -44,11 +44,11 @@ function transformForOfMultiIterableStatement(context, statement, block) {
         //     ${initializer} = ____value0
         identifiers = statement.initializer.elements.map((_, i) => lua.createIdentifier(`____value${i}`));
         if (identifiers.length > 0) {
-            block.statements.unshift(lua.createAssignmentStatement(statement.initializer.elements.map(e => utils_2.cast(context.transformExpression(e), lua.isAssignmentLeftHandSideExpression)), identifiers));
+            block.statements.unshift(lua.createAssignmentStatement(statement.initializer.elements.map(e => (0, utils_2.cast)(context.transformExpression(e), lua.isAssignmentLeftHandSideExpression)), identifiers));
         }
     }
     else {
-        context.diagnostics.push(diagnostics_1.invalidMultiIterableWithoutDestructuring(statement.initializer));
+        context.diagnostics.push((0, diagnostics_1.invalidMultiIterableWithoutDestructuring)(statement.initializer));
     }
     if (identifiers.length === 0) {
         identifiers.push(lua.createAnonymousIdentifier());
@@ -58,11 +58,11 @@ function transformForOfMultiIterableStatement(context, statement, block) {
 function transformForOfIterableStatement(context, statement, block) {
     var _a;
     const type = context.checker.getTypeAtLocation(statement.expression);
-    if (((_a = type.aliasTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 2 && multi_1.isMultiReturnType(type.aliasTypeArguments[0])) {
+    if (((_a = type.aliasTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 2 && (0, multi_1.isMultiReturnType)(type.aliasTypeArguments[0])) {
         return transformForOfMultiIterableStatement(context, statement, block);
     }
     const luaIterator = context.transformExpression(statement.expression);
-    const identifier = utils_1.transformForInitializer(context, statement.initializer, block);
+    const identifier = (0, utils_1.transformForInitializer)(context, statement.initializer, block);
     return lua.createForInStatement(block, [identifier], [luaIterator], statement);
 }
 exports.transformForOfIterableStatement = transformForOfIterableStatement;

package/dist/transformation/visitors/language-extensions/multi.d.ts

@@ -8,4 +8,4 @@ export declare function isMultiReturnCall(context: TransformationContext, expres
 export declare function isMultiFunctionNode(context: TransformationContext, node: ts.Node): boolean;
 export declare function isInMultiReturnFunction(context: TransformationContext, node: ts.Node): boolean;
 export declare function shouldMultiReturnCallBeWrapped(context: TransformationContext, node: ts.CallExpression): boolean;
-export declare function findMultiAssignmentViolations(context: TransformationContext, node: ts.ObjectLiteralExpressionBase<ts.ObjectLiteralElement>): ts.Node[];
+export declare function findMultiAssignmentViolations(context: TransformationContext, node: ts.ObjectLiteralExpression): ts.Node[];

package/dist/transformation/visitors/language-extensions/multi.js

@@ -34,7 +34,7 @@ function isMultiFunctionNode(context, node) {
 }
 exports.isMultiFunctionNode = isMultiFunctionNode;
 function isInMultiReturnFunction(context, node) {
-    const declaration = typescript_1.findFirstNodeAbove(node, ts.isFunctionLike);
+    const declaration = (0, typescript_1.findFirstNodeAbove)(node, ts.isFunctionLike);
     if (!declaration) {
         return false;
     }
@@ -75,7 +75,7 @@ function shouldMultiReturnCallBeWrapped(context, node) {
         return false;
     }
     // LuaIterable in for...of
-    if (ts.isForOfStatement(node.parent) && iterable_1.isIterableExpression(context, node)) {
+    if (ts.isForOfStatement(node.parent) && (0, iterable_1.isIterableExpression)(context, node)) {
         return false;
     }
     return true;
@@ -89,7 +89,7 @@ function findMultiAssignmentViolations(context, node) {
         const valueSymbol = context.checker.getShorthandAssignmentValueSymbol(element);
         if (valueSymbol) {
             if (extensions.isExtensionValue(context, valueSymbol, extensions.ExtensionKind.MultiFunction)) {
-                context.diagnostics.push(diagnostics_1.invalidMultiFunctionUse(element));
+                context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(element));
                 result.push(element);
             }
         }

package/dist/transformation/visitors/language-extensions/operators.js

@@ -64,7 +64,7 @@ const bitwiseOperatorMapExtensions = new Set([
     extensions.ExtensionKind.BitwiseNotOperatorMethodType,
 ]);
 function getOperatorMapExtensionKindForCall(context, node) {
-    const type = typescript_1.getFunctionTypeForCall(context, node);
+    const type = (0, typescript_1.getFunctionTypeForCall)(context, node);
     return type && operatorMapExtensions.find(extensionKind => extensions.isExtensionType(type, extensionKind));
 }
 function isOperatorMapping(context, node) {
@@ -79,7 +79,7 @@ function isOperatorMapping(context, node) {
 exports.isOperatorMapping = isOperatorMapping;
 function transformOperatorMappingExpression(context, node) {
     const extensionKind = getOperatorMapExtensionKindForCall(context, node);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const isBefore53 = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 ||
         context.luaTarget === CompilerOptions_1.LuaTarget.Lua52 ||
         context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT ||
@@ -87,11 +87,11 @@ function transformOperatorMappingExpression(context, node) {
     if (isBefore53) {
         const luaTarget = context.luaTarget === CompilerOptions_1.LuaTarget.Universal ? CompilerOptions_1.LuaTarget.Lua51 : context.luaTarget;
         if (bitwiseOperatorMapExtensions.has(extensionKind)) {
-            context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "Native bitwise operations", luaTarget));
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Native bitwise operations", luaTarget));
         }
         else if (extensionKind === extensions.ExtensionKind.FloorDivisionOperatorType ||
             extensionKind === extensions.ExtensionKind.FloorDivisionOperatorMethodType) {
-            context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "Floor division operator", luaTarget));
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Floor division operator", luaTarget));
         }
     }
     const args = node.arguments.slice();
@@ -101,7 +101,7 @@ function transformOperatorMappingExpression(context, node) {
             args.unshift(node.expression.expression);
         }
         const luaOperator = binaryOperatorMappings.get(extensionKind);
-        utils_1.assert(luaOperator);
+        (0, utils_1.assert)(luaOperator);
         return lua.createBinaryExpression(context.transformExpression(args[0]), context.transformExpression(args[1]), luaOperator);
     }
     else {
@@ -114,7 +114,7 @@ function transformOperatorMappingExpression(context, node) {
             arg = args[0];
         }
         const luaOperator = unaryOperatorMappings.get(extensionKind);
-        utils_1.assert(luaOperator);
+        (0, utils_1.assert)(luaOperator);
         return lua.createUnaryExpression(context.transformExpression(arg), luaOperator);
     }
 }

package/dist/transformation/visitors/language-extensions/range.js

@@ -20,21 +20,21 @@ function isRangeFunctionNode(context, node) {
 exports.isRangeFunctionNode = isRangeFunctionNode;
 function getControlVariable(context, statement) {
     if (!ts.isVariableDeclarationList(statement.initializer)) {
-        context.diagnostics.push(diagnostics_1.invalidRangeControlVariable(statement.initializer));
+        context.diagnostics.push((0, diagnostics_1.invalidRangeControlVariable)(statement.initializer));
         return;
     }
-    const binding = utils_1.getVariableDeclarationBinding(context, statement.initializer);
+    const binding = (0, utils_1.getVariableDeclarationBinding)(context, statement.initializer);
     if (!ts.isIdentifier(binding)) {
-        context.diagnostics.push(diagnostics_1.invalidRangeControlVariable(statement.initializer));
+        context.diagnostics.push((0, diagnostics_1.invalidRangeControlVariable)(statement.initializer));
         return;
     }
-    return identifier_1.transformIdentifier(context, binding);
+    return (0, identifier_1.transformIdentifier)(context, binding);
 }
 function transformRangeStatement(context, statement, block) {
     var _a;
-    utils_2.assert(ts.isCallExpression(statement.expression));
+    (0, utils_2.assert)(ts.isCallExpression(statement.expression));
     const controlVariable = (_a = getControlVariable(context, statement)) !== null && _a !== void 0 ? _a : lua.createAnonymousIdentifier(statement.initializer);
-    const [start = lua.createNumericLiteral(0), limit = lua.createNumericLiteral(0), step] = call_1.transformArguments(context, statement.expression.arguments, context.checker.getResolvedSignature(statement.expression));
+    const [start = lua.createNumericLiteral(0), limit = lua.createNumericLiteral(0), step] = (0, call_1.transformArguments)(context, statement.expression.arguments, context.checker.getResolvedSignature(statement.expression));
     return lua.createForStatement(block, controlVariable, start, limit, step, statement);
 }
 exports.transformRangeStatement = transformRangeStatement;

package/dist/transformation/visitors/language-extensions/table.js

@@ -21,7 +21,7 @@ const tableExtensions = [
     ...tableSetExtensions,
 ];
 function getTableExtensionKindForCall(context, node, validExtensions) {
-    const type = typescript_1.getFunctionTypeForCall(context, node);
+    const type = (0, typescript_1.getFunctionTypeForCall)(context, node);
     return type && validExtensions.find(extensionKind => extensions.isExtensionType(type, extensionKind));
 }
 function isTableExtensionIdentifier(context, node) {
@@ -52,7 +52,7 @@ function isTableNewCall(context, node) {
 exports.isTableNewCall = isTableNewCall;
 function transformTableDeleteExpression(context, node) {
     const extensionKind = getTableExtensionKindForCall(context, node, tableDeleteExtensions);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const args = node.arguments.slice();
     if (args.length === 1 &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
@@ -65,7 +65,7 @@ function transformTableDeleteExpression(context, node) {
 exports.transformTableDeleteExpression = transformTableDeleteExpression;
 function transformTableGetExpression(context, node) {
     const extensionKind = getTableExtensionKindForCall(context, node, tableGetExtensions);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const args = node.arguments.slice();
     if (args.length === 1 &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
@@ -78,7 +78,7 @@ function transformTableGetExpression(context, node) {
 exports.transformTableGetExpression = transformTableGetExpression;
 function transformTableHasExpression(context, node) {
     const extensionKind = getTableExtensionKindForCall(context, node, tableHasExtensions);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const args = node.arguments.slice();
     if (args.length === 1 &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
@@ -93,7 +93,7 @@ function transformTableHasExpression(context, node) {
 exports.transformTableHasExpression = transformTableHasExpression;
 function transformTableSetExpression(context, node) {
     const extensionKind = getTableExtensionKindForCall(context, node, tableSetExtensions);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const args = node.arguments.slice();
     if (args.length === 2 &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {