typescript-to-lua 1.1.0 → 1.3.1

package/dist/transformation/utils/safe-names.d.ts

@@ -1,8 +1,10 @@
 import * as ts from "typescript";
+import { CompilerOptions } from "../..";
 import { TransformationContext } from "../context";
-export declare const isValidLuaIdentifier: (name: string) => boolean;
+export declare const shouldAllowUnicode: (options: CompilerOptions) => boolean;
+export declare const isValidLuaIdentifier: (name: string, options: CompilerOptions) => boolean;
 export declare const luaKeywords: ReadonlySet<string>;
-export declare const isUnsafeName: (name: string) => boolean;
+export declare const isUnsafeName: (name: string, options: CompilerOptions) => boolean;
 export declare function hasUnsafeSymbolName(context: TransformationContext, symbol: ts.Symbol, tsOriginal: ts.Identifier): boolean;
 export declare function hasUnsafeIdentifierName(context: TransformationContext, identifier: ts.Identifier, checkSymbol?: boolean): boolean;
 export declare const createSafeName: (name: string) => string;

package/dist/transformation/utils/safe-names.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSafeName = exports.hasUnsafeIdentifierName = exports.hasUnsafeSymbolName = exports.isUnsafeName = exports.luaKeywords = exports.isValidLuaIdentifier = void 0;
+exports.createSafeName = exports.hasUnsafeIdentifierName = exports.hasUnsafeSymbolName = exports.isUnsafeName = exports.luaKeywords = exports.isValidLuaIdentifier = exports.shouldAllowUnicode = void 0;
+const __1 = require("../..");
 const diagnostics_1 = require("./diagnostics");
 const export_1 = require("./export");
 const typescript_1 = require("./typescript");
-const isValidLuaIdentifier = (name) => !exports.luaKeywords.has(name) && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+const shouldAllowUnicode = (options) => options.luaTarget === __1.LuaTarget.LuaJIT;
+exports.shouldAllowUnicode = shouldAllowUnicode;
+const isValidLuaIdentifier = (name, options) => !exports.luaKeywords.has(name) &&
+    ((0, exports.shouldAllowUnicode)(options)
+        ? /^[a-zA-Z_\u007F-\uFFFD][a-zA-Z0-9_\u007F-\uFFFD]*$/
+        : /^[a-zA-Z_][a-zA-Z0-9_]*$/).test(name);
 exports.isValidLuaIdentifier = isValidLuaIdentifier;
 exports.luaKeywords = new Set([
     "and",
@@ -51,10 +57,10 @@ const luaBuiltins = new Set([
     "type",
     "unpack",
 ]);
-const isUnsafeName = (name) => !(0, exports.isValidLuaIdentifier)(name) || luaBuiltins.has(name);
+const isUnsafeName = (name, options) => !(0, exports.isValidLuaIdentifier)(name, options) || luaBuiltins.has(name);
 exports.isUnsafeName = isUnsafeName;
 function checkName(context, name, node) {
-    const isInvalid = !(0, exports.isValidLuaIdentifier)(name);
+    const isInvalid = !(0, exports.isValidLuaIdentifier)(name, context.options);
     if (isInvalid) {
         // Empty identifier is a TypeScript error
         if (name !== "") {
@@ -71,7 +77,7 @@ function hasUnsafeSymbolName(context, symbol, tsOriginal) {
         return true;
     }
     // only unsafe when non-ambient and not exported
-    return (0, exports.isUnsafeName)(symbol.name) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
+    return (0, exports.isUnsafeName)(symbol.name, context.options) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
 }
 exports.hasUnsafeSymbolName = hasUnsafeSymbolName;
 function hasUnsafeIdentifierName(context, identifier, checkSymbol = true) {

package/dist/transformation/utils/scope.d.ts

@@ -9,7 +9,8 @@ export declare enum ScopeType {
     Conditional = 16,
     Block = 32,
     Try = 64,
-    Catch = 128
+    Catch = 128,
+    LoopInitializer = 256
 }
 interface FunctionDefinitionInfo {
     referencedSymbols: Map<lua.SymbolId, ts.Node[]>;
@@ -37,6 +38,7 @@ export declare function peekScope(context: TransformationContext): Scope;
 export declare function findScope(context: TransformationContext, scopeTypes: ScopeType): Scope | undefined;
 export declare function pushScope(context: TransformationContext, scopeType: ScopeType): Scope;
 export declare function popScope(context: TransformationContext): Scope;
+export declare function addScopeVariableDeclaration(scope: Scope, declaration: lua.VariableDeclarationStatement): void;
 export declare function hasReferencedUndefinedLocalFunction(context: TransformationContext, scope: Scope): boolean;
 export declare function hasReferencedSymbol(context: TransformationContext, scope: Scope, symbol: ts.Symbol): boolean | undefined;
 export declare function isFunctionScopeWithDefinition(scope: Scope): scope is Scope & {

package/dist/transformation/utils/scope.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.performHoisting = exports.separateHoistedStatements = exports.isFunctionScopeWithDefinition = exports.hasReferencedSymbol = exports.hasReferencedUndefinedLocalFunction = exports.popScope = exports.pushScope = exports.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
+exports.performHoisting = exports.separateHoistedStatements = exports.isFunctionScopeWithDefinition = exports.hasReferencedSymbol = exports.hasReferencedUndefinedLocalFunction = exports.addScopeVariableDeclaration = exports.popScope = exports.pushScope = exports.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
@@ -16,6 +16,7 @@ var ScopeType;
     ScopeType[ScopeType["Block"] = 32] = "Block";
     ScopeType[ScopeType["Try"] = 64] = "Try";
     ScopeType[ScopeType["Catch"] = 128] = "Catch";
+    ScopeType[ScopeType["LoopInitializer"] = 256] = "LoopInitializer";
 })(ScopeType = exports.ScopeType || (exports.ScopeType = {}));
 const scopeStacks = new WeakMap();
 function getScopeStack(context) {
@@ -68,6 +69,13 @@ function popScope(context) {
     return scope;
 }
 exports.popScope = popScope;
+function addScopeVariableDeclaration(scope, declaration) {
+    if (!scope.variableDeclarations) {
+        scope.variableDeclarations = [];
+    }
+    scope.variableDeclarations.push(declaration);
+}
+exports.addScopeVariableDeclaration = addScopeVariableDeclaration;
 function isHoistableFunctionDeclaredInScope(symbol, scopeNode) {
     var _a;
     return (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => ts.isFunctionDeclaration(d) && (0, typescript_1.findFirstNodeAbove)(d, (n) => n === scopeNode));

package/dist/transformation/utils/typescript/index.d.ts

@@ -14,3 +14,4 @@ export declare function inferAssignedType(context: TransformationContext, expres
 export declare function getAllCallSignatures(type: ts.Type): readonly ts.Signature[];
 export declare function isExpressionWithEvaluationEffect(node: ts.Expression): boolean;
 export declare function getFunctionTypeForCall(context: TransformationContext, node: ts.CallExpression): ts.Type | undefined;
+export declare function isConstIdentifier(context: TransformationContext, node: ts.Node): boolean;

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

@@ -10,7 +10,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.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.getFirstDeclarationInFile = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
+exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.getFirstDeclarationInFile = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
 const ts = require("typescript");
 __exportStar(require("./nodes"), exports);
 __exportStar(require("./types"), exports);
@@ -94,4 +94,19 @@ function getFunctionTypeForCall(context, node) {
     return context.checker.getTypeFromTypeNode(typeDeclaration.type);
 }
 exports.getFunctionTypeForCall = getFunctionTypeForCall;
+function isConstIdentifier(context, node) {
+    let identifier = node;
+    if (ts.isComputedPropertyName(identifier)) {
+        identifier = identifier.expression;
+    }
+    if (!ts.isIdentifier(identifier)) {
+        return false;
+    }
+    const symbol = context.checker.getSymbolAtLocation(identifier);
+    if (!symbol || !symbol.declarations) {
+        return false;
+    }
+    return symbol.declarations.some(d => ts.isVariableDeclarationList(d.parent) && (d.parent.flags & ts.NodeFlags.Const) !== 0);
+}
+exports.isConstIdentifier = isConstIdentifier;
 //# sourceMappingURL=index.js.map

package/dist/transformation/utils/typescript/types.d.ts

@@ -10,4 +10,6 @@ export declare function isNumberType(context: TransformationContext, type: ts.Ty
  */
 export declare function forTypeOrAnySupertype(context: TransformationContext, type: ts.Type, predicate: (type: ts.Type) => boolean): boolean;
 export declare function isArrayType(context: TransformationContext, type: ts.Type): boolean;
-export declare function isFunctionType(context: TransformationContext, type: ts.Type): boolean;
+export declare function isFunctionType(type: ts.Type): boolean;
+export declare function canBeFalsy(context: TransformationContext, type: ts.Type): boolean;
+export declare function canBeFalsyWhenNotNull(context: TransformationContext, type: ts.Type): boolean;

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

@@ -1,21 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
+exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
 const ts = require("typescript");
 function isTypeWithFlags(context, type, flags) {
-    const predicate = (type) => {
-        if (type.symbol) {
-            const baseConstraint = context.checker.getBaseConstraintOfType(type);
-            if (baseConstraint && baseConstraint !== type) {
-                return isTypeWithFlags(context, baseConstraint, flags);
-            }
-        }
-        return (type.flags & flags) !== 0;
-    };
+    const predicate = (type) => (type.flags & flags) !== 0;
     return typeAlwaysSatisfies(context, type, predicate);
 }
 exports.isTypeWithFlags = isTypeWithFlags;
 function typeAlwaysSatisfies(context, type, predicate) {
+    const baseConstraint = context.checker.getBaseConstraintOfType(type);
+    if (baseConstraint) {
+        type = baseConstraint;
+    }
     if (predicate(type)) {
         return true;
     }
@@ -29,6 +25,15 @@ function typeAlwaysSatisfies(context, type, predicate) {
 }
 exports.typeAlwaysSatisfies = typeAlwaysSatisfies;
 function typeCanSatisfy(context, type, predicate) {
+    const baseConstraint = context.checker.getBaseConstraintOfType(type);
+    if (!baseConstraint) {
+        // type parameter with no constraint can be anything, assume it might satisfy predicate
+        if (type.isTypeParameter())
+            return true;
+    }
+    else {
+        type = baseConstraint;
+    }
     if (predicate(type)) {
         return true;
     }
@@ -84,9 +89,31 @@ function isArrayType(context, type) {
     return forTypeOrAnySupertype(context, type, t => isExplicitArrayType(context, t));
 }
 exports.isArrayType = isArrayType;
-function isFunctionType(context, type) {
-    const typeNode = context.checker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.InTypeAlias);
-    return typeNode !== undefined && ts.isFunctionTypeNode(typeNode);
+function isFunctionType(type) {
+    return type.getCallSignatures().length > 0;
 }
 exports.isFunctionType = isFunctionType;
+function canBeFalsy(context, type) {
+    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
+    const falsyFlags = ts.TypeFlags.Boolean |
+        ts.TypeFlags.BooleanLiteral |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Any |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Null;
+    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0 || (!strictNullChecks && !type.isLiteral()));
+}
+exports.canBeFalsy = canBeFalsy;
+function canBeFalsyWhenNotNull(context, type) {
+    const falsyFlags = ts.TypeFlags.Boolean |
+        ts.TypeFlags.BooleanLiteral |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Any;
+    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0);
+}
+exports.canBeFalsyWhenNotNull = canBeFalsyWhenNotNull;
 //# sourceMappingURL=types.js.map

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

@@ -1,7 +1,10 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
+import { ExpressionWithThisValue } from "./optional-chaining";
 export declare function transformElementAccessArgument(context: TransformationContext, node: ts.ElementAccessExpression): lua.Expression;
 export declare const transformElementAccessExpression: FunctionVisitor<ts.ElementAccessExpression>;
+export declare function transformElementAccessExpressionWithCapture(context: TransformationContext, node: ts.ElementAccessExpression, thisValueCapture: lua.Identifier | undefined): ExpressionWithThisValue;
 export declare const transformPropertyAccessExpression: FunctionVisitor<ts.PropertyAccessExpression>;
+export declare function transformPropertyAccessExpressionWithCapture(context: TransformationContext, node: ts.PropertyAccessExpression, thisValueCapture: lua.Identifier | undefined): ExpressionWithThisValue;
 export declare const transformQualifiedName: FunctionVisitor<ts.QualifiedName>;

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;