typescript-to-lua 1.1.1 → 1.2.0

package/dist/transformation/visitors/access.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformQualifiedName = exports.transformPropertyAccessExpression = exports.transformElementAccessExpression = exports.transformElementAccessArgument = void 0;
+exports.transformQualifiedName = exports.transformPropertyAccessExpressionWithCapture = exports.transformPropertyAccessExpression = exports.transformElementAccessExpressionWithCapture = exports.transformElementAccessExpression = exports.transformElementAccessArgument = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
@@ -10,9 +10,10 @@ const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
 const typescript_1 = require("../utils/typescript");
 const enum_1 = require("./enum");
+const expression_list_1 = require("./expression-list");
 const multi_1 = require("./language-extensions/multi");
-function transformElementAccessArgument(context, node) {
-    const index = context.transformExpression(node.argumentExpression);
+const optional_chaining_1 = require("./optional-chaining");
+function addOneToArrayAccessArgument(context, node, index) {
     const type = context.checker.getTypeAtLocation(node.expression);
     const argumentType = context.checker.getTypeAtLocation(node.argumentExpression);
     if ((0, typescript_1.isArrayType)(context, type) && (0, typescript_1.isNumberType)(context, argumentType)) {
@@ -20,20 +21,31 @@ function transformElementAccessArgument(context, node) {
     }
     return index;
 }
+function transformElementAccessArgument(context, node) {
+    const index = context.transformExpression(node.argumentExpression);
+    return addOneToArrayAccessArgument(context, node, index);
+}
 exports.transformElementAccessArgument = transformElementAccessArgument;
-const transformElementAccessExpression = (node, context) => {
+const transformElementAccessExpression = (node, context) => transformElementAccessExpressionWithCapture(context, node, undefined).expression;
+exports.transformElementAccessExpression = transformElementAccessExpression;
+function transformElementAccessExpressionWithCapture(context, node, thisValueCapture) {
     const constEnumValue = (0, enum_1.tryGetConstEnumValue)(context, node);
     if (constEnumValue) {
-        return constEnumValue;
+        return { expression: constEnumValue };
     }
-    const table = context.transformExpression(node.expression);
+    if (ts.isOptionalChain(node)) {
+        return (0, optional_chaining_1.transformOptionalChainWithCapture)(context, node, thisValueCapture);
+    }
+    const [table, accessExpression] = (0, expression_list_1.transformOrderedExpressions)(context, [node.expression, node.argumentExpression]);
     const type = context.checker.getTypeAtLocation(node.expression);
     const argumentType = context.checker.getTypeAtLocation(node.argumentExpression);
     if ((0, typescript_1.isStringType)(context, type) && (0, typescript_1.isNumberType)(context, argumentType)) {
-        const index = context.transformExpression(node.argumentExpression);
-        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringAccess, node, table, index);
+        // strings are not callable, so ignore thisValueCapture
+        return {
+            expression: (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringAccess, node, table, accessExpression),
+        };
     }
-    const accessExpression = transformElementAccessArgument(context, node);
+    const updatedAccessExpression = addOneToArrayAccessArgument(context, node, accessExpression);
     if ((0, multi_1.isMultiReturnCall)(context, node.expression)) {
         const accessType = context.checker.getTypeAtLocation(node.argumentExpression);
         if (!(0, typescript_1.isNumberType)(context, accessType)) {
@@ -41,61 +53,76 @@ const transformElementAccessExpression = (node, context) => {
         }
         // When selecting the first element, we can shortcut
         if (ts.isNumericLiteral(node.argumentExpression) && node.argumentExpression.text === "0") {
-            return table;
+            return { expression: table };
         }
         else {
             const selectIdentifier = lua.createIdentifier("select");
-            const selectCall = lua.createCallExpression(selectIdentifier, [accessExpression, table]);
-            return selectCall;
+            return { expression: lua.createCallExpression(selectIdentifier, [updatedAccessExpression, table]) };
         }
     }
-    if (ts.isOptionalChain(node)) {
-        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalChainAccess, node, table, accessExpression);
+    if (thisValueCapture) {
+        const thisValue = (0, optional_chaining_1.captureThisValue)(context, table, thisValueCapture, node.expression);
+        return {
+            expression: lua.createTableIndexExpression(thisValue, updatedAccessExpression, node),
+            thisValue,
+        };
     }
-    return lua.createTableIndexExpression(table, accessExpression, node);
-};
-exports.transformElementAccessExpression = transformElementAccessExpression;
-const transformPropertyAccessExpression = (node, context) => {
+    return { expression: lua.createTableIndexExpression(table, updatedAccessExpression, node) };
+}
+exports.transformElementAccessExpressionWithCapture = transformElementAccessExpressionWithCapture;
+const transformPropertyAccessExpression = (node, context) => transformPropertyAccessExpressionWithCapture(context, node, undefined).expression;
+exports.transformPropertyAccessExpression = transformPropertyAccessExpression;
+function transformPropertyAccessExpressionWithCapture(context, node, thisValueCapture) {
     const property = node.name.text;
     const type = context.checker.getTypeAtLocation(node.expression);
+    const isOptionalLeft = (0, optional_chaining_1.isOptionalContinuation)(node.expression);
     const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
         context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
     }
     const constEnumValue = (0, enum_1.tryGetConstEnumValue)(context, node);
     if (constEnumValue) {
-        return constEnumValue;
-    }
-    const builtinResult = (0, builtins_1.transformBuiltinPropertyAccessExpression)(context, node);
-    if (builtinResult) {
-        return builtinResult;
+        return { expression: constEnumValue };
     }
     if (ts.isCallExpression(node.expression) && (0, multi_1.returnsMultiType)(context, node.expression)) {
         context.diagnostics.push((0, diagnostics_1.invalidMultiReturnAccess)(node));
     }
+    if (ts.isOptionalChain(node)) {
+        return (0, optional_chaining_1.transformOptionalChainWithCapture)(context, node, thisValueCapture);
+    }
     // Do not output path for member only enums
     if (annotations.has(annotations_1.AnnotationKind.CompileMembersOnly)) {
+        if (isOptionalLeft) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedOptionalCompileMembersOnly)(node));
+        }
         if (ts.isPropertyAccessExpression(node.expression)) {
             // in case of ...x.enum.y transform to ...x.y
-            return lua.createTableIndexExpression(context.transformExpression(node.expression.expression), lua.createStringLiteral(property), node);
+            const expression = lua.createTableIndexExpression(context.transformExpression(node.expression.expression), lua.createStringLiteral(property), node);
+            return { expression };
         }
         else {
-            return lua.createIdentifier(property, node);
+            return { expression: lua.createIdentifier(property, node) };
         }
     }
-    if (ts.isOptionalChain(node)) {
-        // Only handle full optional chains separately, not partial ones
-        return transformOptionalChain(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinPropertyAccessExpression)(context, node);
+    if (builtinResult) {
+        // Ignore thisValueCapture.
+        // This assumes that nothing returned by builtin property accesses are callable.
+        // If this assumption is no longer true, this may need to be updated.
+        return { expression: builtinResult };
     }
-    const callPath = context.transformExpression(node.expression);
-    return lua.createTableIndexExpression(callPath, lua.createStringLiteral(property), node);
-};
-exports.transformPropertyAccessExpression = transformPropertyAccessExpression;
-function transformOptionalChain(context, node) {
-    const left = context.transformExpression(node.expression);
-    const right = lua.createStringLiteral(node.name.text, node.name);
-    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalChainAccess, node, left, right);
+    const table = context.transformExpression(node.expression);
+    if (thisValueCapture) {
+        const thisValue = (0, optional_chaining_1.captureThisValue)(context, table, thisValueCapture, node.expression);
+        const expression = lua.createTableIndexExpression(thisValue, lua.createStringLiteral(property), node);
+        return {
+            expression,
+            thisValue,
+        };
+    }
+    return { expression: lua.createTableIndexExpression(table, lua.createStringLiteral(property), node) };
 }
+exports.transformPropertyAccessExpressionWithCapture = transformPropertyAccessExpressionWithCapture;
 const transformQualifiedName = (node, context) => {
     const right = lua.createStringLiteral(node.right.text, node.right);
     const left = context.transformExpression(node.left);

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

@@ -1,7 +1,8 @@
 import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
-export declare function transformAssignmentLeftHandSideExpression(context: TransformationContext, node: ts.Expression): lua.AssignmentLeftHandSideExpression;
-export declare function transformAssignment(context: TransformationContext, lhs: ts.Expression, right: lua.Expression, parent?: ts.Expression): lua.Statement[];
+export declare function transformAssignmentLeftHandSideExpression(context: TransformationContext, node: ts.Expression, rightHasPrecedingStatements?: boolean): lua.AssignmentLeftHandSideExpression;
+export declare function transformAssignment(context: TransformationContext, lhs: ts.Expression, right: lua.Expression, rightHasPrecedingStatements?: boolean, parent?: ts.Expression): lua.Statement[];
+export declare function transformAssignmentWithRightPrecedingStatements(context: TransformationContext, lhs: ts.Expression, right: lua.Expression, rightPrecedingStatements: lua.Statement[], parent?: ts.Expression): lua.Statement[];
 export declare function transformAssignmentExpression(context: TransformationContext, expression: ts.AssignmentExpression<ts.EqualsToken>): lua.Expression;
 export declare function transformAssignmentStatement(context: TransformationContext, expression: ts.AssignmentExpression<ts.EqualsToken>): lua.Statement[];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformAssignmentStatement = exports.transformAssignmentExpression = exports.transformAssignment = exports.transformAssignmentLeftHandSideExpression = void 0;
+exports.transformAssignmentStatement = exports.transformAssignmentExpression = exports.transformAssignmentWithRightPrecedingStatements = exports.transformAssignment = exports.transformAssignmentLeftHandSideExpression = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
@@ -9,13 +9,27 @@ const export_1 = require("../../utils/export");
 const lua_ast_1 = require("../../utils/lua-ast");
 const lualib_1 = require("../../utils/lualib");
 const typescript_1 = require("../../utils/typescript");
-const access_1 = require("../access");
 const destructuring_assignments_1 = require("./destructuring-assignments");
 const multi_1 = require("../language-extensions/multi");
-const scope_1 = require("../../utils/scope");
-const transform_1 = require("../../utils/transform");
 const diagnostics_1 = require("../../utils/diagnostics");
-function transformAssignmentLeftHandSideExpression(context, node) {
+const access_1 = require("../access");
+const expression_list_1 = require("../expression-list");
+const preceding_statements_1 = require("../../utils/preceding-statements");
+function transformAssignmentLeftHandSideExpression(context, node, rightHasPrecedingStatements) {
+    // Access expressions need the components of the left side cached in temps before the right side's preceding statements
+    if (rightHasPrecedingStatements && (ts.isElementAccessExpression(node) || ts.isPropertyAccessExpression(node))) {
+        let table = context.transformExpression(node.expression);
+        table = (0, expression_list_1.moveToPrecedingTemp)(context, table, node.expression);
+        let index;
+        if (ts.isElementAccessExpression(node)) {
+            index = (0, access_1.transformElementAccessArgument)(context, node);
+            index = (0, expression_list_1.moveToPrecedingTemp)(context, index, node.argumentExpression);
+        }
+        else {
+            index = lua.createStringLiteral(node.name.text, node.name);
+        }
+        return lua.createTableIndexExpression(table, index, node);
+    }
     const symbol = context.checker.getSymbolAtLocation(node);
     const left = context.transformExpression(node);
     return lua.isIdentifier(left) && symbol && (0, export_1.isSymbolExported)(context, symbol)
@@ -25,7 +39,7 @@ function transformAssignmentLeftHandSideExpression(context, node) {
 exports.transformAssignmentLeftHandSideExpression = transformAssignmentLeftHandSideExpression;
 function transformAssignment(context, 
 // TODO: Change type to ts.LeftHandSideExpression?
-lhs, right, parent) {
+lhs, right, rightHasPrecedingStatements, parent) {
     if (ts.isOptionalChain(lhs)) {
         context.diagnostics.push((0, diagnostics_1.notAllowedOptionalAssignment)(lhs));
         return [];
@@ -34,11 +48,11 @@ lhs, right, parent) {
         const arrayLengthAssignment = lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, parent, context.transformExpression(lhs.expression), right));
         return [arrayLengthAssignment];
     }
-    const symbol = ts.isShorthandPropertyAssignment(lhs.parent)
+    const symbol = lhs.parent && ts.isShorthandPropertyAssignment(lhs.parent)
         ? context.checker.getShorthandAssignmentValueSymbol(lhs.parent)
         : context.checker.getSymbolAtLocation(lhs);
     const dependentSymbols = symbol ? (0, export_1.getDependenciesOfSymbol)(context, symbol) : [];
-    const left = transformAssignmentLeftHandSideExpression(context, lhs);
+    const left = transformAssignmentLeftHandSideExpression(context, lhs, rightHasPrecedingStatements);
     const rootAssignment = lua.createAssignmentStatement(left, right, lhs.parent);
     return [
         rootAssignment,
@@ -50,15 +64,23 @@ lhs, right, parent) {
     ];
 }
 exports.transformAssignment = transformAssignment;
+function transformAssignmentWithRightPrecedingStatements(context, lhs, right, rightPrecedingStatements, parent) {
+    return [
+        ...rightPrecedingStatements,
+        ...transformAssignment(context, lhs, right, rightPrecedingStatements.length > 0, parent),
+    ];
+}
+exports.transformAssignmentWithRightPrecedingStatements = transformAssignmentWithRightPrecedingStatements;
 function transformDestructuredAssignmentExpression(context, expression) {
-    const rootIdentifier = lua.createAnonymousIdentifier(expression.left);
-    let right = context.transformExpression(expression.right);
+    const rootIdentifier = context.createTempNameForNode(expression.right);
+    let [rightPrecedingStatements, 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);
     }
     const statements = [
         lua.createVariableDeclarationStatement(rootIdentifier, right),
-        ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier),
+        ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier, rightPrecedingStatements.length > 0),
     ];
     return { statements, result: rootIdentifier };
 }
@@ -72,48 +94,28 @@ function transformAssignmentExpression(context, expression) {
         return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, expression, context.transformExpression(expression.left.expression), context.transformExpression(expression.right));
     }
     if ((0, typescript_1.isDestructuringAssignment)(expression)) {
-        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => transformDestructuredAssignmentExpression(context, expression), expression);
+        const { statements, result } = transformDestructuredAssignmentExpression(context, expression);
+        context.addPrecedingStatements(statements);
+        return result;
     }
     if (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) {
-        // Left is property/element access: cache result while maintaining order of evaluation
-        // (function(o, i, v) o[i] = v; return v end)(${objExpression}, ${indexExpression}, ${right})
-        const objParameter = lua.createIdentifier("o");
-        const indexParameter = lua.createIdentifier("i");
-        const valueParameter = lua.createIdentifier("v");
-        const indexStatement = lua.createTableIndexExpression(objParameter, indexParameter);
-        const statements = [
-            lua.createAssignmentStatement(indexStatement, valueParameter),
-            lua.createReturnStatement([valueParameter]),
-        ];
-        const iife = lua.createFunctionExpression(lua.createBlock(statements), [
-            objParameter,
-            indexParameter,
-            valueParameter,
+        const tempVar = context.createTempNameForNode(expression.right);
+        const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        const left = transformAssignmentLeftHandSideExpression(context, expression.left, precedingStatements.length > 0);
+        context.addPrecedingStatements([
+            ...precedingStatements,
+            lua.createVariableDeclarationStatement(tempVar, right, expression.right),
+            lua.createAssignmentStatement(left, lua.cloneIdentifier(tempVar), expression.left),
         ]);
-        (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
-        const objExpression = context.transformExpression(expression.left.expression);
-        let indexExpression;
-        if (ts.isPropertyAccessExpression(expression.left)) {
-            // Property access
-            indexExpression = lua.createStringLiteral(expression.left.name.text);
-        }
-        else {
-            // Element access
-            indexExpression = (0, access_1.transformElementAccessArgument)(context, expression.left);
-        }
-        const args = [objExpression, indexExpression, context.transformExpression(expression.right)];
-        (0, scope_1.popScope)(context);
-        return lua.createCallExpression(iife, args, expression);
+        return lua.cloneIdentifier(tempVar);
     }
     else {
-        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => {
-            // Simple assignment
-            // (function() ${left} = ${right}; return ${left} end)()
-            const left = context.transformExpression(expression.left);
-            const right = context.transformExpression(expression.right);
-            const statements = transformAssignment(context, expression.left, right);
-            return { statements, result: left };
-        }, expression);
+        // Simple assignment
+        // ${left} = ${right}; return ${left}
+        const left = context.transformExpression(expression.left);
+        const right = context.transformExpression(expression.right);
+        context.addPrecedingStatements(transformAssignment(context, expression.left, right));
+        return left;
     }
 }
 exports.transformAssignmentExpression = transformAssignmentExpression;
@@ -123,7 +125,9 @@ const canBeTransformedToLuaAssignmentStatement = (context, node) => ts.isArrayLi
             return false;
         }
         if (ts.isPropertyAccessExpression(element) || ts.isElementAccessExpression(element)) {
-            return true;
+            // Lua's execution order for multi-assignments is not the same as JS's, so we should always
+            // break these down when the left side may have side effects.
+            return false;
         }
         if (ts.isIdentifier(element)) {
             const symbol = context.checker.getSymbolAtLocation(element);
@@ -141,28 +145,33 @@ function transformAssignmentStatement(context, expression) {
     if ((0, typescript_1.isDestructuringAssignment)(expression)) {
         if (canBeTransformedToLuaAssignmentStatement(context, expression)) {
             const rightType = context.checker.getTypeAtLocation(expression.right);
-            let right = context.transformExpression(expression.right);
+            let right;
             if (ts.isArrayLiteralExpression(expression.right)) {
-                right = expression.right.elements.map(e => context.transformExpression(e));
+                right = (0, expression_list_1.transformExpressionList)(context, expression.right.elements);
             }
-            else if (!(0, multi_1.isMultiReturnCall)(context, expression.right) && (0, typescript_1.isArrayType)(context, rightType)) {
-                right = (0, lua_ast_1.createUnpackCall)(context, right, expression.right);
+            else {
+                right = context.transformExpression(expression.right);
+                if (!(0, multi_1.isMultiReturnCall)(context, expression.right) && (0, typescript_1.isArrayType)(context, rightType)) {
+                    right = (0, lua_ast_1.createUnpackCall)(context, right, expression.right);
+                }
             }
             const left = expression.left.elements.map(e => transformAssignmentLeftHandSideExpression(context, e));
             return [lua.createAssignmentStatement(left, right, expression)];
         }
-        let right = context.transformExpression(expression.right);
+        let [rightPrecedingStatements, 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);
         }
-        const rootIdentifier = lua.createAnonymousIdentifier(expression.left);
+        const rootIdentifier = context.createTempNameForNode(expression.left);
         return [
             lua.createVariableDeclarationStatement(rootIdentifier, right),
-            ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier),
+            ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier, rightPrecedingStatements.length > 0),
         ];
     }
     else {
-        return transformAssignment(context, expression.left, context.transformExpression(expression.right));
+        const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        return transformAssignmentWithRightPrecedingStatements(context, expression.left, right, precedingStatements);
     }
 }
 exports.transformAssignmentStatement = transformAssignmentStatement;

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

@@ -1,12 +1,13 @@
 import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
-import { ImmediatelyInvokedFunctionParameters } from "../../utils/transform";
-export declare function parseAccessExpressionWithEvaluationEffects(context: TransformationContext, node: ts.Expression): [ts.Expression, ts.Expression] | [];
 declare 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): ImmediatelyInvokedFunctionParameters;
-export declare function transformCompoundAssignmentExpression(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): lua.CallExpression;
+export declare function transformCompoundAssignment(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): {
+    statements: lua.Statement[];
+    result: lua.AssignmentLeftHandSideExpression;
+};
+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 {};