typescript-to-lua 1.0.0 → 1.2.0

package/dist/transformation/visitors/binary-expression/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformBinaryExpressionStatement = exports.transformBinaryExpression = exports.transformBinaryOperation = void 0;
+exports.transformBinaryExpressionStatement = exports.transformBinaryExpression = exports.transformBinaryOperation = exports.createShortCircuitBinaryExpressionPrecedingStatements = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const lua_ast_1 = require("../../utils/lua-ast");
@@ -11,7 +11,11 @@ const assignments_1 = require("./assignments");
 const bit_1 = require("./bit");
 const compound_1 = require("./compound");
 const utils_1 = require("../../../utils");
-const transform_1 = require("../../utils/transform");
+const expression_list_1 = require("../expression-list");
+const preceding_statements_1 = require("../../utils/preceding-statements");
+const isShortCircuitOperator = (value) => value === ts.SyntaxKind.AmpersandAmpersandToken ||
+    value === ts.SyntaxKind.BarBarToken ||
+    value === ts.SyntaxKind.QuestionQuestionToken;
 const simpleOperatorsToLua = {
     [ts.SyntaxKind.AmpersandAmpersandToken]: lua.SyntaxKind.AndOperator,
     [ts.SyntaxKind.BarBarToken]: lua.SyntaxKind.OrOperator,
@@ -30,43 +34,77 @@ const simpleOperatorsToLua = {
     [ts.SyntaxKind.ExclamationEqualsToken]: lua.SyntaxKind.InequalityOperator,
     [ts.SyntaxKind.ExclamationEqualsEqualsToken]: lua.SyntaxKind.InequalityOperator,
 };
-function transformBinaryOperation(context, left, right, operator, node) {
-    if (bit_1.isBitOperator(operator)) {
-        return bit_1.transformBinaryBitOperation(context, node, left, right, operator);
+function transformBinaryOperationWithNoPrecedingStatements(context, left, right, operator, node) {
+    if ((0, bit_1.isBitOperator)(operator)) {
+        return (0, bit_1.transformBinaryBitOperation)(context, node, left, right, operator);
     }
     if (operator === ts.SyntaxKind.QuestionQuestionToken) {
-        utils_1.assert(ts.isBinaryExpression(node));
-        return transformNullishCoalescingExpression(context, node, left, right);
+        (0, utils_1.assert)(ts.isBinaryExpression(node));
+        return transformNullishCoalescingOperationNoPrecedingStatements(context, node, left, right);
     }
     let luaOperator = simpleOperatorsToLua[operator];
     // Check if we need to use string concat operator
     if (operator === ts.SyntaxKind.PlusToken && ts.isBinaryExpression(node)) {
         const typeLeft = context.checker.getTypeAtLocation(node.left);
         const typeRight = context.checker.getTypeAtLocation(node.right);
-        const isLeftString = typescript_1.isStringType(context, typeLeft);
-        const isRightString = typescript_1.isStringType(context, typeRight);
+        const isLeftString = (0, typescript_1.isStringType)(context, typeLeft);
+        const isRightString = (0, typescript_1.isStringType)(context, typeRight);
         if (isLeftString || isRightString) {
-            left = isLeftString ? left : lua_ast_1.wrapInToStringForConcat(left);
-            right = isRightString ? right : lua_ast_1.wrapInToStringForConcat(right);
+            left = isLeftString ? left : (0, lua_ast_1.wrapInToStringForConcat)(left);
+            right = isRightString ? right : (0, lua_ast_1.wrapInToStringForConcat)(right);
             luaOperator = lua.SyntaxKind.ConcatOperator;
         }
     }
     return lua.createBinaryExpression(left, right, luaOperator, node);
 }
+function createShortCircuitBinaryExpressionPrecedingStatements(context, lhs, rhs, rightPrecedingStatements, operator, node) {
+    const conditionIdentifier = context.createTempNameForLuaExpression(lhs);
+    const assignmentStatement = lua.createVariableDeclarationStatement(conditionIdentifier, lhs, node === null || node === void 0 ? void 0 : node.left);
+    let condition;
+    switch (operator) {
+        case ts.SyntaxKind.BarBarToken:
+            condition = lua.createUnaryExpression(lua.cloneIdentifier(conditionIdentifier), lua.SyntaxKind.NotOperator, node);
+            break;
+        case ts.SyntaxKind.AmpersandAmpersandToken:
+            condition = lua.cloneIdentifier(conditionIdentifier);
+            break;
+        case ts.SyntaxKind.QuestionQuestionToken:
+            condition = lua.createBinaryExpression(lua.cloneIdentifier(conditionIdentifier), lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator, node);
+            break;
+    }
+    const ifStatement = lua.createIfStatement(condition, lua.createBlock([...rightPrecedingStatements, lua.createAssignmentStatement(conditionIdentifier, rhs)]), undefined, node === null || node === void 0 ? void 0 : node.left);
+    return [[assignmentStatement, ifStatement], conditionIdentifier];
+}
+exports.createShortCircuitBinaryExpressionPrecedingStatements = createShortCircuitBinaryExpressionPrecedingStatements;
+function transformShortCircuitBinaryExpression(context, node, operator) {
+    const lhs = context.transformExpression(node.left);
+    const [rightPrecedingStatements, rhs] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
+    return transformBinaryOperation(context, lhs, rhs, rightPrecedingStatements, operator, node);
+}
+function transformBinaryOperation(context, left, right, rightPrecedingStatements, operator, node) {
+    if (rightPrecedingStatements.length > 0 && isShortCircuitOperator(operator)) {
+        (0, utils_1.assert)(ts.isBinaryExpression(node));
+        return createShortCircuitBinaryExpressionPrecedingStatements(context, left, right, rightPrecedingStatements, operator, node);
+    }
+    return [
+        rightPrecedingStatements,
+        transformBinaryOperationWithNoPrecedingStatements(context, left, right, operator, node),
+    ];
+}
 exports.transformBinaryOperation = transformBinaryOperation;
 const transformBinaryExpression = (node, context) => {
     const operator = node.operatorToken.kind;
-    const typeOfResult = typeof_1.transformTypeOfBinaryExpression(context, node);
+    const typeOfResult = (0, typeof_1.transformTypeOfBinaryExpression)(context, node);
     if (typeOfResult) {
         return typeOfResult;
     }
-    if (compound_1.isCompoundAssignmentToken(operator)) {
-        const token = compound_1.unwrapCompoundAssignmentToken(operator);
-        return compound_1.transformCompoundAssignmentExpression(context, node, node.left, node.right, token, false);
+    if ((0, compound_1.isCompoundAssignmentToken)(operator)) {
+        const token = (0, compound_1.unwrapCompoundAssignmentToken)(operator);
+        return (0, compound_1.transformCompoundAssignmentExpression)(context, node, node.left, node.right, token, false);
     }
     switch (operator) {
         case ts.SyntaxKind.EqualsToken:
-            return assignments_1.transformAssignmentExpression(context, node);
+            return (0, assignments_1.transformAssignmentExpression)(context, node);
         case ts.SyntaxKind.InKeyword: {
             const lhs = context.transformExpression(node.left);
             const rhs = context.transformExpression(node.right);
@@ -77,20 +115,31 @@ const transformBinaryExpression = (node, context) => {
             const lhs = context.transformExpression(node.left);
             const rhs = context.transformExpression(node.right);
             const rhsType = context.checker.getTypeAtLocation(node.right);
-            if (typescript_1.isStandardLibraryType(context, rhsType, "ObjectConstructor")) {
-                return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.InstanceOfObject, node, lhs);
+            if ((0, typescript_1.isStandardLibraryType)(context, rhsType, "ObjectConstructor")) {
+                return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.InstanceOfObject, node, lhs);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.InstanceOf, node, lhs, rhs);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.InstanceOf, node, lhs, rhs);
         }
         case ts.SyntaxKind.CommaToken: {
-            return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => ({
-                statements: context.transformStatements(ts.factory.createExpressionStatement(node.left)),
-                result: context.transformExpression(node.right),
-            }), node);
+            const statements = context.transformStatements(ts.factory.createExpressionStatement(node.left));
+            const [precedingStatements, result] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
+            statements.push(...precedingStatements);
+            context.addPrecedingStatements(statements);
+            return result;
+        }
+        case ts.SyntaxKind.QuestionQuestionToken:
+        case ts.SyntaxKind.AmpersandAmpersandToken:
+        case ts.SyntaxKind.BarBarToken: {
+            const [precedingStatements, result] = transformShortCircuitBinaryExpression(context, node, operator);
+            context.addPrecedingStatements(precedingStatements);
+            return result;
         }
-        default:
-            return transformBinaryOperation(context, context.transformExpression(node.left), context.transformExpression(node.right), operator, node);
     }
+    let [precedingStatements, [lhs, rhs]] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.transformOrderedExpressions)(context, [node.left, node.right]));
+    let result;
+    [precedingStatements, result] = transformBinaryOperation(context, lhs, rhs, precedingStatements, operator, node);
+    context.addPrecedingStatements(precedingStatements);
+    return result;
 };
 exports.transformBinaryExpression = transformBinaryExpression;
 function transformBinaryExpressionStatement(context, node) {
@@ -98,13 +147,13 @@ function transformBinaryExpressionStatement(context, node) {
     if (!ts.isBinaryExpression(expression))
         return;
     const operator = expression.operatorToken.kind;
-    if (compound_1.isCompoundAssignmentToken(operator)) {
+    if ((0, compound_1.isCompoundAssignmentToken)(operator)) {
         // +=, -=, etc...
-        const token = compound_1.unwrapCompoundAssignmentToken(operator);
-        return compound_1.transformCompoundAssignmentStatement(context, expression, expression.left, expression.right, token);
+        const token = (0, compound_1.unwrapCompoundAssignmentToken)(operator);
+        return (0, compound_1.transformCompoundAssignmentStatement)(context, expression, expression.left, expression.right, token);
     }
     else if (operator === ts.SyntaxKind.EqualsToken) {
-        return assignments_1.transformAssignmentStatement(context, expression);
+        return (0, assignments_1.transformAssignmentStatement)(context, expression);
     }
     else if (operator === ts.SyntaxKind.CommaToken) {
         const statements = [
@@ -115,21 +164,16 @@ function transformBinaryExpressionStatement(context, node) {
     }
 }
 exports.transformBinaryExpressionStatement = transformBinaryExpressionStatement;
-function transformNullishCoalescingExpression(context, node, transformedLeft, transformedRight) {
+function transformNullishCoalescingOperationNoPrecedingStatements(context, node, transformedLeft, transformedRight) {
     const lhsType = context.checker.getTypeAtLocation(node.left);
     // Check if we can take a shortcut to 'lhs or rhs' if the left-hand side cannot be 'false'.
     const typeCanBeFalse = (type) => (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Boolean)) !== 0 ||
         (type.flags & ts.TypeFlags.BooleanLiteral & ts.TypeFlags.PossiblyFalsy) !== 0;
-    if (typescript_1.typeCanSatisfy(context, lhsType, typeCanBeFalse)) {
-        // lhs can be false, transform to IIFE
-        const lhsIdentifier = lua.createIdentifier("____lhs");
-        const nilComparison = lua.createBinaryExpression(lua.cloneIdentifier(lhsIdentifier), lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-        // if ____ == nil then return rhs else return ____ end
-        const ifStatement = lua.createIfStatement(nilComparison, lua.createBlock([lua.createReturnStatement([transformedRight])]), lua.createBlock([lua.createReturnStatement([lua.cloneIdentifier(lhsIdentifier)])]));
-        // (function(lhs') if lhs' == nil then return rhs else return lhs' end)(lhs)
-        return lua.createCallExpression(lua.createFunctionExpression(lua.createBlock([ifStatement]), [lhsIdentifier]), [
-            transformedLeft,
-        ]);
+    if ((0, typescript_1.typeCanSatisfy)(context, lhsType, typeCanBeFalse)) {
+        // reuse logic from case with preceding statements
+        const [precedingStatements, result] = createShortCircuitBinaryExpressionPrecedingStatements(context, transformedLeft, transformedRight, [], ts.SyntaxKind.QuestionQuestionToken, node);
+        context.addPrecedingStatements(precedingStatements);
+        return result;
     }
     else {
         // lhs or rhs

package/dist/transformation/visitors/block.js

@@ -9,16 +9,16 @@ function transformBlockOrStatement(context, statement) {
 }
 exports.transformBlockOrStatement = transformBlockOrStatement;
 function transformScopeBlock(context, node, scopeType) {
-    scope_1.pushScope(context, scopeType);
-    const statements = scope_1.performHoisting(context, context.transformStatements(node.statements));
-    const scope = scope_1.popScope(context);
+    (0, scope_1.pushScope)(context, scopeType);
+    const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
+    const scope = (0, scope_1.popScope)(context);
     return [lua.createBlock(statements, node), scope];
 }
 exports.transformScopeBlock = transformScopeBlock;
 const transformBlock = (node, context) => {
-    scope_1.pushScope(context, scope_1.ScopeType.Block);
-    const statements = scope_1.performHoisting(context, context.transformStatements(node.statements));
-    scope_1.popScope(context);
+    (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+    const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
+    (0, scope_1.popScope)(context);
     return lua.createDoStatement(statements, node);
 };
 exports.transformBlock = transformBlock;

package/dist/transformation/visitors/break-continue.js

@@ -6,21 +6,16 @@ const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const scope_1 = require("../utils/scope");
 const transformBreakStatement = (breakStatement, context) => {
-    const breakableScope = scope_1.findScope(context, scope_1.ScopeType.Loop | scope_1.ScopeType.Switch);
-    if ((breakableScope === null || breakableScope === void 0 ? void 0 : breakableScope.type) === scope_1.ScopeType.Switch) {
-        return lua.createGotoStatement(`____switch${breakableScope.id}_end`);
-    }
-    else {
-        return lua.createBreakStatement(breakStatement);
-    }
+    void context;
+    return lua.createBreakStatement(breakStatement);
 };
 exports.transformBreakStatement = transformBreakStatement;
 const transformContinueStatement = (statement, context) => {
     var _a;
     if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal || context.luaTarget === CompilerOptions_1.LuaTarget.Lua51) {
-        context.diagnostics.push(diagnostics_1.unsupportedForTarget(statement, "Continue statement", CompilerOptions_1.LuaTarget.Lua51));
+        context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(statement, "Continue statement", CompilerOptions_1.LuaTarget.Lua51));
     }
-    const scope = scope_1.findScope(context, scope_1.ScopeType.Loop);
+    const scope = (0, scope_1.findScope)(context, scope_1.ScopeType.Loop);
     if (scope) {
         scope.loopContinued = true;
     }

package/dist/transformation/visitors/call.d.ts

@@ -4,7 +4,8 @@ import { FunctionVisitor, TransformationContext } from "../context";
 export declare type PropertyCallExpression = ts.CallExpression & {
     expression: ts.PropertyAccessExpression;
 };
-export declare function flattenSpreadExpressions(context: TransformationContext, expressions: readonly ts.Expression[]): lua.Expression[];
+export declare function validateArguments(context: TransformationContext, params: readonly ts.Expression[], signature?: ts.Signature): void;
 export declare function transformArguments(context: TransformationContext, params: readonly ts.Expression[], signature?: ts.Signature, callContext?: ts.Expression): lua.Expression[];
-export declare function transformContextualCallExpression(context: TransformationContext, node: ts.CallExpression | ts.TaggedTemplateExpression, args: ts.Expression[] | ts.NodeArray<ts.Expression>, signature?: ts.Signature): lua.CallExpression | lua.MethodCallExpression;
+export declare function transformCallAndArguments(context: TransformationContext, callExpression: ts.Expression, params: readonly ts.Expression[], signature?: ts.Signature, callContext?: ts.Expression): [lua.Expression, lua.Expression[]];
+export declare function transformContextualCallExpression(context: TransformationContext, node: ts.CallExpression | ts.TaggedTemplateExpression, args: ts.Expression[] | ts.NodeArray<ts.Expression>, signature?: ts.Signature): lua.Expression;
 export declare const transformCallExpression: FunctionVisitor<ts.CallExpression>;