roblox-ts/out/TSTransformer/macros/propertyCallMacros.js

A TypeScript-to-Luau Compiler for Roblox

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.PROPERTY_CALL_MACROS = void 0;
const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
const assert_1 = require("../../Shared/util/assert");
const convertToIndexableExpression_1 = require("../util/convertToIndexableExpression");
const isUsedAsStatement_1 = require("../util/isUsedAsStatement");
const offset_1 = require("../util/offset");
const types_1 = require("../util/types");
const valueToIdStr_1 = require("../util/valueToIdStr");
const typescript_1 = __importDefault(require("typescript"));
function makeMathMethod(operator) {
    return (state, node, expression, args) => {
        let rhs = args[0];
        if (!luau_ast_1.default.isSimple(rhs)) {
            rhs = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ParenthesizedExpression, { expression: rhs });
        }
        return luau_ast_1.default.binary(expression, operator, rhs);
    };
}
const OPERATOR_TO_NAME_MAP = new Map([
    ["+", "add"],
    ["-", "sub"],
    ["*", "mul"],
    ["/", "div"],
    ["//", "idiv"],
]);
function makeMathSet(...operators) {
    const result = {};
    for (const operator of operators) {
        const methodName = OPERATOR_TO_NAME_MAP.get(operator);
        (0, assert_1.assert)(methodName);
        result[methodName] = makeMathMethod(operator);
    }
    return result;
}
function makeStringCallback(strCallback) {
    return (state, node, expression, args) => {
        return luau_ast_1.default.call(strCallback, [expression, ...args]);
    };
}
const STRING_CALLBACKS = {
    size: (state, node, expression) => luau_ast_1.default.unary("#", expression),
    byte: makeStringCallback(luau_ast_1.default.globals.string.byte),
    find: makeStringCallback(luau_ast_1.default.globals.string.find),
    format: makeStringCallback(luau_ast_1.default.globals.string.format),
    gmatch: makeStringCallback(luau_ast_1.default.globals.string.gmatch),
    gsub: makeStringCallback(luau_ast_1.default.globals.string.gsub),
    lower: makeStringCallback(luau_ast_1.default.globals.string.lower),
    match: makeStringCallback(luau_ast_1.default.globals.string.match),
    rep: makeStringCallback(luau_ast_1.default.globals.string.rep),
    reverse: makeStringCallback(luau_ast_1.default.globals.string.reverse),
    split: makeStringCallback(luau_ast_1.default.globals.string.split),
    sub: makeStringCallback(luau_ast_1.default.globals.string.sub),
    upper: makeStringCallback(luau_ast_1.default.globals.string.upper),
};
function makeEveryOrSomeMethod(callbackArgsListMaker, initialState) {
    return (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const resultId = state.pushToVar(luau_ast_1.default.bool(initialState), "result");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const keyId = luau_ast_1.default.tempId("k");
        const valueId = luau_ast_1.default.tempId("v");
        const callCallback = luau_ast_1.default.call(callbackId, callbackArgsListMaker(keyId, valueId, expression));
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(keyId, valueId),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: initialState ? luau_ast_1.default.unary("not", callCallback) : callCallback,
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: resultId,
                    operator: "=",
                    right: luau_ast_1.default.bool(!initialState),
                }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BreakStatement, {})),
                elseBody: luau_ast_1.default.list.make(),
            })),
        }));
        return resultId;
    };
}
function makeEveryMethod(callbackArgsListMaker) {
    return makeEveryOrSomeMethod(callbackArgsListMaker, true);
}
function makeSomeMethod(callbackArgsListMaker) {
    return makeEveryOrSomeMethod(callbackArgsListMaker, false);
}
function argumentsWithDefaults(state, args, defaults) {
    for (let i = 0; i < args.length; i++) {
        if (!luau_ast_1.default.isSimplePrimitive(args[i])) {
            args[i] = state.pushToVar(args[i], (0, valueToIdStr_1.valueToIdStr)(args[i]) || `arg${i}`);
            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: luau_ast_1.default.binary(args[i], "==", luau_ast_1.default.nil()),
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: args[i],
                    operator: "=",
                    right: defaults[i],
                })),
                elseBody: luau_ast_1.default.list.make(),
            }));
        }
    }
    for (let j = args.length; j < defaults.length; j++) {
        args[j] = defaults[j];
    }
    return args;
}
const ARRAY_LIKE_METHODS = {
    size: (state, node, expression) => luau_ast_1.default.unary("#", expression),
};
const READONLY_ARRAY_METHODS = {
    isEmpty: (state, node, expression) => luau_ast_1.default.binary(luau_ast_1.default.unary("#", expression), "==", luau_ast_1.default.number(0)),
    join: (state, node, expression, args) => {
        args = argumentsWithDefaults(state, args, [luau_ast_1.default.strings[", "]]);
        const indexType = state.typeChecker.getIndexTypeOfType(state.getType(node.expression.expression), typescript_1.default.IndexKind.Number);
        if (indexType && !(0, types_1.isDefinitelyType)(indexType, types_1.isStringType, types_1.isNumberType)) {
            expression = state.pushToVarIfComplex(expression, "exp");
            const id = state.pushToVar(luau_ast_1.default.call(luau_ast_1.default.globals.table.create, [luau_ast_1.default.unary("#", expression)]), "result");
            const keyId = luau_ast_1.default.tempId("k");
            const valueId = luau_ast_1.default.tempId("v");
            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
                ids: luau_ast_1.default.list.make(keyId, valueId),
                expression,
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                        expression: id,
                        index: keyId,
                    }),
                    operator: "=",
                    right: luau_ast_1.default.call(luau_ast_1.default.globals.tostring, [valueId]),
                })),
            }));
            expression = id;
        }
        return luau_ast_1.default.call(luau_ast_1.default.globals.table.concat, [expression, args[0]]);
    },
    move: (state, node, expression, args) => {
        const moveArgs = [expression, (0, offset_1.offset)(args[0], 1), (0, offset_1.offset)(args[1], 1), (0, offset_1.offset)(args[2], 1)];
        if (args[3]) {
            moveArgs.push(args[3]);
        }
        return luau_ast_1.default.call(luau_ast_1.default.globals.table.move, moveArgs);
    },
    includes: (state, node, expression, args) => {
        const callArgs = [expression, args[0]];
        if (args[1]) {
            callArgs.push((0, offset_1.offset)(args[1], 1));
        }
        return luau_ast_1.default.binary(luau_ast_1.default.call(luau_ast_1.default.globals.table.find, callArgs), "~=", luau_ast_1.default.nil());
    },
    indexOf: (state, node, expression, args) => {
        const findArgs = [expression, args[0]];
        if (args.length > 1) {
            findArgs.push((0, offset_1.offset)(args[1], 1));
        }
        return (0, offset_1.offset)(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BinaryExpression, {
            left: luau_ast_1.default.call(luau_ast_1.default.globals.table.find, findArgs),
            operator: "or",
            right: luau_ast_1.default.number(0),
        }), -1);
    },
    every: makeEveryMethod((keyId, valueId, expression) => [valueId, (0, offset_1.offset)(keyId, -1), expression]),
    some: makeSomeMethod((keyId, valueId, expression) => [valueId, (0, offset_1.offset)(keyId, -1), expression]),
    forEach: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const keyId = luau_ast_1.default.tempId("k");
        const valueId = luau_ast_1.default.tempId("v");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(keyId, valueId),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
                expression: luau_ast_1.default.call(callbackId, [valueId, (0, offset_1.offset)(keyId, -1), expression]),
            })),
        }));
        return !(0, isUsedAsStatement_1.isUsedAsStatement)(node) ? luau_ast_1.default.nil() : luau_ast_1.default.none();
    },
    map: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const newValueId = state.pushToVar(luau_ast_1.default.call(luau_ast_1.default.globals.table.create, [luau_ast_1.default.unary("#", expression)]), "newValue");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const keyId = luau_ast_1.default.tempId("k");
        const valueId = luau_ast_1.default.tempId("v");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(keyId, valueId),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                    expression: newValueId,
                    index: keyId,
                }),
                operator: "=",
                right: luau_ast_1.default.call(callbackId, [valueId, (0, offset_1.offset)(keyId, -1), expression]),
            })),
        }));
        return newValueId;
    },
    mapFiltered: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const newValueId = state.pushToVar(luau_ast_1.default.array(), "newValue");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const lengthId = state.pushToVar(luau_ast_1.default.number(0), "length");
        const keyId = luau_ast_1.default.tempId("k");
        const valueId = luau_ast_1.default.tempId("v");
        const resultId = luau_ast_1.default.tempId("result");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(keyId, valueId),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
                left: resultId,
                right: luau_ast_1.default.call(callbackId, [valueId, (0, offset_1.offset)(keyId, -1), expression]),
            }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: luau_ast_1.default.binary(resultId, "~=", luau_ast_1.default.nil()),
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: lengthId,
                    operator: "+=",
                    right: luau_ast_1.default.number(1),
                }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                        expression: newValueId,
                        index: lengthId,
                    }),
                    operator: "=",
                    right: resultId,
                })),
                elseBody: luau_ast_1.default.list.make(),
            })),
        }));
        return newValueId;
    },
    filterUndefined: (state, node, expression) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const lengthId = state.pushToVar(luau_ast_1.default.number(0), "length");
        const indexId1 = luau_ast_1.default.tempId("i");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(indexId1),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: luau_ast_1.default.binary(indexId1, ">", lengthId),
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: lengthId,
                    operator: "=",
                    right: indexId1,
                })),
                elseBody: luau_ast_1.default.list.make(),
            })),
        }));
        const resultId = state.pushToVar(luau_ast_1.default.array(), "result");
        const resultLengthId = state.pushToVar(luau_ast_1.default.number(0), "resultLength");
        const indexId2 = luau_ast_1.default.tempId("i");
        const valueId = luau_ast_1.default.tempId("v");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.NumericForStatement, {
            id: indexId2,
            start: luau_ast_1.default.number(1),
            end: lengthId,
            step: undefined,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
                left: valueId,
                right: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                    expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
                    index: indexId2,
                }),
            }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: luau_ast_1.default.binary(valueId, "~=", luau_ast_1.default.nil()),
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: resultLengthId,
                    operator: "+=",
                    right: luau_ast_1.default.number(1),
                }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                        expression: resultId,
                        index: resultLengthId,
                    }),
                    operator: "=",
                    right: valueId,
                })),
                elseBody: luau_ast_1.default.list.make(),
            })),
        }));
        return resultId;
    },
    filter: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const newValueId = state.pushToVar(luau_ast_1.default.array(), "newValue");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const lengthId = state.pushToVar(luau_ast_1.default.number(0), "length");
        const keyId = luau_ast_1.default.tempId("k");
        const valueId = luau_ast_1.default.tempId("v");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(keyId, valueId),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BinaryExpression, {
                    left: luau_ast_1.default.call(callbackId, [valueId, (0, offset_1.offset)(keyId, -1), expression]),
                    operator: "==",
                    right: luau_ast_1.default.bool(true),
                }),
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: lengthId,
                    operator: "+=",
                    right: luau_ast_1.default.number(1),
                }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                        expression: newValueId,
                        index: lengthId,
                    }),
                    operator: "=",
                    right: valueId,
                })),
                elseBody: luau_ast_1.default.list.make(),
            })),
        }));
        return newValueId;
    },
    reduce: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        let start = luau_ast_1.default.number(1);
        const end = luau_ast_1.default.unary("#", expression);
        const step = 1;
        const lengthExp = luau_ast_1.default.unary("#", expression);
        let resultId;
        if (args.length < 2) {
            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: luau_ast_1.default.binary(lengthExp, "==", luau_ast_1.default.number(0)),
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
                    expression: luau_ast_1.default.call(luau_ast_1.default.globals.error, [
                        luau_ast_1.default.string("Attempted to call `ReadonlyArray.reduce()` on an empty array without an initialValue."),
                    ]),
                })),
                elseBody: luau_ast_1.default.list.make(),
            }));
            resultId = state.pushToVar(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
                index: start,
            }), "result");
            start = (0, offset_1.offset)(start, step);
        }
        else {
            resultId = state.pushToVar(args[1], "result");
        }
        const callbackId = state.pushToVar(args[0], "callback");
        const iteratorId = luau_ast_1.default.tempId("i");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.NumericForStatement, {
            id: iteratorId,
            start,
            end,
            step: step === 1 ? undefined : luau_ast_1.default.number(step),
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                left: resultId,
                operator: "=",
                right: luau_ast_1.default.call(callbackId, [
                    resultId,
                    luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                        expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
                        index: iteratorId,
                    }),
                    (0, offset_1.offset)(iteratorId, -1),
                    expression,
                ]),
            })),
        }));
        return resultId;
    },
    find: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const loopId = luau_ast_1.default.tempId("i");
        const valueId = luau_ast_1.default.tempId("v");
        const resultId = state.pushToVar(undefined, "result");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            expression,
            ids: luau_ast_1.default.list.make(loopId, valueId),
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BinaryExpression, {
                    left: luau_ast_1.default.call(callbackId, [valueId, (0, offset_1.offset)(loopId, -1), expression]),
                    operator: "==",
                    right: luau_ast_1.default.bool(true),
                }),
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: resultId,
                    operator: "=",
                    right: valueId,
                }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BreakStatement, {})),
                elseBody: luau_ast_1.default.list.make(),
            })),
        }));
        return resultId;
    },
    findIndex: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const loopId = luau_ast_1.default.tempId("i");
        const valueId = luau_ast_1.default.tempId("v");
        const resultId = state.pushToVar(luau_ast_1.default.number(-1), "result");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            expression,
            ids: luau_ast_1.default.list.make(loopId, valueId),
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
                condition: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BinaryExpression, {
                    left: luau_ast_1.default.call(callbackId, [valueId, (0, offset_1.offset)(loopId, -1), expression]),
                    operator: "==",
                    right: luau_ast_1.default.bool(true),
                }),
                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                    left: resultId,
                    operator: "=",
                    right: (0, offset_1.offset)(loopId, -1),
                }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BreakStatement, {})),
                elseBody: luau_ast_1.default.list.make(),
            })),
        }));
        return resultId;
    },
};
const ARRAY_METHODS = {
    push: (state, node, expression, args) => {
        if (args.length === 0) {
            return luau_ast_1.default.unary("#", expression);
        }
        expression = state.pushToVarIfComplex(expression, "exp");
        for (let i = 0; i < args.length; i++) {
            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
                expression: luau_ast_1.default.call(luau_ast_1.default.globals.table.insert, [expression, args[i]]),
            }));
        }
        return !(0, isUsedAsStatement_1.isUsedAsStatement)(node) ? luau_ast_1.default.unary("#", expression) : luau_ast_1.default.none();
    },
    pop: (state, node, expression) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        let lengthExp = luau_ast_1.default.unary("#", expression);
        const returnValueIsUsed = !(0, isUsedAsStatement_1.isUsedAsStatement)(node);
        let retValue;
        if (returnValueIsUsed) {
            lengthExp = state.pushToVar(lengthExp, "length");
            retValue = state.pushToVar(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
                index: lengthExp,
            }), "result");
        }
        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: lengthExp,
            }),
            operator: "=",
            right: luau_ast_1.default.nil(),
        }));
        return returnValueIsUsed ? retValue : luau_ast_1.default.none();
    },
    shift: (state, node, expression) => luau_ast_1.default.call(luau_ast_1.default.globals.table.remove, [expression, luau_ast_1.default.number(1)]),
    unshift: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        for (let i = args.length - 1; i >= 0; i--) {
            const arg = args[i];
            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
                expression: luau_ast_1.default.call(luau_ast_1.default.globals.table.insert, [expression, luau_ast_1.default.number(1), arg]),
            }));
        }
        return !(0, isUsedAsStatement_1.isUsedAsStatement)(node) ? luau_ast_1.default.unary("#", expression) : luau_ast_1.default.none();
    },
    insert: (state, node, expression, args) => {
        return luau_ast_1.default.call(luau_ast_1.default.globals.table.insert, [expression, (0, offset_1.offset)(args[0], 1), args[1]]);
    },
    remove: (state, node, expression, args) => luau_ast_1.default.call(luau_ast_1.default.globals.table.remove, [expression, (0, offset_1.offset)(args[0], 1)]),
    unorderedRemove: (state, node, expression, args) => {
        const indexExp = state.pushToVarIfComplex((0, offset_1.offset)(args[0], 1), "index");
        expression = state.pushToVarIfComplex(expression, "exp");
        const lengthId = state.pushToVar(luau_ast_1.default.unary("#", expression), "length");
        const valueIsUsed = !(0, isUsedAsStatement_1.isUsedAsStatement)(node);
        const valueId = state.pushToVar(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
            expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
            index: indexExp,
        }), "value");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
            condition: luau_ast_1.default.binary(valueId, "~=", luau_ast_1.default.nil()),
            statements: luau_ast_1.default.list.make(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: indexExp,
                }),
                operator: "=",
                right: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                    expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
                    index: lengthId,
                }),
            }), 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: lengthId,
                }),
                operator: "=",
                right: luau_ast_1.default.nil(),
            })),
            elseBody: luau_ast_1.default.list.make(),
        }));
        return valueIsUsed ? valueId : luau_ast_1.default.none();
    },
    sort: (state, node, expression, args) => {
        const valueIsUsed = !(0, isUsedAsStatement_1.isUsedAsStatement)(node);
        if (valueIsUsed) {
            expression = state.pushToVarIfComplex(expression, "exp");
        }
        args.unshift(expression);
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
            expression: luau_ast_1.default.call(luau_ast_1.default.globals.table.sort, args),
        }));
        return valueIsUsed ? expression : luau_ast_1.default.none();
    },
    clear: (state, node, expression) => {
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
            expression: luau_ast_1.default.call(luau_ast_1.default.globals.table.clear, [expression]),
        }));
        return !(0, isUsedAsStatement_1.isUsedAsStatement)(node) ? luau_ast_1.default.nil() : luau_ast_1.default.none();
    },
};
const READONLY_SET_MAP_SHARED_METHODS = {
    isEmpty: (state, node, expression) => luau_ast_1.default.binary(luau_ast_1.default.call(luau_ast_1.default.globals.next, [expression]), "==", luau_ast_1.default.nil()),
    size: (state, node, expression) => {
        const sizeId = state.pushToVar(luau_ast_1.default.number(0), "size");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(luau_ast_1.default.tempId()),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
                left: sizeId,
                operator: "+=",
                right: luau_ast_1.default.number(1),
            })),
        }));
        return sizeId;
    },
    has: (state, node, expression, args) => {
        const left = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
            expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
            index: args[0],
        });
        return luau_ast_1.default.binary(left, "~=", luau_ast_1.default.nil());
    },
};
const SET_MAP_SHARED_METHODS = {
    delete: (state, node, expression, args) => {
        const arg = state.pushToVarIfComplex(args[0], "value");
        const valueIsUsed = !(0, isUsedAsStatement_1.isUsedAsStatement)(node);
        let valueExistedId;
        if (valueIsUsed) {
            expression = state.pushToVarIfNonId(expression, "exp");
            valueExistedId = state.pushToVar(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BinaryExpression, {
                left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
                    expression,
                    index: arg,
                }),
                operator: "~=",
                right: luau_ast_1.default.nil(),
            }), "valueExisted");
        }
        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: arg,
            }),
            operator: "=",
            right: luau_ast_1.default.nil(),
        }));
        return valueIsUsed ? valueExistedId : luau_ast_1.default.none();
    },
    clear: (state, node, expression) => {
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
            expression: luau_ast_1.default.call(luau_ast_1.default.globals.table.clear, [expression]),
        }));
        return !(0, isUsedAsStatement_1.isUsedAsStatement)(node) ? luau_ast_1.default.nil() : luau_ast_1.default.none();
    },
};
const READONLY_SET_METHODS = {
    ...READONLY_SET_MAP_SHARED_METHODS,
    forEach: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const valueId = luau_ast_1.default.tempId("v");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(valueId),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
                expression: luau_ast_1.default.call(callbackId, [valueId, valueId, expression]),
            })),
        }));
        return !(0, isUsedAsStatement_1.isUsedAsStatement)(node) ? luau_ast_1.default.nil() : luau_ast_1.default.none();
    },
};
const SET_METHODS = {
    ...SET_MAP_SHARED_METHODS,
    add: (state, node, expression, args) => {
        const valueIsUsed = !(0, isUsedAsStatement_1.isUsedAsStatement)(node);
        if (valueIsUsed) {
            expression = state.pushToVarIfComplex(expression, "exp");
        }
        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: args[0],
            }),
            operator: "=",
            right: luau_ast_1.default.bool(true),
        }));
        return valueIsUsed ? expression : luau_ast_1.default.none();
    },
};
const READONLY_MAP_METHODS = {
    ...READONLY_SET_MAP_SHARED_METHODS,
    forEach: (state, node, expression, args) => {
        expression = state.pushToVarIfComplex(expression, "exp");
        const callbackId = state.pushToVarIfNonId(args[0], "callback");
        const keyId = luau_ast_1.default.tempId("k");
        const valueId = luau_ast_1.default.tempId("v");
        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
            ids: luau_ast_1.default.list.make(keyId, valueId),
            expression,
            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
                expression: luau_ast_1.default.call(callbackId, [valueId, keyId, expression]),
            })),
        }));
        return !(0, isUsedAsStatement_1.isUsedAsStatement)(node) ? luau_ast_1.default.nil() : luau_ast_1.default.none();
    },
    get: (state, node, expression, args) => luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
        expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
        index: args[0],
    }),
};
const MAP_METHODS = {
    ...SET_MAP_SHARED_METHODS,
    set: (state, node, expression, args) => {
        const [keyExp, valueExp] = args;
        const valueIsUsed = !(0, isUsedAsStatement_1.isUsedAsStatement)(node);
        if (valueIsUsed) {
            expression = state.pushToVarIfComplex(expression, "exp");
        }
        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: keyExp,
            }),
            operator: "=",
            right: valueExp,
        }));
        return valueIsUsed ? expression : luau_ast_1.default.none();
    },
};
const PROMISE_METHODS = {
    then: (state, node, expression, args) => luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MethodCallExpression, {
        expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
        name: "andThen",
        args: luau_ast_1.default.list.make(...args),
    }),
};
exports.PROPERTY_CALL_MACROS = {
    CFrame: makeMathSet("+", "-", "*"),
    UDim: makeMathSet("+", "-"),
    UDim2: makeMathSet("+", "-"),
    Vector2: makeMathSet("+", "-", "*", "/", "//"),
    Vector2int16: makeMathSet("+", "-", "*", "/"),
    Vector3: makeMathSet("+", "-", "*", "/", "//"),
    Vector3int16: makeMathSet("+", "-", "*", "/"),
    Number: makeMathSet("//"),
    String: STRING_CALLBACKS,
    ArrayLike: ARRAY_LIKE_METHODS,
    ReadonlyArray: READONLY_ARRAY_METHODS,
    Array: ARRAY_METHODS,
    ReadonlySet: READONLY_SET_METHODS,
    Set: SET_METHODS,
    ReadonlyMap: READONLY_MAP_METHODS,
    Map: MAP_METHODS,
    Promise: PROMISE_METHODS,
};
function header(text) {
    return luau_ast_1.default.comment(` ▼ ${text} ▼`);
}
function footer(text) {
    return luau_ast_1.default.comment(` ▲ ${text} ▲`);
}
function wasExpressionPushed(statements, expression) {
    if (luau_ast_1.default.list.isNonEmpty(statements)) {
        const firstStatement = statements.head.value;
        if (luau_ast_1.default.isVariableDeclaration(firstStatement)) {
            if (!luau_ast_1.default.list.isList(firstStatement.left) && luau_ast_1.default.isTemporaryIdentifier(firstStatement.left)) {
                if (firstStatement.right === expression) {
                    return true;
                }
            }
        }
    }
    return false;
}
function wrapComments(methodName, callback) {
    return (state, callNode, callExp, args) => {
        const [expression, prereqs] = state.capture(() => callback(state, callNode, callExp, args));
        let size = luau_ast_1.default.list.size(prereqs);
        if (size > 0) {
            const wasPushed = wasExpressionPushed(prereqs, callExp);
            let pushStatement;
            if (wasPushed) {
                pushStatement = luau_ast_1.default.list.shift(prereqs);
                size--;
            }
            if (size > 1) {
                luau_ast_1.default.list.unshift(prereqs, header(methodName));
                if (wasPushed && pushStatement) {
                    luau_ast_1.default.list.unshift(prereqs, pushStatement);
                }
                luau_ast_1.default.list.push(prereqs, footer(methodName));
            }
            else {
                if (wasPushed && pushStatement) {
                    luau_ast_1.default.list.unshift(prereqs, pushStatement);
                }
            }
        }
        state.prereqList(prereqs);
        return expression;
    };
}
for (const [className, macroList] of Object.entries(exports.PROPERTY_CALL_MACROS)) {
    for (const [methodName, macro] of Object.entries(macroList)) {
        macroList[methodName] = wrapComments(`${className}.${methodName}`, macro);
    }
}
//# sourceMappingURL=propertyCallMacros.js.map