typescript-to-lua 1.12.0 → 1.13.0

package/dist/transformation/utils/typescript/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.isStandardLibraryDeclaration = exports.getFirstDeclarationInFile = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
+exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.isStandardLibraryDeclaration = exports.getFirstDeclarationInFile = exports.expressionResultIsUsed = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
 const ts = require("typescript");
 __exportStar(require("./nodes"), exports);
 __exportStar(require("./types"), exports);
@@ -46,6 +46,10 @@ function findFirstNonOuterParent(node) {
     return current;
 }
 exports.findFirstNonOuterParent = findFirstNonOuterParent;
+function expressionResultIsUsed(node) {
+    return !ts.isExpressionStatement(findFirstNonOuterParent(node));
+}
+exports.expressionResultIsUsed = expressionResultIsUsed;
 function getFirstDeclarationInFile(symbol, sourceFile) {
     var _a, _b;
     const originalSourceFile = (_a = ts.getParseTreeNode(sourceFile)) !== null && _a !== void 0 ? _a : sourceFile;

package/dist/transformation/utils/typescript/types.js

@@ -103,9 +103,6 @@ function canBeFalsy(context, type) {
 }
 exports.canBeFalsy = canBeFalsy;
 function canBeFalsyWhenNotNull(context, type) {
-    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
-    if (!strictNullChecks && !type.isLiteral())
-        return true;
     const falsyFlags = ts.TypeFlags.Boolean |
         ts.TypeFlags.BooleanLiteral |
         ts.TypeFlags.Never |

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

@@ -72,7 +72,7 @@ function transformAssignmentWithRightPrecedingStatements(context, lhs, right, ri
 }
 exports.transformAssignmentWithRightPrecedingStatements = transformAssignmentWithRightPrecedingStatements;
 function transformDestructuredAssignmentExpression(context, expression) {
-    let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+    let { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
     context.addPrecedingStatements(rightPrecedingStatements);
     if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
         right = (0, lua_ast_1.wrapInTable)(right);
@@ -96,7 +96,7 @@ function transformAssignmentExpression(context, expression) {
         return result;
     }
     if (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) {
-        const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        const { precedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
         const left = transformAssignmentLeftHandSideExpression(context, expression.left, precedingStatements.length > 0);
         context.addPrecedingStatements(precedingStatements);
         const rightExpr = (0, expression_list_1.moveToPrecedingTemp)(context, right, expression.right);
@@ -156,7 +156,7 @@ function transformAssignmentStatement(context, expression) {
         return statements;
     }
     else {
-        const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        const { precedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
         return transformAssignmentWithRightPrecedingStatements(context, expression.left, right, precedingStatements);
     }
 }

package/dist/transformation/visitors/binary-expression/compound.d.ts

@@ -4,13 +4,6 @@ import { TransformationContext } from "../../context";
 type CompoundAssignmentToken = ts.SyntaxKind.BarToken | ts.SyntaxKind.PlusToken | ts.SyntaxKind.CaretToken | ts.SyntaxKind.MinusToken | ts.SyntaxKind.SlashToken | ts.SyntaxKind.PercentToken | ts.SyntaxKind.AsteriskToken | ts.SyntaxKind.AmpersandToken | ts.SyntaxKind.AsteriskAsteriskToken | ts.SyntaxKind.LessThanLessThanToken | ts.SyntaxKind.GreaterThanGreaterThanToken | ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.QuestionQuestionToken;
 export declare const isCompoundAssignmentToken: (token: ts.BinaryOperator) => token is ts.CompoundAssignmentOperator;
 export declare const unwrapCompoundAssignmentToken: (token: ts.CompoundAssignmentOperator) => CompoundAssignmentToken;
-export declare function transformCompoundAssignment(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): {
-    statements: lua.Statement[];
-    result: lua.Identifier;
-} | {
-    statements: lua.Statement[];
-    result: lua.TableIndexExpression;
-};
 export declare function transformCompoundAssignmentExpression(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): lua.Expression;
 export declare function transformCompoundAssignmentStatement(context: TransformationContext, node: ts.Node, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken): lua.Statement[];
 export {};

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

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCompoundAssignmentStatement = exports.transformCompoundAssignmentExpression = exports.transformCompoundAssignment = exports.unwrapCompoundAssignmentToken = exports.isCompoundAssignmentToken = void 0;
+exports.transformCompoundAssignmentStatement = exports.transformCompoundAssignmentExpression = exports.unwrapCompoundAssignmentToken = exports.isCompoundAssignmentToken = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
 const preceding_statements_1 = require("../../utils/preceding-statements");
 const index_1 = require("./index");
 const assignments_1 = require("./assignments");
+const destructuring_assignments_1 = require("./destructuring-assignments");
+const lualib_1 = require("../../utils/lualib");
 function isLuaExpressionWithSideEffect(expression) {
     return !(lua.isLiteral(expression) || lua.isIdentifier(expression));
 }
@@ -37,8 +39,12 @@ exports.isCompoundAssignmentToken = isCompoundAssignmentToken;
 const unwrapCompoundAssignmentToken = (token) => compoundToAssignmentTokens[token];
 exports.unwrapCompoundAssignmentToken = unwrapCompoundAssignmentToken;
 function transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix) {
+    if ((0, destructuring_assignments_1.isArrayLength)(context, lhs)) {
+        const { precedingStatements, result: lengthSetterStatement } = transformCompoundLengthSetter(context, expression, lhs, rhs, operator);
+        return { precedingStatements, result: lengthSetterStatement.expression };
+    }
     const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    const [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
+    const { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
     if (lua.isTableIndexExpression(left)) {
         // Complex property/element accesses need to cache object/index expressions to avoid repeating side-effects
         // local __obj, __index = ${objExpression}, ${indexExpression};
@@ -52,17 +58,17 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
             // ____obj[____index] = ____tmp ${replacementOperator} ${right};
             // return ____tmp
             const tmpDeclaration = lua.createVariableDeclarationStatement(tmp, accessExpression);
-            const [precedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, tmp, right, rightPrecedingStatements, operator, expression);
+            const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, tmp, right, rightPrecedingStatements, operator, expression);
             const assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
             return {
-                statements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
+                precedingStatements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
                 result: tmp,
             };
         }
         else {
             if (isSetterSkippingCompoundAssignmentOperator(operator)) {
                 return {
-                    statements: [
+                    precedingStatements: [
                         objAndIndexDeclaration,
                         ...transformSetterSkippingCompoundAssignment(accessExpression, operator, right, rightPrecedingStatements),
                     ],
@@ -72,11 +78,11 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
             // local ____tmp = ____obj[____index] ${replacementOperator} ${right};
             // ____obj[____index] = ____tmp;
             // return ____tmp
-            const [precedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, expression);
+            const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, expression);
             const tmpDeclaration = lua.createVariableDeclarationStatement(tmp, operatorExpression);
             const assignStatement = lua.createAssignmentStatement(accessExpression, tmp);
             return {
-                statements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
+                precedingStatements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
                 result: tmp,
             };
         }
@@ -88,36 +94,42 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
         // return ____tmp
         const tmpIdentifier = context.createTempNameForLuaExpression(left);
         const tmpDeclaration = lua.createVariableDeclarationStatement(tmpIdentifier, left);
-        const [precedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, tmpIdentifier, right, rightPrecedingStatements, operator, expression);
+        const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, tmpIdentifier, right, rightPrecedingStatements, operator, expression);
         const assignStatements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements);
-        return { statements: [tmpDeclaration, ...precedingStatements, ...assignStatements], result: tmpIdentifier };
+        return {
+            precedingStatements: [tmpDeclaration, ...precedingStatements, ...assignStatements],
+            result: tmpIdentifier,
+        };
     }
     else {
         if (rightPrecedingStatements.length > 0 && isSetterSkippingCompoundAssignmentOperator(operator)) {
             return {
-                statements: transformSetterSkippingCompoundAssignment(left, operator, right, rightPrecedingStatements),
+                precedingStatements: transformSetterSkippingCompoundAssignment(left, operator, right, rightPrecedingStatements),
                 result: left,
             };
         }
         // Simple expressions
         // ${left} = ${left} ${operator} ${right}
-        const [precedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, expression);
+        const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, expression);
         const statements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, precedingStatements);
-        return { statements, result: left };
+        return { precedingStatements: statements, result: left };
     }
 }
-exports.transformCompoundAssignment = transformCompoundAssignment;
 function transformCompoundAssignmentExpression(context, expression, 
 // TODO: Change type to ts.LeftHandSideExpression?
 lhs, rhs, operator, isPostfix) {
-    const { statements, result } = transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix);
-    context.addPrecedingStatements(statements);
+    const { precedingStatements, result } = transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix);
+    context.addPrecedingStatements(precedingStatements);
     return result;
 }
 exports.transformCompoundAssignmentExpression = transformCompoundAssignmentExpression;
 function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator) {
+    if ((0, destructuring_assignments_1.isArrayLength)(context, lhs)) {
+        const { precedingStatements, result: lengthSetterStatement } = transformCompoundLengthSetter(context, node, lhs, rhs, operator);
+        return [...precedingStatements, lengthSetterStatement];
+    }
     const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
+    const { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
     if (lua.isTableIndexExpression(left) && shouldCacheTableIndexExpressions(left, rightPrecedingStatements)) {
         // Complex property/element accesses need to cache object/index expressions to avoid repeating side-effects
         // local __obj, __index = ${objExpression}, ${indexExpression};
@@ -132,10 +144,9 @@ function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator)
                 ...transformSetterSkippingCompoundAssignment(accessExpression, operator, right, rightPrecedingStatements, node),
             ];
         }
-        let operatorExpression;
-        [rightPrecedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, node);
+        const { precedingStatements: rightPrecedingStatements2, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, node);
         const assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
-        return [objAndIndexDeclaration, ...rightPrecedingStatements, assignStatement];
+        return [objAndIndexDeclaration, ...rightPrecedingStatements2, assignStatement];
     }
     else {
         if (isSetterSkippingCompoundAssignmentOperator(operator)) {
@@ -143,9 +154,8 @@ function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator)
         }
         // Simple statements
         // ${left} = ${left} ${replacementOperator} ${right}
-        let operatorExpression;
-        [rightPrecedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, node);
-        return (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements);
+        const { precedingStatements: rightPrecedingStatements2, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, node);
+        return (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements2);
     }
 }
 exports.transformCompoundAssignmentStatement = transformCompoundAssignmentStatement;
@@ -174,4 +184,12 @@ function transformSetterSkippingCompoundAssignment(lhs, operator, right, rightPr
         lua.createIfStatement(condition, lua.createBlock([...rightPrecedingStatements, lua.createAssignmentStatement(lhs, right, node)]), undefined, node),
     ];
 }
+function transformCompoundLengthSetter(context, node, lhs, rhs, operator) {
+    const { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
+    const table = context.transformExpression(lhs.expression);
+    const lengthExpression = lua.createUnaryExpression(table, lua.SyntaxKind.LengthOperator, lhs);
+    const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, lengthExpression, right, rightPrecedingStatements, operator, node);
+    const arrayLengthAssignment = lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, node, table, operatorExpression));
+    return { precedingStatements, result: arrayLengthAssignment };
+}
 //# sourceMappingURL=compound.js.map

package/dist/transformation/visitors/binary-expression/destructuring-assignments.js

@@ -52,7 +52,7 @@ function transformArrayLiteralAssignmentPattern(context, node, root, rightHasPre
                 const assignedVariable = context.createTempNameForLuaExpression(indexedRoot);
                 const assignedVariableDeclaration = lua.createVariableDeclarationStatement(assignedVariable, indexedRoot);
                 const nilCondition = lua.createBinaryExpression(assignedVariable, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-                const [defaultPrecedingStatements, defaultAssignmentStatements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.left, context.transformExpression(element.right)));
+                const { precedingStatements: defaultPrecedingStatements, result: defaultAssignmentStatements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.left, context.transformExpression(element.right)));
                 // Keep preceding statements inside if block
                 defaultAssignmentStatements.unshift(...defaultPrecedingStatements);
                 const elseAssignmentStatements = (0, assignments_1.transformAssignment)(context, element.left, assignedVariable);
@@ -63,7 +63,7 @@ function transformArrayLiteralAssignmentPattern(context, node, root, rightHasPre
             case ts.SyntaxKind.Identifier:
             case ts.SyntaxKind.PropertyAccessExpression:
             case ts.SyntaxKind.ElementAccessExpression:
-                const [precedingStatements, statements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element, indexedRoot, rightHasPrecedingStatements));
+                const { precedingStatements, result: statements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element, indexedRoot, rightHasPrecedingStatements));
                 return [...precedingStatements, ...statements]; // Keep preceding statements in order
             case ts.SyntaxKind.SpreadElement:
                 if (index !== node.elements.length - 1) {
@@ -71,7 +71,7 @@ function transformArrayLiteralAssignmentPattern(context, node, root, rightHasPre
                     return [];
                 }
                 const restElements = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, undefined, root, lua.createNumericLiteral(index));
-                const [spreadPrecedingStatements, spreadStatements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.expression, restElements, rightHasPrecedingStatements));
+                const { precedingStatements: spreadPrecedingStatements, result: spreadStatements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.expression, restElements, rightHasPrecedingStatements));
                 return [...spreadPrecedingStatements, ...spreadStatements]; // Keep preceding statements in order
             case ts.SyntaxKind.OmittedExpression:
                 return [];
@@ -146,12 +146,12 @@ function transformPropertyAssignment(context, node, root, rightHasPrecedingState
             // Access expressions need their table and index expressions cached to preserve execution order
             const left = (0, utils_1.cast)(context.transformExpression(node.initializer.left), lua.isTableIndexExpression);
             const rightExpression = node.initializer.right;
-            const [defaultPrecedingStatements, defaultExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rightExpression));
+            const { precedingStatements: defaultPrecedingStatements, result: defaultExpression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rightExpression));
             const tableTemp = context.createTempNameForLuaExpression(left.table);
             const indexTemp = context.createTempNameForLuaExpression(left.index);
             const tempsDeclaration = lua.createVariableDeclarationStatement([tableTemp, indexTemp], [left.table, left.index]);
             // obj[index] = extractingExpression ?? defaultExpression
-            const [rightPrecedingStatements, rhs] = (0, _1.transformBinaryOperation)(context, extractingExpression, defaultExpression, defaultPrecedingStatements, ts.SyntaxKind.QuestionQuestionToken, node.initializer);
+            const { precedingStatements: rightPrecedingStatements, result: rhs } = (0, _1.transformBinaryOperation)(context, extractingExpression, defaultExpression, defaultPrecedingStatements, ts.SyntaxKind.QuestionQuestionToken, node.initializer);
             const assignStatement = lua.createAssignmentStatement(lua.createTableIndexExpression(tableTemp, indexTemp), rhs);
             destructureAssignmentStatements = [tempsDeclaration, ...rightPrecedingStatements, assignStatement];
         }

package/dist/transformation/visitors/binary-expression/index.d.ts

@@ -2,10 +2,11 @@ import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../../context";
 import { BitOperator } from "./bit";
+import { WithPrecedingStatements } from "../../utils/preceding-statements";
 type ShortCircuitOperator = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
 type SimpleOperator = ts.AdditiveOperatorOrHigher | Exclude<ts.RelationalOperator, ts.SyntaxKind.InstanceOfKeyword | ts.SyntaxKind.InKeyword> | ts.EqualityOperator | ts.LogicalOperator;
-export declare function createShortCircuitBinaryExpressionPrecedingStatements(context: TransformationContext, lhs: lua.Expression, rhs: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: ShortCircuitOperator, node?: ts.BinaryExpression): [lua.Statement[], lua.Expression];
-export declare function transformBinaryOperation(context: TransformationContext, left: lua.Expression, right: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: BitOperator | SimpleOperator | ts.SyntaxKind.QuestionQuestionToken, node: ts.Node): [lua.Statement[], lua.Expression];
+export declare function createShortCircuitBinaryExpressionPrecedingStatements(context: TransformationContext, lhs: lua.Expression, rhs: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: ShortCircuitOperator, node?: ts.BinaryExpression): WithPrecedingStatements<lua.Expression>;
+export declare function transformBinaryOperation(context: TransformationContext, left: lua.Expression, right: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: BitOperator | SimpleOperator | ts.SyntaxKind.QuestionQuestionToken, node: ts.Node): WithPrecedingStatements<lua.Expression>;
 export declare const transformBinaryExpression: FunctionVisitor<ts.BinaryExpression>;
 export declare function transformBinaryExpressionStatement(context: TransformationContext, node: ts.ExpressionStatement): lua.Statement[] | lua.Statement | undefined;
 export {};

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

@@ -78,23 +78,23 @@ function createShortCircuitBinaryExpressionPrecedingStatements(context, lhs, rhs
             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];
+    return { precedingStatements: [assignmentStatement, ifStatement], result: 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);
+    const { precedingStatements, result } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
+    return transformBinaryOperation(context, lhs, result, precedingStatements, 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),
-    ];
+    return {
+        precedingStatements: rightPrecedingStatements,
+        result: transformBinaryOperationWithNoPrecedingStatements(context, left, right, operator, node),
+    };
 }
 exports.transformBinaryOperation = transformBinaryOperation;
 const transformBinaryExpression = (node, context) => {
@@ -127,7 +127,7 @@ const transformBinaryExpression = (node, context) => {
         }
         case ts.SyntaxKind.CommaToken: {
             const statements = context.transformStatements(ts.factory.createExpressionStatement(node.left));
-            const [precedingStatements, result] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
+            const { precedingStatements, result } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
             statements.push(...precedingStatements);
             context.addPrecedingStatements(statements);
             return result;
@@ -135,14 +135,13 @@ const transformBinaryExpression = (node, context) => {
         case ts.SyntaxKind.QuestionQuestionToken:
         case ts.SyntaxKind.AmpersandAmpersandToken:
         case ts.SyntaxKind.BarBarToken: {
-            const [precedingStatements, result] = transformShortCircuitBinaryExpression(context, node, operator);
+            const { precedingStatements, result } = transformShortCircuitBinaryExpression(context, node, operator);
             context.addPrecedingStatements(precedingStatements);
             return result;
         }
     }
-    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);
+    const { precedingStatements: orderedExpressionPrecedingStatements, result: [lhs, rhs], } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.transformOrderedExpressions)(context, [node.left, node.right]));
+    const { precedingStatements, result } = transformBinaryOperation(context, lhs, rhs, orderedExpressionPrecedingStatements, operator, node);
     context.addPrecedingStatements(precedingStatements);
     return result;
 };
@@ -174,7 +173,7 @@ function transformNullishCoalescingOperationNoPrecedingStatements(context, node,
     // Check if we can take a shortcut to 'lhs or rhs' if the left-hand side cannot be 'false'.
     if ((0, typescript_1.canBeFalsyWhenNotNull)(context, lhsType)) {
         // reuse logic from case with preceding statements
-        const [precedingStatements, result] = createShortCircuitBinaryExpressionPrecedingStatements(context, transformedLeft, transformedRight, [], ts.SyntaxKind.QuestionQuestionToken, node);
+        const { precedingStatements, result } = createShortCircuitBinaryExpressionPrecedingStatements(context, transformedLeft, transformedRight, [], ts.SyntaxKind.QuestionQuestionToken, node);
         context.addPrecedingStatements(precedingStatements);
         return result;
     }

package/dist/transformation/visitors/call.js

@@ -55,7 +55,7 @@ function transformCallWithArguments(context, callExpression, transformedArgument
     return [call, transformedArguments];
 }
 function transformCallAndArguments(context, callExpression, params, signature, callContext) {
-    const [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, params, signature, callContext));
+    const { precedingStatements: argPrecedingStatements, result: transformedArguments } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, params, signature, callContext));
     return transformCallWithArguments(context, callExpression, transformedArguments, argPrecedingStatements);
 }
 exports.transformCallAndArguments = transformCallAndArguments;
@@ -82,7 +82,7 @@ function transformContextualCallExpression(context, node, args, signature) {
         return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
     const left = ts.isCallExpression(node) ? getCalledExpression(node) : node.tag;
-    let [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
+    let { precedingStatements: argPrecedingStatements, result: transformedArguments } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
     if (ts.isPropertyAccessExpression(left) &&
         ts.isIdentifier(left.name) &&
         (0, safe_names_1.isValidLuaIdentifier)(left.name.text, context.options) &&

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

@@ -20,7 +20,7 @@ const transformClassDeclaration = (declaration, context) => {
     // If declaration is a default export, transform to export variable assignment instead
     if ((0, export_1.hasDefaultExportModifier)(declaration)) {
         // Class declaration including assignment to ____exports.default are in preceding statements
-        const [precedingStatements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        const { precedingStatements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
             transformClassAsExpression(declaration, context);
             return [];
         });

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

@@ -22,7 +22,7 @@ exports.createPropertyDecoratingExpression = createPropertyDecoratingExpression;
 function transformClassInstanceFields(context, instanceFields) {
     const statements = [];
     for (const f of instanceFields) {
-        const [precedingStatements, statement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        const { precedingStatements, result: statement } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
             // Get identifier
             const fieldName = (0, literal_1.transformPropertyName)(context, f.name);
             const value = f.initializer ? context.transformExpression(f.initializer) : undefined;

package/dist/transformation/visitors/conditional.js

@@ -10,12 +10,12 @@ const typescript_1 = require("../utils/typescript");
 const diagnostics_1 = require("../utils/diagnostics");
 function transformProtectedConditionalExpression(context, expression, condition, whenTrue, whenFalse) {
     const tempVar = context.createTempNameForNode(expression.condition);
-    const trueStatements = whenTrue[0].concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenTrue[1], expression.whenTrue));
-    const falseStatements = whenFalse[0].concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenFalse[1], expression.whenFalse));
+    const trueStatements = whenTrue.precedingStatements.concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenTrue.result, expression.whenTrue));
+    const falseStatements = whenFalse.precedingStatements.concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenFalse.result, expression.whenFalse));
     context.addPrecedingStatements([
         lua.createVariableDeclarationStatement(tempVar, undefined, expression.condition),
-        ...condition[0],
-        lua.createIfStatement(condition[1], lua.createBlock(trueStatements, expression.whenTrue), lua.createBlock(falseStatements, expression.whenFalse), expression),
+        ...condition.precedingStatements,
+        lua.createIfStatement(condition.result, lua.createBlock(trueStatements, expression.whenTrue), lua.createBlock(falseStatements, expression.whenFalse), expression),
     ]);
     return lua.cloneIdentifier(tempVar);
 }
@@ -25,15 +25,15 @@ const transformConditionalExpression = (expression, context) => {
     const condition = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.condition));
     const whenTrue = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.whenTrue));
     const whenFalse = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.whenFalse));
-    if (whenTrue[0].length > 0 ||
-        whenFalse[0].length > 0 ||
+    if (whenTrue.precedingStatements.length > 0 ||
+        whenFalse.precedingStatements.length > 0 ||
         (0, typescript_1.canBeFalsy)(context, context.checker.getTypeAtLocation(expression.whenTrue))) {
         return transformProtectedConditionalExpression(context, expression, condition, whenTrue, whenFalse);
     }
     // condition and v1 or v2
-    context.addPrecedingStatements(condition[0]);
-    const conditionAnd = lua.createBinaryExpression(condition[1], whenTrue[1], lua.SyntaxKind.AndOperator);
-    return lua.createBinaryExpression(conditionAnd, whenFalse[1], lua.SyntaxKind.OrOperator, expression);
+    context.addPrecedingStatements(condition.precedingStatements);
+    const conditionAnd = lua.createBinaryExpression(condition.result, whenTrue.result, lua.SyntaxKind.AndOperator);
+    return lua.createBinaryExpression(conditionAnd, whenFalse.result, lua.SyntaxKind.OrOperator, expression);
 };
 exports.transformConditionalExpression = transformConditionalExpression;
 function transformIfStatement(statement, context) {
@@ -47,7 +47,7 @@ function transformIfStatement(statement, context) {
     if (statement.elseStatement) {
         if (ts.isIfStatement(statement.elseStatement)) {
             const tsElseStatement = statement.elseStatement;
-            const [precedingStatements, elseStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformIfStatement(tsElseStatement, context));
+            const { precedingStatements, result: elseStatement } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformIfStatement(tsElseStatement, context));
             // If else-if condition generates preceding statements, we can't use elseif, we have to break it down:
             // if conditionA then
             //     ...

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

@@ -34,7 +34,7 @@ function transformExpressions(context, expressions) {
     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]));
+        const { precedingStatements: expressionPrecedingStatements, result: expression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expressions[i]));
         transformedExpressions.push(expression);
         if (expressionPrecedingStatements.length > 0) {
             lastPrecedingStatementsIndex = i;

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

@@ -1,5 +1,5 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
-import { FunctionVisitor, TransformationContext } from "../context";
+import { FunctionVisitor } from "../context";
 export declare const transformExpressionStatement: FunctionVisitor<ts.ExpressionStatement>;
-export declare function transformExpressionToStatement(context: TransformationContext, expression: ts.Expression): lua.Statement | undefined;
+export declare function wrapInStatement(result: lua.Expression): lua.Statement | undefined;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformExpressionToStatement = exports.transformExpressionStatement = void 0;
+exports.wrapInStatement = exports.transformExpressionStatement = void 0;
 const lua = require("../../LuaAST");
 const context_1 = require("../context");
 const binary_expression_1 = require("./binary-expression");
@@ -14,11 +14,10 @@ const transformExpressionStatement = (node, context) => {
     if (binaryExpressionResult) {
         return binaryExpressionResult;
     }
-    return transformExpressionToStatement(context, node.expression);
+    return wrapInStatement(context.transformExpression(node.expression));
 };
 exports.transformExpressionStatement = transformExpressionStatement;
-function transformExpressionToStatement(context, expression) {
-    const result = context.transformExpression(expression);
+function wrapInStatement(result) {
     const isTempVariable = lua.isIdentifier(result) && result.symbolId === context_1.tempSymbolId;
     if (isTempVariable) {
         return undefined;
@@ -34,5 +33,5 @@ function transformExpressionToStatement(context, expression) {
     // Assign expression statements to dummy to make sure they're legal Lua
     return lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), result);
 }
-exports.transformExpressionToStatement = transformExpressionToStatement;
+exports.wrapInStatement = wrapInStatement;
 //# sourceMappingURL=expression-statement.js.map

package/dist/transformation/visitors/function.js

@@ -69,7 +69,7 @@ function isFunctionTypeWithProperties(context, functionType) {
 exports.isFunctionTypeWithProperties = isFunctionTypeWithProperties;
 function transformFunctionBodyContent(context, body) {
     if (!ts.isBlock(body)) {
-        const [precedingStatements, returnStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, return_1.transformExpressionBodyToReturnStatement)(context, body));
+        const { precedingStatements, result: returnStatement } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, return_1.transformExpressionBodyToReturnStatement)(context, body));
         return [...precedingStatements, returnStatement];
     }
     const bodyStatements = (0, scope_1.performHoisting)(context, context.transformStatements(body.statements));
@@ -90,7 +90,7 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
             }
             // Binding pattern
             const name = declaration.name;
-            const [precedingStatements, bindings] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, name, identifier));
+            const { precedingStatements, result: bindings } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, name, identifier));
             bindingPatternDeclarations.push(...precedingStatements, ...bindings);
         }
         else if (declaration.initializer !== undefined) {

package/dist/transformation/visitors/identifier.js

@@ -21,7 +21,9 @@ function transformIdentifier(context, identifier) {
 exports.transformIdentifier = transformIdentifier;
 function transformNonValueIdentifier(context, identifier, symbol) {
     if ((0, optional_chaining_1.isOptionalContinuation)(identifier)) {
-        return lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
+        const result = lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
+        (0, optional_chaining_1.getOptionalContinuationData)(identifier).usedIdentifiers.push(result);
+        return result;
     }
     const extensionKind = symbol
         ? (0, language_extensions_1.getExtensionKindForSymbol)(context, symbol)

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

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.operatorExtensionTransformers = void 0;
-const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
 const CompilerOptions_1 = require("../../../CompilerOptions");
 const diagnostics_1 = require("../../utils/diagnostics");
 const language_extensions_1 = require("../../utils/language-extensions");
+const expression_list_1 = require("../expression-list");
 const binaryOperatorMappings = new Map([
     [language_extensions_1.ExtensionKind.AdditionOperatorType, lua.SyntaxKind.AdditionOperator],
     [language_extensions_1.ExtensionKind.AdditionOperatorMethodType, lua.SyntaxKind.AdditionOperator],
@@ -76,26 +76,20 @@ for (const kind of unaryOperatorMappings.keys()) {
 function transformBinaryOperator(context, node, kind) {
     if (requiresLua53.has(kind))
         checkHasLua53(context, node, kind);
-    let args = node.arguments;
-    if (args.length === 1 &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        args = [node.expression.expression, ...args];
-    }
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, kind);
+    if (!args)
+        return lua.createNilLiteral();
+    const [left, right] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     const luaOperator = binaryOperatorMappings.get(kind);
     (0, utils_1.assert)(luaOperator);
-    return lua.createBinaryExpression(context.transformExpression(args[0]), context.transformExpression(args[1]), luaOperator);
+    return lua.createBinaryExpression(left, right, luaOperator);
 }
 function transformUnaryOperator(context, node, kind) {
     if (requiresLua53.has(kind))
         checkHasLua53(context, node, kind);
-    let arg;
-    if (node.arguments.length === 0 &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        arg = node.expression.expression;
-    }
-    else {
-        arg = node.arguments[0];
-    }
+    const arg = (0, language_extensions_1.getUnaryCallExtensionArg)(context, node, kind);
+    if (!arg)
+        return lua.createNilLiteral();
     const luaOperator = unaryOperatorMappings.get(kind);
     (0, utils_1.assert)(luaOperator);
     return lua.createUnaryExpression(context.transformExpression(arg), luaOperator);

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

@@ -1,9 +1,7 @@
 import * as ts from "typescript";
 import { TransformationContext } from "../../context";
 import { ExtensionKind } from "../../utils/language-extensions";
-import { LanguageExtensionCallTransformer } from "./call-extension";
+import { LanguageExtensionCallTransformerMap } from "./call-extension";
 export declare function isTableNewCall(context: TransformationContext, node: ts.NewExpression): boolean;
 export declare const tableNewExtensions: ExtensionKind[];
-export declare const tableExtensionTransformers: {
-    [P in ExtensionKind]?: LanguageExtensionCallTransformer;
-};
+export declare const tableExtensionTransformers: LanguageExtensionCallTransformerMap;