@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/nodes/expressions/transformBinaryExpression.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBinaryExpression = transformBinaryExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const assert_1 = require("../../../Shared/util/assert");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformArrayAssignmentPattern_1 = require("../binding/transformArrayAssignmentPattern");
+const transformObjectAssignmentPattern_1 = require("../binding/transformObjectAssignmentPattern");
+const transformExpression_1 = require("./transformExpression");
+const transformInitializer_1 = require("../transformInitializer");
+const transformLogical_1 = require("../transformLogical");
+const transformLogicalOrCoalescingAssignmentExpression_1 = require("../transformLogicalOrCoalescingAssignmentExpression");
+const transformWritable_1 = require("../transformWritable");
+const arrayLikeExpressionContainsSpread_1 = require("../../util/arrayLikeExpressionContainsSpread");
+const assignment_1 = require("../../util/assignment");
+const bitwise_1 = require("../../util/bitwise");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const createBinaryFromOperator_1 = require("../../util/createBinaryFromOperator");
+const ensureTransformOrder_1 = require("../../util/ensureTransformOrder");
+const getAssignableValue_1 = require("../../util/getAssignableValue");
+const getKindName_1 = require("../../util/getKindName");
+const isUsedAsStatement_1 = require("../../util/isUsedAsStatement");
+const traversal_1 = require("../../util/traversal");
+const types_1 = require("../../util/types");
+const validateNotAny_1 = require("../../util/validateNotAny");
+const typescript_1 = __importDefault(require("typescript"));
+function transformOptimizedArrayAssignmentPattern(state, assignmentPattern, rhs) {
+    const variables = luau_ast_1.default.list.make();
+    const writes = luau_ast_1.default.list.make();
+    const writesPrereqs = luau_ast_1.default.list.make();
+    const statements = state.capturePrereqs(() => {
+        for (let element of assignmentPattern.elements) {
+            if (typescript_1.default.isOmittedExpression(element)) {
+                luau_ast_1.default.list.push(writes, luau_ast_1.default.tempId());
+            }
+            else if (typescript_1.default.isSpreadElement(element)) {
+                (0, assert_1.assert)(false, "Cannot optimize-assign spread element");
+            }
+            else {
+                let initializer;
+                if (typescript_1.default.isBinaryExpression(element)) {
+                    initializer = (0, traversal_1.skipDownwards)(element.right);
+                    element = (0, traversal_1.skipDownwards)(element.left);
+                }
+                if (typescript_1.default.isIdentifier(element) ||
+                    typescript_1.default.isElementAccessExpression(element) ||
+                    typescript_1.default.isPropertyAccessExpression(element)) {
+                    const [id, idPrereqs] = state.capture(() => (0, transformWritable_1.transformWritableExpression)(state, element, true));
+                    luau_ast_1.default.list.pushList(writesPrereqs, idPrereqs);
+                    luau_ast_1.default.list.push(writes, id);
+                    if (initializer) {
+                        state.prereq((0, transformInitializer_1.transformInitializer)(state, id, initializer));
+                    }
+                }
+                else if (typescript_1.default.isArrayLiteralExpression(element)) {
+                    const id = luau_ast_1.default.tempId("binding");
+                    luau_ast_1.default.list.push(variables, id);
+                    luau_ast_1.default.list.push(writes, id);
+                    if (initializer) {
+                        state.prereq((0, transformInitializer_1.transformInitializer)(state, id, initializer));
+                    }
+                    (0, transformArrayAssignmentPattern_1.transformArrayAssignmentPattern)(state, element, id);
+                }
+                else if (typescript_1.default.isObjectLiteralExpression(element)) {
+                    const id = luau_ast_1.default.tempId("binding");
+                    luau_ast_1.default.list.push(variables, id);
+                    luau_ast_1.default.list.push(writes, id);
+                    if (initializer) {
+                        state.prereq((0, transformInitializer_1.transformInitializer)(state, id, initializer));
+                    }
+                    (0, transformObjectAssignmentPattern_1.transformObjectAssignmentPattern)(state, element, id);
+                }
+                else {
+                    (0, assert_1.assert)(false, `transformOptimizedArrayAssignmentPattern invalid element: ${(0, getKindName_1.getKindName)(element.kind)}`);
+                }
+            }
+        }
+    });
+    if (!luau_ast_1.default.list.isEmpty(variables)) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: variables,
+            right: undefined,
+        }));
+    }
+    state.prereqList(writesPrereqs);
+    (0, assert_1.assert)(!luau_ast_1.default.list.isEmpty(writes));
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: writes,
+        operator: "=",
+        right: rhs,
+    }));
+    state.prereqList(statements);
+}
+function transformBinaryExpression(state, node) {
+    const operatorKind = node.operatorToken.kind;
+    (0, validateNotAny_1.validateNotAnyType)(state, node.left);
+    (0, validateNotAny_1.validateNotAnyType)(state, node.right);
+    if (operatorKind === typescript_1.default.SyntaxKind.EqualsEqualsToken) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noEqualsEquals(node));
+        return luau_ast_1.default.none();
+    }
+    else if (operatorKind === typescript_1.default.SyntaxKind.ExclamationEqualsToken) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noExclamationEquals(node));
+        return luau_ast_1.default.none();
+    }
+    if (operatorKind === typescript_1.default.SyntaxKind.AmpersandAmpersandToken ||
+        operatorKind === typescript_1.default.SyntaxKind.BarBarToken ||
+        operatorKind === typescript_1.default.SyntaxKind.QuestionQuestionToken) {
+        return (0, transformLogical_1.transformLogical)(state, node);
+    }
+    if (typescript_1.default.isLogicalOrCoalescingAssignmentExpression(node)) {
+        return (0, transformLogicalOrCoalescingAssignmentExpression_1.transformLogicalOrCoalescingAssignmentExpression)(state, node);
+    }
+    if (typescript_1.default.isAssignmentOperator(operatorKind)) {
+        if (typescript_1.default.isArrayLiteralExpression(node.left)) {
+            const rightExp = (0, transformExpression_1.transformExpression)(state, node.right);
+            if (node.left.elements.length === 0) {
+                if ((0, isUsedAsStatement_1.isUsedAsStatement)(node) && luau_ast_1.default.isArray(rightExp) && luau_ast_1.default.list.isEmpty(rightExp.members)) {
+                    return luau_ast_1.default.none();
+                }
+                return rightExp;
+            }
+            if (luau_ast_1.default.isCall(rightExp) &&
+                (0, types_1.isLuaTupleType)(state)(state.getType(node.right)) &&
+                !(0, arrayLikeExpressionContainsSpread_1.arrayLikeExpressionContainsSpread)(node.left)) {
+                transformOptimizedArrayAssignmentPattern(state, node.left, rightExp);
+                if (!(0, isUsedAsStatement_1.isUsedAsStatement)(node)) {
+                    DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noLuaTupleDestructureAssignmentExpression(node));
+                }
+                return luau_ast_1.default.none();
+            }
+            if (luau_ast_1.default.isArray(rightExp) &&
+                !luau_ast_1.default.list.isEmpty(rightExp.members) &&
+                (0, isUsedAsStatement_1.isUsedAsStatement)(node) &&
+                !(0, arrayLikeExpressionContainsSpread_1.arrayLikeExpressionContainsSpread)(node.left)) {
+                transformOptimizedArrayAssignmentPattern(state, node.left, rightExp.members);
+                return luau_ast_1.default.none();
+            }
+            const parentId = state.pushToVar(rightExp, "binding");
+            (0, transformArrayAssignmentPattern_1.transformArrayAssignmentPattern)(state, node.left, parentId);
+            return parentId;
+        }
+        else if (typescript_1.default.isObjectLiteralExpression(node.left)) {
+            const rightExp = (0, transformExpression_1.transformExpression)(state, node.right);
+            if (node.left.properties.length === 0) {
+                if ((0, isUsedAsStatement_1.isUsedAsStatement)(node) && luau_ast_1.default.isMap(rightExp) && luau_ast_1.default.list.isEmpty(rightExp.fields)) {
+                    return luau_ast_1.default.none();
+                }
+                return rightExp;
+            }
+            const parentId = state.pushToVar(rightExp, "binding");
+            (0, transformObjectAssignmentPattern_1.transformObjectAssignmentPattern)(state, node.left, parentId);
+            return parentId;
+        }
+        const writableType = state.getType(node.left);
+        const valueType = state.getType(node.right);
+        const operator = (0, assignment_1.getSimpleAssignmentOperator)(writableType, operatorKind, valueType);
+        const { writable, readable, value } = (0, transformWritable_1.transformWritableAssignment)(state, node.left, node.right, true, operator === undefined);
+        if (operator !== undefined) {
+            return (0, assignment_1.createAssignmentExpression)(state, writable, operator, (0, getAssignableValue_1.getAssignableValue)(operator, value, valueType));
+        }
+        else {
+            return (0, assignment_1.createCompoundAssignmentExpression)(state, node, writable, writableType, readable, operatorKind, value, valueType);
+        }
+    }
+    if ((0, bitwise_1.isBitwiseOperator)(operatorKind)) {
+        return (0, bitwise_1.createBitwiseFromOperator)(state, operatorKind, node);
+    }
+    const [left, right] = (0, ensureTransformOrder_1.ensureTransformOrder)(state, [node.left, node.right]);
+    if (operatorKind === typescript_1.default.SyntaxKind.InKeyword) {
+        return luau_ast_1.default.binary(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+            expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(right),
+            index: left,
+        }), "~=", luau_ast_1.default.nil());
+    }
+    else if (operatorKind === typescript_1.default.SyntaxKind.InstanceOfKeyword) {
+        if ((0, types_1.isPossiblyType)(state.getType(node.right), (0, types_1.isRobloxType)(state))) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noRobloxSymbolInstanceof(node.right));
+        }
+        return luau_ast_1.default.call(state.TS(node, "instanceof"), [left, right]);
+    }
+    const leftType = state.getType(node.left);
+    const rightType = state.getType(node.right);
+    if (operatorKind === typescript_1.default.SyntaxKind.LessThanToken ||
+        operatorKind === typescript_1.default.SyntaxKind.LessThanEqualsToken ||
+        operatorKind === typescript_1.default.SyntaxKind.GreaterThanToken ||
+        operatorKind === typescript_1.default.SyntaxKind.GreaterThanEqualsToken) {
+        if ((!(0, types_1.isDefinitelyType)(leftType, types_1.isStringType) && !(0, types_1.isDefinitelyType)(leftType, types_1.isNumberType)) ||
+            (!(0, types_1.isDefinitelyType)(rightType, types_1.isStringType) && !(0, types_1.isDefinitelyType)(leftType, types_1.isNumberType))) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noNonNumberStringRelationOperator(node));
+        }
+    }
+    return (0, createBinaryFromOperator_1.createBinaryFromOperator)(state, node, left, leftType, operatorKind, right, rightType);
+}
+//# sourceMappingURL=transformBinaryExpression.js.map

package/out/TSTransformer/nodes/expressions/transformBooleanLiteral.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function transformTrueKeyword(): luau.TrueLiteral;
+export declare function transformFalseKeyword(): luau.FalseLiteral;

package/out/TSTransformer/nodes/expressions/transformBooleanLiteral.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTrueKeyword = transformTrueKeyword;
+exports.transformFalseKeyword = transformFalseKeyword;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function transformTrueKeyword() {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.TrueLiteral, {});
+}
+function transformFalseKeyword() {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FalseLiteral, {});
+}
+//# sourceMappingURL=transformBooleanLiteral.js.map

package/out/TSTransformer/nodes/expressions/transformCallExpression.d.ts

@@ -0,0 +1,7 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformCallExpressionInner(state: TransformState, node: ts.CallExpression, expression: luau.Expression, nodeArguments: ReadonlyArray<ts.Expression>): luau.Expression<luau.SyntaxKind>;
+export declare function transformPropertyCallExpressionInner(state: TransformState, node: ts.CallExpression, expression: ts.PropertyAccessExpression, baseExpression: luau.Expression, name: string, nodeArguments: ReadonlyArray<ts.Expression>): luau.Expression<luau.SyntaxKind>;
+export declare function transformElementCallExpressionInner(state: TransformState, node: ts.CallExpression, expression: ts.ElementAccessExpression, baseExpression: luau.Expression, argumentExpression: ts.Expression, nodeArguments: ReadonlyArray<ts.Expression>): luau.Expression<luau.SyntaxKind>;
+export declare function transformCallExpression(state: TransformState, node: ts.CallExpression): luau.Expression<luau.SyntaxKind>;

package/out/TSTransformer/nodes/expressions/transformCallExpression.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformCallExpressionInner = transformCallExpressionInner;
+exports.transformPropertyCallExpressionInner = transformPropertyCallExpressionInner;
+exports.transformElementCallExpressionInner = transformElementCallExpressionInner;
+exports.transformCallExpression = transformCallExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const assert_1 = require("../../../Shared/util/assert");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformExpression_1 = require("./transformExpression");
+const transformImportExpression_1 = require("./transformImportExpression");
+const transformOptionalChain_1 = require("../transformOptionalChain");
+const addOneIfArrayType_1 = require("../../util/addOneIfArrayType");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const ensureTransformOrder_1 = require("../../util/ensureTransformOrder");
+const expressionMightMutate_1 = require("../../util/expressionMightMutate");
+const isMethod_1 = require("../../util/isMethod");
+const types_1 = require("../../util/types");
+const validateNotAny_1 = require("../../util/validateNotAny");
+const valueToIdStr_1 = require("../../util/valueToIdStr");
+const wrapReturnIfLuaTuple_1 = require("../../util/wrapReturnIfLuaTuple");
+const typescript_1 = __importDefault(require("typescript"));
+function runCallMacro(macro, state, node, expression, nodeArguments) {
+    let args;
+    const prereqs = state.capturePrereqs(() => {
+        args = (0, ensureTransformOrder_1.ensureTransformOrder)(state, nodeArguments);
+        const lastArg = nodeArguments[nodeArguments.length - 1];
+        if (lastArg && typescript_1.default.isSpreadElement(lastArg)) {
+            const signature = state.typeChecker.getSignaturesOfType(state.getType(node.expression), typescript_1.default.SignatureKind.Call)[0];
+            const lastParameter = signature.parameters[signature.parameters.length - 1].valueDeclaration;
+            if (lastParameter && typescript_1.default.isParameter(lastParameter) && lastParameter.dotDotDotToken) {
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noVarArgsMacroSpread(lastArg));
+                return;
+            }
+            const tupleArgType = state.getType(lastArg.expression);
+            (0, assert_1.assert)(state.typeChecker.isTupleType(tupleArgType));
+            const argumentCount = tupleArgType.target.elementFlags.length;
+            const spread = args.pop();
+            const tempIds = luau_ast_1.default.list.make();
+            for (let i = args.length; i < argumentCount; i++) {
+                const tempId = luau_ast_1.default.tempId(`spread${i}`);
+                args.push(tempId);
+                luau_ast_1.default.list.push(tempIds, tempId);
+            }
+            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                left: tempIds,
+                right: spread,
+            }));
+        }
+        for (let i = 0; i < args.length; i++) {
+            if ((0, expressionMightMutate_1.expressionMightMutate)(state, args[i], nodeArguments[i])) {
+                args[i] = state.pushToVar(args[i], (0, valueToIdStr_1.valueToIdStr)(args[i]) || `arg${i}`);
+            }
+        }
+    });
+    let nodeExpression = node.expression;
+    if (typescript_1.default.isPropertyAccessExpression(nodeExpression) || typescript_1.default.isElementAccessExpression(nodeExpression)) {
+        nodeExpression = nodeExpression.expression;
+    }
+    if (!luau_ast_1.default.list.isEmpty(prereqs) && (0, expressionMightMutate_1.expressionMightMutate)(state, expression, nodeExpression)) {
+        expression = state.pushToVar(expression, (0, valueToIdStr_1.valueToIdStr)(expression) || "exp");
+    }
+    state.prereqList(prereqs);
+    return (0, wrapReturnIfLuaTuple_1.wrapReturnIfLuaTuple)(state, node, macro(state, node, expression, args));
+}
+function fixVoidArgumentsForRobloxFunctions(state, type, args, nodeArguments) {
+    if ((0, types_1.isPossiblyType)(type, (0, types_1.isRobloxType)(state))) {
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            const nodeArg = nodeArguments[i];
+            if (typescript_1.default.isCallExpression(nodeArg) && (0, types_1.isPossiblyType)(state.getType(nodeArg), types_1.isUndefinedType)) {
+                args[i] = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ParenthesizedExpression, {
+                    expression: arg,
+                });
+            }
+        }
+    }
+}
+function transformCallExpressionInner(state, node, expression, nodeArguments) {
+    if (typescript_1.default.isImportCall(node)) {
+        return (0, transformImportExpression_1.transformImportExpression)(state, node);
+    }
+    (0, validateNotAny_1.validateNotAnyType)(state, node.expression);
+    if (typescript_1.default.isSuperCall(node)) {
+        return luau_ast_1.default.call(luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(expression), "constructor"), [
+            luau_ast_1.default.globals.self,
+            ...(0, ensureTransformOrder_1.ensureTransformOrder)(state, node.arguments),
+        ]);
+    }
+    const expType = state.typeChecker.getNonOptionalType(state.getType(node.expression));
+    const symbol = (0, types_1.getFirstDefinedSymbol)(state, expType);
+    if (symbol) {
+        const macro = state.services.macroManager.getCallMacro(symbol);
+        if (macro) {
+            return runCallMacro(macro, state, node, expression, nodeArguments);
+        }
+    }
+    const [args, prereqs] = state.capture(() => (0, ensureTransformOrder_1.ensureTransformOrder)(state, nodeArguments));
+    fixVoidArgumentsForRobloxFunctions(state, expType, args, nodeArguments);
+    if (!luau_ast_1.default.list.isEmpty(prereqs) && (0, expressionMightMutate_1.expressionMightMutate)(state, expression, node.expression)) {
+        expression = state.pushToVar(expression, "fn");
+    }
+    state.prereqList(prereqs);
+    const exp = luau_ast_1.default.call((0, convertToIndexableExpression_1.convertToIndexableExpression)(expression), args);
+    return (0, wrapReturnIfLuaTuple_1.wrapReturnIfLuaTuple)(state, node, exp);
+}
+function transformPropertyCallExpressionInner(state, node, expression, baseExpression, name, nodeArguments) {
+    (0, validateNotAny_1.validateNotAnyType)(state, expression.expression);
+    (0, validateNotAny_1.validateNotAnyType)(state, node.expression);
+    if (typescript_1.default.isSuperProperty(expression)) {
+        return luau_ast_1.default.call(luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(baseExpression), expression.name.text), [
+            luau_ast_1.default.globals.self,
+            ...(0, ensureTransformOrder_1.ensureTransformOrder)(state, node.arguments),
+        ]);
+    }
+    const expType = state.typeChecker.getNonOptionalType(state.getType(node.expression));
+    const symbol = (0, types_1.getFirstDefinedSymbol)(state, expType);
+    if (symbol) {
+        const macro = state.services.macroManager.getPropertyCallMacro(symbol);
+        if (macro) {
+            return runCallMacro(macro, state, node, baseExpression, nodeArguments);
+        }
+    }
+    const [args, prereqs] = state.capture(() => (0, ensureTransformOrder_1.ensureTransformOrder)(state, nodeArguments));
+    fixVoidArgumentsForRobloxFunctions(state, expType, args, nodeArguments);
+    if (!luau_ast_1.default.list.isEmpty(prereqs) && (0, expressionMightMutate_1.expressionMightMutate)(state, baseExpression, expression.expression)) {
+        baseExpression = state.pushToVar(baseExpression);
+    }
+    state.prereqList(prereqs);
+    let exp;
+    if ((0, isMethod_1.isMethod)(state, expression)) {
+        if (luau_ast_1.default.isValidIdentifier(name)) {
+            exp = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MethodCallExpression, {
+                name,
+                expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(baseExpression),
+                args: luau_ast_1.default.list.make(...args),
+            });
+        }
+        else {
+            baseExpression = state.pushToVarIfComplex(baseExpression);
+            args.unshift(baseExpression);
+            exp = luau_ast_1.default.call(luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(baseExpression), name), args);
+        }
+    }
+    else {
+        exp = luau_ast_1.default.call(luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(baseExpression), name), args);
+    }
+    return (0, wrapReturnIfLuaTuple_1.wrapReturnIfLuaTuple)(state, node, exp);
+}
+function transformElementCallExpressionInner(state, node, expression, baseExpression, argumentExpression, nodeArguments) {
+    (0, validateNotAny_1.validateNotAnyType)(state, expression.expression);
+    (0, validateNotAny_1.validateNotAnyType)(state, expression.argumentExpression);
+    (0, validateNotAny_1.validateNotAnyType)(state, node.expression);
+    if (typescript_1.default.isSuperProperty(expression)) {
+        return luau_ast_1.default.call(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+            expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(baseExpression),
+            index: (0, transformExpression_1.transformExpression)(state, expression.argumentExpression),
+        }), [luau_ast_1.default.globals.self, ...(0, ensureTransformOrder_1.ensureTransformOrder)(state, node.arguments)]);
+    }
+    const expType = state.typeChecker.getNonOptionalType(state.getType(node.expression));
+    const symbol = (0, types_1.getFirstDefinedSymbol)(state, expType);
+    if (symbol) {
+        const macro = state.services.macroManager.getPropertyCallMacro(symbol);
+        if (macro) {
+            return runCallMacro(macro, state, node, baseExpression, nodeArguments);
+        }
+    }
+    const [[argumentExp, ...args], prereqs] = state.capture(() => (0, ensureTransformOrder_1.ensureTransformOrder)(state, [argumentExpression, ...nodeArguments]));
+    fixVoidArgumentsForRobloxFunctions(state, expType, args, nodeArguments);
+    if (!luau_ast_1.default.list.isEmpty(prereqs) && (0, expressionMightMutate_1.expressionMightMutate)(state, baseExpression, expression.expression)) {
+        baseExpression = state.pushToVar(baseExpression);
+    }
+    state.prereqList(prereqs);
+    if ((0, isMethod_1.isMethod)(state, expression)) {
+        baseExpression = state.pushToVarIfComplex(baseExpression);
+        args.unshift(baseExpression);
+    }
+    const exp = luau_ast_1.default.call(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+        expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(baseExpression),
+        index: (0, addOneIfArrayType_1.addOneIfArrayType)(state, state.typeChecker.getNonOptionalType(state.getType(expression.expression)), argumentExp),
+    }), args);
+    return (0, wrapReturnIfLuaTuple_1.wrapReturnIfLuaTuple)(state, node, exp);
+}
+function transformCallExpression(state, node) {
+    return (0, transformOptionalChain_1.transformOptionalChain)(state, node);
+}
+//# sourceMappingURL=transformCallExpression.js.map

package/out/TSTransformer/nodes/expressions/transformClassExpression.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformClassExpression(state: TransformState, node: ts.ClassExpression): import("@roblox-ts/luau-ast/out/LuauAST/bundle").Identifier | import("@roblox-ts/luau-ast/out/LuauAST/bundle").TemporaryIdentifier;

package/out/TSTransformer/nodes/expressions/transformClassExpression.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformClassExpression = transformClassExpression;
+const transformClassLikeDeclaration_1 = require("../class/transformClassLikeDeclaration");
+function transformClassExpression(state, node) {
+    const { statements, name } = (0, transformClassLikeDeclaration_1.transformClassLikeDeclaration)(state, node);
+    state.prereqList(statements);
+    return name;
+}
+//# sourceMappingURL=transformClassExpression.js.map

package/out/TSTransformer/nodes/expressions/transformConditionalExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformConditionalExpression(state: TransformState, node: ts.ConditionalExpression): luau.TemporaryIdentifier | luau.None | luau.IfExpression;

package/out/TSTransformer/nodes/expressions/transformConditionalExpression.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformConditionalExpression = transformConditionalExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+const createTruthinessChecks_1 = require("../../util/createTruthinessChecks");
+const isUsedAsStatement_1 = require("../../util/isUsedAsStatement");
+const wrapExpressionStatement_1 = require("../../util/wrapExpressionStatement");
+function transformConditionalExpression(state, node) {
+    const condition = (0, transformExpression_1.transformExpression)(state, node.condition);
+    const [whenTrue, whenTruePrereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, node.whenTrue));
+    const [whenFalse, whenFalsePrereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, node.whenFalse));
+    if ((0, isUsedAsStatement_1.isUsedAsStatement)(node)) {
+        luau_ast_1.default.list.pushList(whenTruePrereqs, (0, wrapExpressionStatement_1.wrapExpressionStatement)(whenTrue));
+        luau_ast_1.default.list.pushList(whenFalsePrereqs, (0, wrapExpressionStatement_1.wrapExpressionStatement)(whenFalse));
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: (0, createTruthinessChecks_1.createTruthinessChecks)(state, condition, node.condition),
+            statements: whenTruePrereqs,
+            elseBody: whenFalsePrereqs,
+        }));
+        return luau_ast_1.default.none();
+    }
+    if (luau_ast_1.default.list.isEmpty(whenTruePrereqs) && luau_ast_1.default.list.isEmpty(whenFalsePrereqs)) {
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfExpression, {
+            condition: (0, createTruthinessChecks_1.createTruthinessChecks)(state, condition, node.condition),
+            expression: whenTrue,
+            alternative: whenFalse,
+        });
+    }
+    const tempId = luau_ast_1.default.tempId("result");
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+        left: tempId,
+        right: undefined,
+    }));
+    luau_ast_1.default.list.push(whenTruePrereqs, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: tempId,
+        operator: "=",
+        right: whenTrue,
+    }));
+    luau_ast_1.default.list.push(whenFalsePrereqs, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: tempId,
+        operator: "=",
+        right: whenFalse,
+    }));
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition: (0, createTruthinessChecks_1.createTruthinessChecks)(state, condition, node.condition),
+        statements: whenTruePrereqs,
+        elseBody: whenFalsePrereqs,
+    }));
+    return tempId;
+}
+//# sourceMappingURL=transformConditionalExpression.js.map

package/out/TSTransformer/nodes/expressions/transformDeleteExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformDeleteExpression(state: TransformState, node: ts.DeleteExpression): luau.None | luau.FalseLiteral | luau.TrueLiteral;

package/out/TSTransformer/nodes/expressions/transformDeleteExpression.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformDeleteExpression = transformDeleteExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+const isUsedAsStatement_1 = require("../../util/isUsedAsStatement");
+function transformDeleteExpression(state, node) {
+    (0, transformExpression_1.transformExpression)(state, node.expression);
+    return !(0, isUsedAsStatement_1.isUsedAsStatement)(node) ? luau_ast_1.default.bool(true) : luau_ast_1.default.none();
+}
+//# sourceMappingURL=transformDeleteExpression.js.map

package/out/TSTransformer/nodes/expressions/transformElementAccessExpression.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformElementAccessExpressionInner(state: TransformState, node: ts.ElementAccessExpression, expression: luau.Expression, argumentExpression: ts.Expression): luau.ComputedIndexExpression | luau.ParenthesizedExpression | luau.None;
+export declare function transformElementAccessExpression(state: TransformState, node: ts.ElementAccessExpression): luau.Expression<luau.SyntaxKind>;

package/out/TSTransformer/nodes/expressions/transformElementAccessExpression.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformElementAccessExpressionInner = transformElementAccessExpressionInner;
+exports.transformElementAccessExpression = transformElementAccessExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+const transformOptionalChain_1 = require("../transformOptionalChain");
+const addIndexDiagnostics_1 = require("../../util/addIndexDiagnostics");
+const addOneIfArrayType_1 = require("../../util/addOneIfArrayType");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const getConstantValueLiteral_1 = require("../../util/getConstantValueLiteral");
+const offset_1 = require("../../util/offset");
+const traversal_1 = require("../../util/traversal");
+const types_1 = require("../../util/types");
+const validateNotAny_1 = require("../../util/validateNotAny");
+const typescript_1 = __importDefault(require("typescript"));
+function transformElementAccessExpressionInner(state, node, expression, argumentExpression) {
+    (0, validateNotAny_1.validateNotAnyType)(state, node.expression);
+    (0, validateNotAny_1.validateNotAnyType)(state, node.argumentExpression);
+    const expType = state.typeChecker.getNonOptionalType(state.getType(node.expression));
+    (0, addIndexDiagnostics_1.addIndexDiagnostics)(state, node, expType);
+    const [index, prereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, argumentExpression));
+    if (!luau_ast_1.default.list.isEmpty(prereqs)) {
+        if ((0, types_1.isLuaTupleType)(state)(expType)) {
+            expression = luau_ast_1.default.array([expression]);
+        }
+        expression = state.pushToVar(expression, "exp");
+        state.prereqList(prereqs);
+    }
+    if (luau_ast_1.default.isCall(expression) && (0, types_1.isLuaTupleType)(state)(expType)) {
+        if (!luau_ast_1.default.isNumberLiteral(index) || Number(index.value) !== 0) {
+            expression = luau_ast_1.default.call(luau_ast_1.default.globals.select, [(0, offset_1.offset)(index, 1), expression]);
+        }
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ParenthesizedExpression, { expression });
+    }
+    if (typescript_1.default.isDeleteExpression((0, traversal_1.skipUpwards)(node).parent)) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
+                index: (0, addOneIfArrayType_1.addOneIfArrayType)(state, expType, index),
+            }),
+            operator: "=",
+            right: luau_ast_1.default.nil(),
+        }));
+        return luau_ast_1.default.none();
+    }
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+        expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
+        index: (0, addOneIfArrayType_1.addOneIfArrayType)(state, expType, index),
+    });
+}
+function transformElementAccessExpression(state, node) {
+    const constantValue = (0, getConstantValueLiteral_1.getConstantValueLiteral)(state, node);
+    if (constantValue) {
+        return constantValue;
+    }
+    return (0, transformOptionalChain_1.transformOptionalChain)(state, node);
+}
+//# sourceMappingURL=transformElementAccessExpression.js.map

package/out/TSTransformer/nodes/expressions/transformExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformExpression(state: TransformState, node: ts.Expression): luau.Expression;