typescript-to-lua 1.1.1 → 1.2.0

package/dist/transformation/visitors/function.js

@@ -10,6 +10,7 @@ const export_1 = require("../utils/export");
 const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const async_await_1 = require("./async-await");
 const identifier_1 = require("./identifier");
@@ -34,8 +35,8 @@ function isRestParameterReferenced(identifier, scope) {
 }
 function transformFunctionBodyContent(context, body) {
     if (!ts.isBlock(body)) {
-        const returnStatement = (0, return_1.transformExpressionBodyToReturnStatement)(context, body);
-        return [returnStatement];
+        const [precedingStatements, returnStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, return_1.transformExpressionBodyToReturnStatement)(context, body));
+        return [...precedingStatements, returnStatement];
     }
     const bodyStatements = (0, scope_1.performHoisting)(context, context.transformStatements(body.statements));
     return bodyStatements;
@@ -163,14 +164,11 @@ function transformFunctionLikeDeclaration(node, context) {
         if (symbol) {
             // TODO: Not using symbol ids because of https://github.com/microsoft/TypeScript/issues/37131
             const isReferenced = [...functionScope.referencedSymbols].some(([, nodes]) => nodes.some(n => { var _a; return ((_a = context.checker.getSymbolAtLocation(n)) === null || _a === void 0 ? void 0 : _a.valueDeclaration) === symbol.valueDeclaration; }));
-            // Only wrap if the name is actually referenced inside the function
+            // Only handle if the name is actually referenced inside the function
             if (isReferenced) {
                 const nameIdentifier = (0, identifier_1.transformIdentifier)(context, node.name);
-                // We cannot use transformToImmediatelyInvokedFunctionExpression() here because we need to transpile
-                // the function first to determine if it's self-referencing. Fortunately, this does not cause issues
-                // with var-arg optimization because the IIFE is just wrapping another function which will already push
-                // another scope.
-                return (0, lua_ast_1.createImmediatelyInvokedFunctionExpression)([lua.createVariableDeclarationStatement(nameIdentifier, functionExpression)], lua.cloneIdentifier(nameIdentifier));
+                context.addPrecedingStatements(lua.createVariableDeclarationStatement(nameIdentifier, functionExpression));
+                return lua.cloneIdentifier(nameIdentifier);
             }
         }
     }

package/dist/transformation/visitors/identifier.js

@@ -16,7 +16,11 @@ const operators_1 = require("./language-extensions/operators");
 const range_1 = require("./language-extensions/range");
 const table_1 = require("./language-extensions/table");
 const vararg_1 = require("./language-extensions/vararg");
+const optional_chaining_1 = require("./optional-chaining");
 function transformIdentifier(context, identifier) {
+    if ((0, optional_chaining_1.isOptionalContinuation)(identifier)) {
+        return lua.createIdentifier(identifier.text);
+    }
     if ((0, multi_1.isMultiFunctionNode)(context, identifier)) {
         context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(identifier));
         return lua.createAnonymousIdentifier(identifier);

package/dist/transformation/visitors/literal.js

@@ -11,7 +11,7 @@ const safe_names_1 = require("../utils/safe-names");
 const symbols_1 = require("../utils/symbols");
 const typescript_1 = require("../utils/typescript");
 const function_1 = require("./function");
-const call_1 = require("./call");
+const expression_list_1 = require("./expression-list");
 const multi_1 = require("./language-extensions/multi");
 // TODO: Move to object-literal.ts?
 function transformPropertyName(context, node) {
@@ -61,13 +61,27 @@ const transformObjectLiteralExpression = (expression, context) => {
         context.diagnostics.push(...violations.map(e => (0, diagnostics_1.invalidMultiFunctionUse)(e)));
         return lua.createNilLiteral(expression);
     }
-    let properties = [];
-    const tableExpressions = [];
-    for (const element of expression.properties) {
+    const properties = [];
+    const initializers = [];
+    const keyPrecedingStatements = [];
+    const valuePrecedingStatements = [];
+    let lastPrecedingStatementsIndex = -1;
+    for (let i = 0; i < expression.properties.length; ++i) {
+        const element = expression.properties[i];
+        // Transform key and cache preceding statements
+        context.pushPrecedingStatements();
         const name = element.name ? transformPropertyName(context, element.name) : undefined;
+        let precedingStatements = context.popPrecedingStatements();
+        keyPrecedingStatements.push(precedingStatements);
+        if (precedingStatements.length > 0) {
+            lastPrecedingStatementsIndex = i;
+        }
+        // Transform value and cache preceding statements
+        context.pushPrecedingStatements();
         if (ts.isPropertyAssignment(element)) {
             const expression = context.transformExpression(element.initializer);
             properties.push(lua.createTableFieldExpression(expression, name, element));
+            initializers.push(element.initializer);
         }
         else if (ts.isShorthandPropertyAssignment(element)) {
             const valueSymbol = context.checker.getShorthandAssignmentValueSymbol(element);
@@ -76,19 +90,14 @@ const transformObjectLiteralExpression = (expression, context) => {
             }
             const identifier = createShorthandIdentifier(context, valueSymbol, element.name);
             properties.push(lua.createTableFieldExpression(identifier, name, element));
+            initializers.push(element);
         }
         else if (ts.isMethodDeclaration(element)) {
             const expression = (0, function_1.transformFunctionLikeDeclaration)(element, context);
             properties.push(lua.createTableFieldExpression(expression, name, element));
+            initializers.push(element);
         }
         else if (ts.isSpreadAssignment(element)) {
-            // Create a table for preceding properties to preserve property order
-            // { x: 0, ...{ y: 2 }, y: 1, z: 2 } --> __TS__ObjectAssign({x = 0}, {y = 2}, {y = 1, z = 2})
-            if (properties.length > 0) {
-                const tableExpression = lua.createTableExpression(properties, expression);
-                tableExpressions.push(tableExpression);
-                properties = [];
-            }
             const type = context.checker.getTypeAtLocation(element.expression);
             let tableExpression;
             if ((0, typescript_1.isArrayType)(context, type)) {
@@ -97,7 +106,8 @@ const transformObjectLiteralExpression = (expression, context) => {
             else {
                 tableExpression = context.transformExpression(element.expression);
             }
-            tableExpressions.push(tableExpression);
+            properties.push(tableExpression);
+            initializers.push(element.expression);
         }
         else if (ts.isAccessor(element)) {
             context.diagnostics.push((0, diagnostics_1.unsupportedAccessorInObjectLiteral)(element));
@@ -105,13 +115,56 @@ const transformObjectLiteralExpression = (expression, context) => {
         else {
             (0, utils_1.assertNever)(element);
         }
+        precedingStatements = context.popPrecedingStatements();
+        valuePrecedingStatements.push(precedingStatements);
+        if (precedingStatements.length > 0) {
+            lastPrecedingStatementsIndex = i;
+        }
+    }
+    // Expressions referenced before others that produced preceding statements need to be cached in temps
+    if (lastPrecedingStatementsIndex >= 0) {
+        for (let i = 0; i < properties.length; ++i) {
+            const property = properties[i];
+            // Bubble up key's preceding statements
+            context.addPrecedingStatements(keyPrecedingStatements[i]);
+            // Cache computed property name in temp if before the last expression that generated preceding statements
+            if (i <= lastPrecedingStatementsIndex && lua.isTableFieldExpression(property) && property.key) {
+                property.key = (0, expression_list_1.moveToPrecedingTemp)(context, property.key, expression.properties[i].name);
+            }
+            // Bubble up value's preceding statements
+            context.addPrecedingStatements(valuePrecedingStatements[i]);
+            // Cache property value in temp if before the last expression that generated preceding statements
+            if (i < lastPrecedingStatementsIndex) {
+                if (lua.isTableFieldExpression(property)) {
+                    property.value = (0, expression_list_1.moveToPrecedingTemp)(context, property.value, initializers[i]);
+                }
+                else {
+                    properties[i] = (0, expression_list_1.moveToPrecedingTemp)(context, property, initializers[i]);
+                }
+            }
+        }
+    }
+    // Sort into field expressions and tables to pass into __TS__ObjectAssign
+    let fields = [];
+    const tableExpressions = [];
+    for (const property of properties) {
+        if (lua.isTableFieldExpression(property)) {
+            fields.push(property);
+        }
+        else {
+            if (fields.length > 0) {
+                tableExpressions.push(lua.createTableExpression(fields));
+            }
+            tableExpressions.push(property);
+            fields = [];
+        }
     }
     if (tableExpressions.length === 0) {
-        return lua.createTableExpression(properties, expression);
+        return lua.createTableExpression(fields, expression);
     }
     else {
-        if (properties.length > 0) {
-            const tableExpression = lua.createTableExpression(properties, expression);
+        if (fields.length > 0) {
+            const tableExpression = lua.createTableExpression(fields, expression);
             tableExpressions.push(tableExpression);
         }
         if (tableExpressions[0].kind !== lua.SyntaxKind.TableExpression) {
@@ -122,7 +175,7 @@ const transformObjectLiteralExpression = (expression, context) => {
 };
 const transformArrayLiteralExpression = (expression, context) => {
     const filteredElements = expression.elements.map(e => ts.isOmittedExpression(e) ? ts.factory.createIdentifier("undefined") : e);
-    const values = (0, call_1.flattenSpreadExpressions)(context, filteredElements).map(e => lua.createTableFieldExpression(e));
+    const values = (0, expression_list_1.transformExpressionList)(context, filteredElements).map(e => lua.createTableFieldExpression(e));
     return lua.createTableExpression(values, expression);
 };
 exports.literalVisitors = {

package/dist/transformation/visitors/loops/do-while.js

@@ -2,19 +2,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformDoStatement = exports.transformWhileStatement = void 0;
 const lua = require("../../../LuaAST");
+const preceding_statements_1 = require("../../utils/preceding-statements");
 const utils_1 = require("./utils");
-const transformWhileStatement = (statement, context) => lua.createWhileStatement(lua.createBlock((0, utils_1.transformLoopBody)(context, statement)), context.transformExpression(statement.expression), statement);
+const transformWhileStatement = (statement, context) => {
+    const body = (0, utils_1.transformLoopBody)(context, statement);
+    let [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
+    // If condition has preceding statements, ensure they are executed every iteration by using the form:
+    //
+    // while true do
+    //     condition's preceding statements
+    //     if not condition then
+    //         break
+    //     end
+    //     ...
+    // end
+    if (conditionPrecedingStatements.length > 0) {
+        conditionPrecedingStatements.push(lua.createIfStatement((0, utils_1.invertCondition)(condition), lua.createBlock([lua.createBreakStatement()]), undefined, statement.expression));
+        body.unshift(...conditionPrecedingStatements);
+        condition = lua.createBooleanLiteral(true);
+    }
+    return lua.createWhileStatement(lua.createBlock(body), condition, statement);
+};
 exports.transformWhileStatement = transformWhileStatement;
 const transformDoStatement = (statement, context) => {
     const body = lua.createDoStatement((0, utils_1.transformLoopBody)(context, statement));
-    let condition = context.transformExpression(statement.expression);
-    if (lua.isUnaryExpression(condition) && condition.operator === lua.SyntaxKind.NotOperator) {
-        condition = condition.operand;
-    }
-    else {
-        condition = lua.createUnaryExpression(condition, lua.SyntaxKind.NotOperator);
+    let [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, utils_1.invertCondition)(context.transformExpression(statement.expression)));
+    // If condition has preceding statements, ensure they are executed every iteration by using the form:
+    //
+    // repeat
+    //     ...
+    //     condition's preceding statements
+    //     if condition then
+    //         break
+    //     end
+    // end
+    if (conditionPrecedingStatements.length > 0) {
+        conditionPrecedingStatements.push(lua.createIfStatement(condition, lua.createBlock([lua.createBreakStatement()]), undefined, statement.expression));
+        condition = lua.createBooleanLiteral(false);
     }
-    return lua.createRepeatStatement(lua.createBlock([body]), condition, statement);
+    return lua.createRepeatStatement(lua.createBlock([body, ...conditionPrecedingStatements]), condition, statement);
 };
 exports.transformDoStatement = transformDoStatement;
 //# sourceMappingURL=do-while.js.map

package/dist/transformation/visitors/loops/for.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformForStatement = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
+const preceding_statements_1 = require("../../utils/preceding-statements");
 const variable_declaration_1 = require("../variable-declaration");
 const utils_1 = require("./utils");
 const transformForStatement = (statement, context) => {
@@ -17,16 +18,35 @@ const transformForStatement = (statement, context) => {
             result.push(...context.transformStatements(ts.factory.createExpressionStatement(statement.initializer)));
         }
     }
-    const condition = statement.condition
-        ? context.transformExpression(statement.condition)
-        : lua.createBooleanLiteral(true);
-    // Add body
     const body = (0, utils_1.transformLoopBody)(context, statement);
+    let condition;
+    if (statement.condition) {
+        let conditionPrecedingStatements;
+        const tsCondition = statement.condition;
+        [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsCondition));
+        // If condition has preceding statements, ensure they are executed every iteration by using the form:
+        //
+        // while true do
+        //     condition's preceding statements
+        //     if not condition then
+        //         break
+        //     end
+        //     ...
+        // end
+        if (conditionPrecedingStatements.length > 0) {
+            conditionPrecedingStatements.push(lua.createIfStatement((0, utils_1.invertCondition)(condition), lua.createBlock([lua.createBreakStatement()]), undefined, statement.condition));
+            body.unshift(...conditionPrecedingStatements);
+            condition = lua.createBooleanLiteral(true);
+        }
+    }
+    else {
+        condition = lua.createBooleanLiteral(true);
+    }
     if (statement.incrementor) {
         body.push(...context.transformStatements(ts.factory.createExpressionStatement(statement.incrementor)));
     }
     // while (condition) do ... end
-    result.push(lua.createWhileStatement(lua.createBlock(body), condition));
+    result.push(lua.createWhileStatement(lua.createBlock(body), condition, statement));
     return lua.createDoStatement(result, statement);
 };
 exports.transformForStatement = transformForStatement;

package/dist/transformation/visitors/loops/utils.d.ts

@@ -4,3 +4,4 @@ import { TransformationContext } from "../../context";
 export declare function transformLoopBody(context: TransformationContext, loop: ts.WhileStatement | ts.DoStatement | ts.ForStatement | ts.ForOfStatement | ts.ForInOrOfStatement): lua.Statement[];
 export declare function getVariableDeclarationBinding(context: TransformationContext, node: ts.VariableDeclarationList): ts.BindingName;
 export declare function transformForInitializer(context: TransformationContext, initializer: ts.ForInitializer, block: lua.Block): lua.Identifier;
+export declare function invertCondition(expression: lua.Expression): lua.Expression;

package/dist/transformation/visitors/loops/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformForInitializer = exports.getVariableDeclarationBinding = exports.transformLoopBody = void 0;
+exports.invertCondition = exports.transformForInitializer = exports.getVariableDeclarationBinding = exports.transformLoopBody = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const scope_1 = require("../../utils/scope");
@@ -48,10 +48,21 @@ function transformForInitializer(context, initializer, block) {
     else {
         // Assignment to existing variable(s)
         block.statements.unshift(...((0, typescript_1.isAssignmentPattern)(initializer)
-            ? (0, destructuring_assignments_1.transformAssignmentPattern)(context, initializer, valueVariable)
+            ? (0, destructuring_assignments_1.transformAssignmentPattern)(context, initializer, valueVariable, false)
             : (0, assignments_1.transformAssignment)(context, initializer, valueVariable)));
     }
     return valueVariable;
 }
 exports.transformForInitializer = transformForInitializer;
+function invertCondition(expression) {
+    if (lua.isUnaryExpression(expression) && expression.operator === lua.SyntaxKind.NotOperator) {
+        return expression.operand;
+    }
+    else {
+        const notExpression = lua.createUnaryExpression(expression, lua.SyntaxKind.NotOperator);
+        lua.setNodePosition(notExpression, lua.getOriginalPos(expression));
+        return notExpression;
+    }
+}
+exports.invertCondition = invertCondition;
 //# sourceMappingURL=utils.js.map

package/dist/transformation/visitors/modules/export.js

@@ -79,7 +79,7 @@ function transformExportSpecifier(context, node) {
 }
 function transformExportSpecifiersFrom(context, statement, moduleSpecifier, exportSpecifiers) {
     // First transpile as import clause
-    const importClause = ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(exportSpecifiers.map(s => ts.factory.createImportSpecifier(s.propertyName, s.name))));
+    const importClause = ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(exportSpecifiers.map(s => ts.factory.createImportSpecifier(statement.isTypeOnly, s.propertyName, s.name))));
     const importDeclaration = ts.factory.createImportDeclaration(statement.decorators, statement.modifiers, importClause, moduleSpecifier);
     // Wrap in block to prevent imports from hoisting out of `do` statement
     const [block] = (0, block_1.transformScopeBlock)(context, ts.factory.createBlock([importDeclaration]), scope_1.ScopeType.Block);

package/dist/transformation/visitors/optional-chaining.d.ts

@@ -0,0 +1,16 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+export interface ExpressionWithThisValue {
+    expression: lua.Expression;
+    thisValue?: lua.Expression;
+}
+export declare function captureThisValue(context: TransformationContext, expression: lua.Expression, thisValueCapture: lua.Identifier, tsOriginal: ts.Node): lua.Expression;
+export interface OptionalContinuation {
+    contextualCall?: lua.CallExpression;
+}
+export declare function isOptionalContinuation(node: ts.Node): boolean;
+export declare function getOptionalContinuationData(identifier: ts.Identifier): OptionalContinuation | undefined;
+export declare function transformOptionalChain(context: TransformationContext, node: ts.OptionalChain): lua.Expression;
+export declare function transformOptionalChainWithCapture(context: TransformationContext, node: ts.OptionalChain, thisValueCapture: lua.Identifier | undefined, isDelete?: ts.DeleteExpression): ExpressionWithThisValue;
+export declare function transformOptionalDeleteExpression(context: TransformationContext, node: ts.DeleteExpression, innerExpression: ts.OptionalChain): lua.BooleanLiteral;

package/dist/transformation/visitors/optional-chaining.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOptionalDeleteExpression = exports.transformOptionalChainWithCapture = exports.transformOptionalChain = exports.getOptionalContinuationData = exports.isOptionalContinuation = exports.captureThisValue = void 0;
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+const context_1 = require("../context");
+const utils_1 = require("../../utils");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const access_1 = require("./access");
+const expression_list_1 = require("./expression-list");
+function skipNonNullChains(chain) {
+    while (ts.isNonNullChain(chain)) {
+        chain = chain.expression;
+    }
+    return chain;
+}
+function flattenChain(chain) {
+    chain = skipNonNullChains(chain);
+    const links = [chain];
+    while (!chain.questionDotToken && !ts.isTaggedTemplateExpression(chain)) {
+        const nextLink = chain.expression;
+        (0, utils_1.assert)(ts.isOptionalChain(nextLink));
+        chain = skipNonNullChains(nextLink);
+        links.unshift(chain);
+    }
+    return { expression: chain.expression, chain: links };
+}
+function transformExpressionWithThisValueCapture(context, node, thisValueCapture) {
+    if (ts.isParenthesizedExpression(node)) {
+        return transformExpressionWithThisValueCapture(context, node.expression, thisValueCapture);
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return (0, access_1.transformPropertyAccessExpressionWithCapture)(context, node, thisValueCapture);
+    }
+    if (ts.isElementAccessExpression(node)) {
+        return (0, access_1.transformElementAccessExpressionWithCapture)(context, node, thisValueCapture);
+    }
+    return { expression: context.transformExpression(node) };
+}
+// returns thisValueCapture exactly if a temp variable was used.
+function captureThisValue(context, expression, thisValueCapture, tsOriginal) {
+    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal) && !isOptionalContinuation(tsOriginal)) {
+        return expression;
+    }
+    const tempAssignment = lua.createAssignmentStatement(thisValueCapture, expression, tsOriginal);
+    context.addPrecedingStatements(tempAssignment);
+    return thisValueCapture;
+}
+exports.captureThisValue = captureThisValue;
+const optionalContinuations = new WeakMap();
+// should be translated verbatim to lua
+function createOptionalContinuationIdentifier(text, tsOriginal) {
+    const identifier = ts.factory.createIdentifier(text);
+    ts.setOriginalNode(identifier, tsOriginal);
+    optionalContinuations.set(identifier, {});
+    return identifier;
+}
+function isOptionalContinuation(node) {
+    return ts.isIdentifier(node) && optionalContinuations.has(node);
+}
+exports.isOptionalContinuation = isOptionalContinuation;
+function getOptionalContinuationData(identifier) {
+    return optionalContinuations.get(identifier);
+}
+exports.getOptionalContinuationData = getOptionalContinuationData;
+function transformOptionalChain(context, node) {
+    return transformOptionalChainWithCapture(context, node, undefined).expression;
+}
+exports.transformOptionalChain = transformOptionalChain;
+function transformOptionalChainWithCapture(context, node, thisValueCapture, isDelete) {
+    var _a;
+    const luaTemp = context.createTempNameForNode(node);
+    const { expression: tsLeftExpression, chain } = flattenChain(node);
+    // build temp.b.c.d
+    const tsTemp = createOptionalContinuationIdentifier(luaTemp.text, tsLeftExpression);
+    let tsRightExpression = tsTemp;
+    for (const link of chain) {
+        if (ts.isPropertyAccessExpression(link)) {
+            tsRightExpression = ts.factory.createPropertyAccessExpression(tsRightExpression, link.name);
+        }
+        else if (ts.isElementAccessExpression(link)) {
+            tsRightExpression = ts.factory.createElementAccessExpression(tsRightExpression, link.argumentExpression);
+        }
+        else if (ts.isCallExpression(link)) {
+            tsRightExpression = ts.factory.createCallExpression(tsRightExpression, undefined, link.arguments);
+        }
+        else {
+            (0, utils_1.assertNever)(link);
+        }
+        ts.setOriginalNode(tsRightExpression, link);
+    }
+    if (isDelete) {
+        tsRightExpression = ts.factory.createDeleteExpression(tsRightExpression);
+        ts.setOriginalNode(tsRightExpression, isDelete);
+    }
+    // transform right expression first to check if thisValue capture is needed
+    // capture and return thisValue if requested from outside
+    let returnThisValue;
+    const [rightPrecedingStatements, rightAssignment] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        let result;
+        if (thisValueCapture) {
+            ({ expression: result, thisValue: returnThisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture));
+        }
+        else {
+            result = context.transformExpression(tsRightExpression);
+        }
+        return lua.createAssignmentStatement(luaTemp, result);
+    });
+    // transform left expression, handle thisValue if needed by rightExpression
+    const thisValueCaptureName = context.createTempName("this");
+    const leftThisValueTemp = lua.createIdentifier(thisValueCaptureName, undefined, context_1.tempSymbolId);
+    let capturedThisValue;
+    const rightContextualCall = (_a = getOptionalContinuationData(tsTemp)) === null || _a === void 0 ? void 0 : _a.contextualCall;
+    const [leftPrecedingStatements, leftExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        let result;
+        if (rightContextualCall) {
+            ({ expression: result, thisValue: capturedThisValue } = transformExpressionWithThisValueCapture(context, tsLeftExpression, leftThisValueTemp));
+        }
+        else {
+            result = context.transformExpression(tsLeftExpression);
+        }
+        return result;
+    });
+    // handle context
+    if (rightContextualCall) {
+        if (capturedThisValue) {
+            rightContextualCall.params[0] = capturedThisValue;
+            if (capturedThisValue === leftThisValueTemp) {
+                context.addPrecedingStatements(lua.createVariableDeclarationStatement(leftThisValueTemp));
+            }
+        }
+        else {
+            if (context.isStrict) {
+                rightContextualCall.params[0] = lua.createNilLiteral();
+            }
+            else {
+                const identifier = lua.createIdentifier("_G");
+                if (rightPrecedingStatements.length === 0) {
+                    rightContextualCall.params[0] = identifier;
+                }
+                else {
+                    const tempContext = context.createTempNameForLuaExpression(identifier);
+                    rightPrecedingStatements.unshift(lua.createVariableDeclarationStatement(tempContext, identifier));
+                    rightContextualCall.params[0] = tempContext;
+                }
+            }
+        }
+    }
+    // <left preceding statements>
+    // local temp = <left>
+    // if temp ~= nil then
+    //   <right preceding statements>
+    //   temp = temp.b.c.d
+    // end
+    // return temp
+    context.addPrecedingStatements([
+        ...leftPrecedingStatements,
+        lua.createVariableDeclarationStatement(luaTemp, leftExpression),
+        lua.createIfStatement(lua.createBinaryExpression(luaTemp, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([...rightPrecedingStatements, rightAssignment])),
+    ]);
+    return {
+        expression: luaTemp,
+        thisValue: returnThisValue,
+    };
+}
+exports.transformOptionalChainWithCapture = transformOptionalChainWithCapture;
+function transformOptionalDeleteExpression(context, node, innerExpression) {
+    transformOptionalChainWithCapture(context, innerExpression, undefined, node);
+    return lua.createBooleanLiteral(true, node);
+}
+exports.transformOptionalDeleteExpression = transformOptionalDeleteExpression;
+//# sourceMappingURL=optional-chaining.js.map

package/dist/transformation/visitors/sourceFile.js

@@ -6,6 +6,7 @@ const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const typescript_1 = require("../utils/typescript");
 const transformSourceFileNode = (node, context) => {
@@ -15,7 +16,9 @@ const transformSourceFileNode = (node, context) => {
         const [statement] = node.statements;
         if (statement) {
             (0, utils_1.assert)(ts.isExpressionStatement(statement));
-            statements.push(lua.createReturnStatement([context.transformExpression(statement.expression)]));
+            const [precedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
+            statements.push(...precedingStatements);
+            statements.push(lua.createReturnStatement([expression]));
         }
         else {
             const errorCall = lua.createCallExpression(lua.createIdentifier("error"), [

package/dist/transformation/visitors/switch.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSwitchStatement = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
+const binary_expression_1 = require("./binary-expression");
 const containsBreakOrReturn = (nodes) => {
     for (const s of nodes) {
         if (ts.isBreakStatement(s) || ts.isReturnStatement(s)) {
@@ -18,13 +20,23 @@ const containsBreakOrReturn = (nodes) => {
     }
     return false;
 };
-const coalesceCondition = (condition, switchVariable, expression, context) => {
+const createOrExpression = (context, left, right, rightPrecedingStatements) => {
+    if (rightPrecedingStatements.length > 0) {
+        return (0, binary_expression_1.createShortCircuitBinaryExpressionPrecedingStatements)(context, left, right, rightPrecedingStatements, ts.SyntaxKind.BarBarToken);
+    }
+    else {
+        return [rightPrecedingStatements, lua.createBinaryExpression(left, right, lua.SyntaxKind.OrOperator)];
+    }
+};
+const coalesceCondition = (condition, conditionPrecedingStatements, switchVariable, expression, context) => {
+    const [precedingStatements, transformedExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression));
     // Coalesce skipped statements
+    const comparison = lua.createBinaryExpression(switchVariable, transformedExpression, lua.SyntaxKind.EqualityOperator);
     if (condition) {
-        return lua.createBinaryExpression(condition, lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator), lua.SyntaxKind.OrOperator);
+        return createOrExpression(context, condition, comparison, precedingStatements);
     }
     // Next condition
-    return lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator);
+    return [[...conditionPrecedingStatements, ...precedingStatements], comparison];
 };
 const transformSwitchStatement = (statement, context) => {
     const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Switch);
@@ -53,6 +65,7 @@ const transformSwitchStatement = (statement, context) => {
         let defaultTransformed = false;
         let isInitialCondition = true;
         let condition = undefined;
+        let conditionPrecedingStatements = [];
         for (let i = 0; i < clauses.length; i++) {
             const clause = clauses[i];
             const previousClause = clauses[i - 1];
@@ -64,29 +77,35 @@ const transformSwitchStatement = (statement, context) => {
             }
             // Compute the condition for the if statement
             if (!ts.isDefaultClause(clause)) {
-                condition = coalesceCondition(condition, switchVariable, clause.expression, context);
+                [conditionPrecedingStatements, condition] = coalesceCondition(condition, conditionPrecedingStatements, switchVariable, clause.expression, context);
                 // Skip empty clauses unless final clause (i.e side-effects)
                 if (i !== clauses.length - 1 && clause.statements.length === 0)
                     continue;
                 // Declare or assign condition variable
-                statements.push(isInitialCondition
-                    ? lua.createVariableDeclarationStatement(conditionVariable, condition)
-                    : lua.createAssignmentStatement(conditionVariable, lua.createBinaryExpression(conditionVariable, condition, lua.SyntaxKind.OrOperator)));
+                if (isInitialCondition) {
+                    statements.push(...conditionPrecedingStatements, lua.createVariableDeclarationStatement(conditionVariable, condition));
+                }
+                else {
+                    [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                    statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
+                }
                 isInitialCondition = false;
             }
             else {
                 // If the default is proceeded by empty clauses and will be emitted we may need to initialize the condition
                 if (isInitialCondition) {
-                    statements.push(lua.createVariableDeclarationStatement(conditionVariable, condition !== null && condition !== void 0 ? condition : lua.createBooleanLiteral(false)));
+                    statements.push(...conditionPrecedingStatements, lua.createVariableDeclarationStatement(conditionVariable, condition !== null && condition !== void 0 ? condition : lua.createBooleanLiteral(false)));
                     // Clear condition ot ensure it is not evaluated twice
                     condition = undefined;
+                    conditionPrecedingStatements = [];
                     isInitialCondition = false;
                 }
                 // Allow default to fallthrough to final default clause
                 if (i === clauses.length - 1) {
                     // Evaluate the final condition that we may be skipping
                     if (condition) {
-                        statements.push(lua.createAssignmentStatement(conditionVariable, lua.createBinaryExpression(conditionVariable, condition, lua.SyntaxKind.OrOperator)));
+                        [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                        statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
                     }
                     continue;
                 }
@@ -106,6 +125,7 @@ const transformSwitchStatement = (statement, context) => {
             statements.push(lua.createIfStatement(conditionVariable, lua.createBlock(clauseStatements)));
             // Clear condition for next clause
             condition = undefined;
+            conditionPrecedingStatements = [];
         }
         // If no conditions above match, we need to create the final default case code-path,
         // as we only handle fallthrough into defaults in the previous if statement chain