eslint-plugin-ts-data-forge 0.6.1 → 0.7.0

package/dist/rules/prefer-canonical-array-slicing.mjs

@@ -1,362 +1,522 @@
-import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, ESLintUtils, } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
-import { getTsDataForgeImport, getImportedLocalName, buildImportFixes } from './import-utils.mjs';
+import { buildImportFixes, getImportedLocalName, getTsDataForgeImport, } from './import-utils.mjs';
+
+const normalizeCountedOp = (fn, count) => count < 1
+    ? undefined
+    : fn === 'skip' && count === 1
+        ? { fn: 'tail' }
+        : fn === 'skipLast' && count === 1
+            ? { fn: 'butLast' }
+            : { fn, count };
+const asNonNegativeIntegerLiteral = (node) => node.type === AST_NODE_TYPES.Literal &&
+    typeof node.value === 'number' &&
+    Number.isInteger(node.value) &&
+    node.value >= 0
+    ? node.value
+    : undefined;
 
-const normalizeCountedOp = (fn, count) => count < 1 ? void 0 : fn === "skip" && count === 1 ? { fn: "tail" } : fn === "skipLast" && count === 1 ? { fn: "butLast" } : { fn, count };
-const asNonNegativeIntegerLiteral = (node) => node.type === AST_NODE_TYPES.Literal && typeof node.value === "number" && Number.isInteger(node.value) && node.value >= 0 ? node.value : void 0;
 const asNegatedPositiveIntegerLiteral = (node) => {
-  if (node.type !== AST_NODE_TYPES.UnaryExpression || node.operator !== "-" || node.argument.type !== AST_NODE_TYPES.Literal) {
-    return void 0;
-  }
-  const n = asNonNegativeIntegerLiteral(node.argument);
-  return n !== void 0 && n >= 1 ? n : void 0;
+    if (node.type !== AST_NODE_TYPES.UnaryExpression ||
+        node.operator !== '-' ||
+        node.argument.type !== AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    const n = asNonNegativeIntegerLiteral(node.argument);
+    return n !== undefined && n >= 1 ? n : undefined;
 };
-const isSimpleReference = (node) => node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.ThisExpression || node.type === AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES.Identifier && isSimpleReference(node.object);
-const rootIdentifierName = (node) => node.type === AST_NODE_TYPES.Identifier ? node.name : node.type === AST_NODE_TYPES.MemberExpression ? rootIdentifierName(node.object) : void 0;
-const COMPARISON_OPERATORS = /* @__PURE__ */ new Set([
-  "!==",
-  "<",
-  "<=",
-  ">",
-  ">="
+
+
+
+
+
+const isSimpleReference = (node) => node.type === AST_NODE_TYPES.Identifier ||
+    node.type === AST_NODE_TYPES.ThisExpression ||
+    (node.type === AST_NODE_TYPES.MemberExpression &&
+        !node.computed &&
+        node.property.type === AST_NODE_TYPES.Identifier &&
+        isSimpleReference(node.object));
+const rootIdentifierName = (node) => node.type === AST_NODE_TYPES.Identifier
+    ? node.name
+    : node.type === AST_NODE_TYPES.MemberExpression
+        ? rootIdentifierName(node.object)
+        : undefined;
+const COMPARISON_OPERATORS = new Set([
+    '!==',
+    '<',
+    '<=',
+    '>',
+    '>=',
 ]);
+
 const FLIPPED_OPERATORS = {
-  "!==": "!==",
-  "<": ">",
-  "<=": ">=",
-  ">": "<",
-  ">=": "<="
+    '!==': '!==',
+    '<': '>',
+    '<=': '>=',
+    '>': '<',
+    '>=': '<=',
 };
+
 const classifyLiteralComparison = (op, n) => {
-  switch (op) {
-    case ">=":
-      return normalizeCountedOp("skip", n);
-    case ">":
-      return normalizeCountedOp("skip", n + 1);
-    case "!==":
-      return n === 0 ? { fn: "tail" } : void 0;
-    case "<":
-      return normalizeCountedOp("take", n);
-    case "<=":
-      return normalizeCountedOp("take", n + 1);
-  }
+    switch (op) {
+        case '>=':
+            return normalizeCountedOp('skip', n);
+        case '>':
+            return normalizeCountedOp('skip', n + 1);
+        case '!==':
+            return n === 0 ? { fn: 'tail' } : undefined;
+        case '<':
+            return normalizeCountedOp('take', n);
+        case '<=':
+            return normalizeCountedOp('take', n + 1);
+    }
 };
+
 const classifyLengthComparison = (op, m) => {
-  switch (op) {
-    case "<":
-      return normalizeCountedOp("skipLast", m);
-    case "<=":
-      return normalizeCountedOp("skipLast", m - 1);
-    case "!==":
-      return m === 1 ? { fn: "butLast" } : void 0;
-    case ">=":
-      return normalizeCountedOp("takeLast", m);
-    case ">":
-      return normalizeCountedOp("takeLast", m - 1);
-  }
+    switch (op) {
+        case '<':
+            return normalizeCountedOp('skipLast', m);
+        case '<=':
+            return normalizeCountedOp('skipLast', m - 1);
+        case '!==':
+            return m === 1 ? { fn: 'butLast' } : undefined;
+        case '>=':
+            return normalizeCountedOp('takeLast', m);
+        case '>':
+            return normalizeCountedOp('takeLast', m - 1);
+    }
 };
-const preferCanonicalArraySlicing = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Unify non-mutating array element addition/removal patterns (`slice` / `toSpliced` / `filter` / `concat` / spread) into the corresponding ts-data-forge functions: `Arr.tail`, `Arr.skip`, `Arr.take`, `Arr.butLast`, `Arr.skipLast`, `Arr.takeLast`, `Arr.toUnshifted`, `Arr.toPushed`."
+export const preferCanonicalArraySlicing = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Unify non-mutating array element addition/removal patterns (`slice` / `toSpliced` / `filter` / `concat` / spread) into the corresponding ts-data-forge functions: `Arr.tail`, `Arr.skip`, `Arr.take`, `Arr.butLast`, `Arr.skipLast`, `Arr.takeLast`, `Arr.toUnshifted`, `Arr.toPushed`.',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferCanonicalArraySlicing: 'Replace with `{{replacement}}` from ts-data-forge.',
+        },
     },
-    fixable: "code",
-    schema: [],
-    messages: {
-      preferCanonicalArraySlicing: "Replace with `{{replacement}}` from ts-data-forge."
-    }
-  },
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    const program = sourceCode.ast;
-    const tsDataForgeImport = getTsDataForgeImport(program);
-    const parserServices = ESLintUtils.getParserServices(context);
-    const checker = parserServices.program.getTypeChecker();
-    const arrLocalName = getImportedLocalName(tsDataForgeImport, "Arr");
-    const namespaceLocalName = tsDataForgeImport?.specifiers.find(
-      (specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier
-    )?.local.name;
-    const arrRef = arrLocalName ?? (namespaceLocalName === void 0 ? "Arr" : `${namespaceLocalName}.Arr`);
-    const needsArrImport = arrLocalName === void 0 && namespaceLocalName === void 0;
-    const isArrayOrTupleType = (type) => {
-      if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
-        return false;
-      }
-      if (type.isUnion()) {
-        return type.types.every(isArrayOrTupleType);
-      }
-      if ((type.flags & (ts.TypeFlags.TypeParameter | ts.TypeFlags.IndexedAccess | ts.TypeFlags.Conditional | ts.TypeFlags.Substitution)) !== 0) {
-        const constraint = checker.getBaseConstraintOfType(type);
-        return constraint !== void 0 && isArrayOrTupleType(constraint);
-      }
-      return checker.isArrayType(type) || checker.isTupleType(type);
-    };
-    const getTypeOf = (node) => checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(node));
-    const isDefinitelyNotArrayType = (type) => {
-      if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
-        return false;
-      }
-      if (type.isUnion()) {
-        return type.types.every(isDefinitelyNotArrayType);
-      }
-      if ((type.flags & (ts.TypeFlags.TypeParameter | ts.TypeFlags.IndexedAccess | ts.TypeFlags.Conditional | ts.TypeFlags.Substitution)) !== 0) {
-        const constraint = checker.getBaseConstraintOfType(type);
-        return constraint !== void 0 && isDefinitelyNotArrayType(constraint);
-      }
-      return !checker.isArrayType(type) && !checker.isTupleType(type);
-    };
-    const toArgText = (node) => {
-      const text = sourceCode.getText(node);
-      return node.type === AST_NODE_TYPES.SequenceExpression ? `(${text})` : text;
-    };
-    const toReplacementText = (op, xsText) => {
-      switch (op.fn) {
-        case "tail":
-        case "butLast":
-          return `${arrRef}.${op.fn}(${xsText})`;
-        case "skip":
-        case "take":
-        case "skipLast":
-        case "takeLast":
-          return `${arrRef}.${op.fn}(${xsText}, ${op.count})`;
-        // Emit the curried form for `toUnshifted` so the new element stays in
-        // the same textual position as in the `[item, ...xs]` source, keeping
-        // the rewrite easy to read.
-        case "toUnshifted":
-          return `${arrRef}.toUnshifted(${op.itemText})(${xsText})`;
-        case "toPushed":
-          return `${arrRef}.toPushed(${xsText}, ${op.itemText})`;
-      }
-    };
-    const mut_nodesToFix = [];
-    const report = (node, op, xsText) => {
-      mut_nodesToFix.push({
-        node,
-        replacement: toReplacementText(op, xsText)
-      });
-    };
-    const isReceiverLengthAccess = (node, receiverText) => node.type === AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "length" && sourceCode.getText(node.object) === receiverText;
-    const matchLengthMinus = (node, receiverText) => {
-      if (node.type !== AST_NODE_TYPES.BinaryExpression || node.operator !== "-" || !isReceiverLengthAccess(node.left, receiverText)) {
-        return void 0;
-      }
-      const m = asNonNegativeIntegerLiteral(node.right);
-      return m !== void 0 && m >= 1 ? m : void 0;
-    };
-    const classifyFilterCallback = (callback, receiver, receiverText) => {
-      if (callback.type !== AST_NODE_TYPES.ArrowFunctionExpression || callback.async || callback.body.type === AST_NODE_TYPES.BlockStatement || callback.params.length !== 2) {
-        return void 0;
-      }
-      const [elementParam, indexParam] = callback.params;
-      if (elementParam === void 0 || indexParam === void 0 || elementParam.type !== AST_NODE_TYPES.Identifier || indexParam.type !== AST_NODE_TYPES.Identifier) {
-        return void 0;
-      }
-      const receiverRoot = rootIdentifierName(receiver);
-      if (receiverRoot !== void 0 && (elementParam.name === receiverRoot || indexParam.name === receiverRoot)) {
-        return void 0;
-      }
-      const body = callback.body;
-      if (body.type !== AST_NODE_TYPES.BinaryExpression || !COMPARISON_OPERATORS.has(body.operator)) {
-        return void 0;
-      }
-      const rawOperator = body.operator;
-      const isIndex = (side) => side.type === AST_NODE_TYPES.Identifier && side.name === indexParam.name;
-      const [op, other] = isIndex(body.left) ? [rawOperator, body.right] : isIndex(body.right) ? [FLIPPED_OPERATORS[rawOperator], body.left] : [void 0, void 0];
-      if (op === void 0 || isIndex(other)) {
-        return void 0;
-      }
-      const n = asNonNegativeIntegerLiteral(other);
-      if (n !== void 0) {
-        return classifyLiteralComparison(op, n);
-      }
-      if (!isSimpleReference(receiver)) return void 0;
-      const m = matchLengthMinus(other, receiverText);
-      return m === void 0 ? void 0 : classifyLengthComparison(op, m);
-    };
-    const classifySliceArgs = (args, receiver) => {
-      if (args.length === 1) {
-        const [start] = args;
-        if (start === void 0) return void 0;
-        const n = asNonNegativeIntegerLiteral(start);
-        if (n !== void 0) return normalizeCountedOp("skip", n);
-        const negated = asNegatedPositiveIntegerLiteral(start);
-        return negated === void 0 ? void 0 : normalizeCountedOp("takeLast", negated);
-      }
-      if (args.length === 2) {
-        const [start, end] = args;
-        if (start === void 0 || end === void 0 || asNonNegativeIntegerLiteral(start) !== 0) {
-          return void 0;
-        }
-        const n = asNonNegativeIntegerLiteral(end);
-        if (n !== void 0) return normalizeCountedOp("take", n);
-        const negated = asNegatedPositiveIntegerLiteral(end);
-        if (negated !== void 0) {
-          return normalizeCountedOp("skipLast", negated);
-        }
-        if (!isSimpleReference(receiver)) return void 0;
-        const m = matchLengthMinus(end, sourceCode.getText(receiver));
-        return m === void 0 ? void 0 : normalizeCountedOp("skipLast", m);
-      }
-      return void 0;
-    };
-    const classifyToSplicedArgs = (args, receiver, receiverText) => {
-      if (args.length === 1) {
-        const [start] = args;
-        if (start === void 0) return void 0;
-        const n = asNonNegativeIntegerLiteral(start);
-        if (n !== void 0) return normalizeCountedOp("take", n);
-        const negated = asNegatedPositiveIntegerLiteral(start);
-        return negated === void 0 ? void 0 : normalizeCountedOp("skipLast", negated);
-      }
-      if (args.length === 2) {
-        const [start, deleteCount] = args;
-        if (start === void 0 || deleteCount === void 0 || asNonNegativeIntegerLiteral(start) !== 0) {
-          return void 0;
-        }
-        const n = asNonNegativeIntegerLiteral(deleteCount);
-        if (n !== void 0) return normalizeCountedOp("skip", n);
-        if (!isSimpleReference(receiver)) return void 0;
-        const m = matchLengthMinus(deleteCount, receiverText);
-        return m === void 0 ? void 0 : normalizeCountedOp("takeLast", m);
-      }
-      if (args.length === 3) {
-        const [start, deleteCount, item] = args;
-        if (start === void 0 || deleteCount === void 0 || item === void 0 || item.type === AST_NODE_TYPES.SpreadElement || asNonNegativeIntegerLiteral(deleteCount) !== 0) {
-          return void 0;
-        }
-        if (asNonNegativeIntegerLiteral(start) === 0) {
-          return { fn: "toUnshifted", itemText: toArgText(item) };
-        }
-        if (isSimpleReference(receiver) && isReceiverLengthAccess(start, receiverText)) {
-          return { fn: "toPushed", itemText: toArgText(item) };
-        }
-        return void 0;
-      }
-      return void 0;
-    };
-    return {
-      CallExpression: (node) => {
-        const callee = node.callee;
-        if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES.Identifier) {
-          return;
-        }
-        const methodName = callee.property.name;
-        const receiver = callee.object;
-        if (methodName === "skip" || methodName === "skipLast") {
-          const isArrObject = receiver.type === AST_NODE_TYPES.Identifier && receiver.name === arrLocalName || receiver.type === AST_NODE_TYPES.MemberExpression && !receiver.computed && receiver.object.type === AST_NODE_TYPES.Identifier && receiver.object.name === namespaceLocalName && receiver.property.type === AST_NODE_TYPES.Identifier && receiver.property.name === "Arr";
-          const [arrayArg, countArg] = node.arguments;
-          if (isArrObject && arrayArg !== void 0 && countArg !== void 0 && node.arguments.length === 2 && arrayArg.type !== AST_NODE_TYPES.SpreadElement && asNonNegativeIntegerLiteral(countArg) === 1) {
-            report(
-              node,
-              { fn: methodName === "skip" ? "tail" : "butLast" },
-              toArgText(arrayArg)
-            );
-          }
-          return;
-        }
-        if (methodName === "concat" && receiver.type === AST_NODE_TYPES.ArrayExpression) {
-          const [element] = receiver.elements;
-          const [arg] = node.arguments;
-          if (element !== null && element !== void 0 && arg !== void 0 && receiver.elements.length === 1 && element.type !== AST_NODE_TYPES.SpreadElement && node.arguments.length === 1 && arg.type !== AST_NODE_TYPES.SpreadElement && isArrayOrTupleType(getTypeOf(arg))) {
-            report(
-              node,
-              { fn: "toUnshifted", itemText: toArgText(element) },
-              toArgText(arg)
-            );
-          }
-          return;
-        }
-        if (methodName !== "slice" && methodName !== "toSpliced" && methodName !== "filter" && methodName !== "concat") {
-          return;
-        }
-        if (!isArrayOrTupleType(getTypeOf(receiver))) return;
-        const receiverText = sourceCode.getText(receiver);
-        switch (methodName) {
-          case "slice": {
-            const op = classifySliceArgs(node.arguments, receiver);
-            if (op !== void 0) report(node, op, toArgText(receiver));
-            return;
-          }
-          case "toSpliced": {
-            const op = classifyToSplicedArgs(
-              node.arguments,
-              receiver,
-              receiverText
-            );
-            if (op !== void 0) report(node, op, toArgText(receiver));
-            return;
-          }
-          case "filter": {
-            const [callback] = node.arguments;
-            if (callback === void 0 || node.arguments.length !== 1) {
-              return;
+    create: (context) => {
+        const sourceCode = context.sourceCode;
+        const program = sourceCode.ast;
+        const tsDataForgeImport = getTsDataForgeImport(program);
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+
+
+
+
+
+        const arrLocalName = getImportedLocalName(tsDataForgeImport, 'Arr');
+        const namespaceLocalName = tsDataForgeImport?.specifiers.find((specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier)?.local.name;
+        const arrRef = arrLocalName ??
+            (namespaceLocalName === undefined ? 'Arr' : `${namespaceLocalName}.Arr`);
+        const needsArrImport = arrLocalName === undefined && namespaceLocalName === undefined;
+
+
+
+
+        const isArrayOrTupleType = (type) => {
+            if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+                return false;
             }
-            const op = classifyFilterCallback(callback, receiver, receiverText);
-            if (op !== void 0) report(node, op, toArgText(receiver));
-            return;
-          }
-          case "concat": {
-            const [arg] = node.arguments;
-            if (arg === void 0 || node.arguments.length !== 1 || arg.type === AST_NODE_TYPES.SpreadElement) {
-              return;
+            if (type.isUnion()) {
+                return type.types.every(isArrayOrTupleType);
             }
-            if (arg.type === AST_NODE_TYPES.ArrayExpression) {
-              const [element] = arg.elements;
-              if (element !== null && element !== void 0 && arg.elements.length === 1 && element.type !== AST_NODE_TYPES.SpreadElement) {
-                report(
-                  node,
-                  { fn: "toPushed", itemText: toArgText(element) },
-                  toArgText(receiver)
-                );
-              }
-              return;
+            if ((type.flags &
+                (ts.TypeFlags.TypeParameter |
+                    ts.TypeFlags.IndexedAccess |
+                    ts.TypeFlags.Conditional |
+                    ts.TypeFlags.Substitution)) !==
+                0) {
+                const constraint = checker.getBaseConstraintOfType(type);
+                return constraint !== undefined && isArrayOrTupleType(constraint);
             }
-            if (isDefinitelyNotArrayType(getTypeOf(arg))) {
-              report(
+            return checker.isArrayType(type) || checker.isTupleType(type);
+        };
+        const getTypeOf = (node) => checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(node));
+
+
+
+
+
+        const isDefinitelyNotArrayType = (type) => {
+            if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+                return false;
+            }
+            if (type.isUnion()) {
+                return type.types.every(isDefinitelyNotArrayType);
+            }
+            if ((type.flags &
+                (ts.TypeFlags.TypeParameter |
+                    ts.TypeFlags.IndexedAccess |
+                    ts.TypeFlags.Conditional |
+                    ts.TypeFlags.Substitution)) !==
+                0) {
+                const constraint = checker.getBaseConstraintOfType(type);
+                return constraint !== undefined && isDefinitelyNotArrayType(constraint);
+            }
+            return !checker.isArrayType(type) && !checker.isTupleType(type);
+        };
+
+        const toArgText = (node) => {
+            const text = sourceCode.getText(node);
+            return node.type === AST_NODE_TYPES.SequenceExpression
+                ? `(${text})`
+                : text;
+        };
+        const toReplacementText = (op, xsText) => {
+            switch (op.fn) {
+                case 'tail':
+                case 'butLast':
+                    return `${arrRef}.${op.fn}(${xsText})`;
+                case 'skip':
+                case 'take':
+                case 'skipLast':
+                case 'takeLast':
+                    return `${arrRef}.${op.fn}(${xsText}, ${op.count})`;
+
+
+
+                case 'toUnshifted':
+                    return `${arrRef}.toUnshifted(${op.itemText})(${xsText})`;
+                case 'toPushed':
+                    return `${arrRef}.toPushed(${xsText}, ${op.itemText})`;
+            }
+        };
+        const mut_nodesToFix = [];
+        const report = (node, op, xsText) => {
+            mut_nodesToFix.push({
                 node,
-                { fn: "toPushed", itemText: toArgText(arg) },
-                toArgText(receiver)
-              );
+                replacement: toReplacementText(op, xsText),
+            });
+        };
+
+        const isReceiverLengthAccess = (node, receiverText) => node.type === AST_NODE_TYPES.MemberExpression &&
+            !node.computed &&
+            node.property.type === AST_NODE_TYPES.Identifier &&
+            node.property.name === 'length' &&
+            sourceCode.getText(node.object) === receiverText;
+
+        const matchLengthMinus = (node, receiverText) => {
+            if (node.type !== AST_NODE_TYPES.BinaryExpression ||
+                node.operator !== '-' ||
+                !isReceiverLengthAccess(node.left, receiverText)) {
+                return undefined;
             }
-          }
-        }
-      },
-      ArrayExpression: (node) => {
-        if (node.elements.length !== 2) return;
-        const [first, second] = node.elements;
-        if (first === null || first === void 0 || second === null || second === void 0) {
-          return;
-        }
-        const [spread, item, fn] = first.type === AST_NODE_TYPES.SpreadElement && second.type !== AST_NODE_TYPES.SpreadElement ? [first, second, "toPushed"] : first.type !== AST_NODE_TYPES.SpreadElement && second.type === AST_NODE_TYPES.SpreadElement ? [second, first, "toUnshifted"] : [void 0, void 0, void 0];
-        if (spread === void 0) return;
-        if (!isArrayOrTupleType(getTypeOf(spread.argument))) return;
-        report(
-          node,
-          { fn, itemText: toArgText(item) },
-          toArgText(spread.argument)
-        );
-      },
-      "Program:exit": () => {
-        for (const [index, nodeInfo] of mut_nodesToFix.entries()) {
-          context.report({
-            node: nodeInfo.node,
-            messageId: "preferCanonicalArraySlicing",
-            data: { replacement: nodeInfo.replacement },
-            fix: (fixer) => {
-              const importFixes = index === 0 && needsArrImport ? buildImportFixes(fixer, program, tsDataForgeImport, ["Arr"]) : [];
-              return [
-                ...importFixes,
-                fixer.replaceText(nodeInfo.node, nodeInfo.replacement)
-              ];
+            const m = asNonNegativeIntegerLiteral(node.right);
+            return m !== undefined && m >= 1 ? m : undefined;
+        };
+
+
+
+
+
+        const classifyFilterCallback = (callback, receiver, receiverText) => {
+            if (callback.type !== AST_NODE_TYPES.ArrowFunctionExpression ||
+                callback.async ||
+                callback.body.type === AST_NODE_TYPES.BlockStatement ||
+                callback.params.length !== 2) {
+                return undefined;
+            }
+            const [elementParam, indexParam] = callback.params;
+            if (elementParam === undefined ||
+                indexParam === undefined ||
+                elementParam.type !== AST_NODE_TYPES.Identifier ||
+                indexParam.type !== AST_NODE_TYPES.Identifier) {
+                return undefined;
             }
-          });
-        }
-      }
-    };
-  },
-  defaultOptions: []
-};
 
-export { preferCanonicalArraySlicing };
-//# sourceMappingURL=prefer-canonical-array-slicing.mjs.map
+
+
+            const receiverRoot = rootIdentifierName(receiver);
+            if (receiverRoot !== undefined &&
+                (elementParam.name === receiverRoot || indexParam.name === receiverRoot)) {
+                return undefined;
+            }
+            const body = callback.body;
+            if (body.type !== AST_NODE_TYPES.BinaryExpression ||
+                !COMPARISON_OPERATORS.has(body.operator)) {
+                return undefined;
+            }
+
+            const rawOperator = body.operator;
+            const isIndex = (side) => side.type === AST_NODE_TYPES.Identifier &&
+                side.name === indexParam.name;
+            const [op, other] = isIndex(body.left)
+                ? [rawOperator, body.right]
+                : isIndex(body.right)
+                    ? [FLIPPED_OPERATORS[rawOperator], body.left]
+                    : [undefined, undefined];
+
+
+            if (op === undefined || isIndex(other)) {
+                return undefined;
+            }
+
+
+
+
+            const n = asNonNegativeIntegerLiteral(other);
+            if (n !== undefined) {
+                return classifyLiteralComparison(op, n);
+            }
+            if (!isSimpleReference(receiver))
+                return undefined;
+            const m = matchLengthMinus(other, receiverText);
+            return m === undefined ? undefined : classifyLengthComparison(op, m);
+        };
+        const classifySliceArgs = (args, receiver) => {
+            if (args.length === 1) {
+                const [start] = args;
+                if (start === undefined)
+                    return undefined;
+                const n = asNonNegativeIntegerLiteral(start);
+                if (n !== undefined)
+                    return normalizeCountedOp('skip', n);
+                const negated = asNegatedPositiveIntegerLiteral(start);
+                return negated === undefined
+                    ? undefined
+                    : normalizeCountedOp('takeLast', negated);
+            }
+            if (args.length === 2) {
+                const [start, end] = args;
+                if (start === undefined ||
+                    end === undefined ||
+                    asNonNegativeIntegerLiteral(start) !== 0) {
+                    return undefined;
+                }
+                const n = asNonNegativeIntegerLiteral(end);
+                if (n !== undefined)
+                    return normalizeCountedOp('take', n);
+                const negated = asNegatedPositiveIntegerLiteral(end);
+                if (negated !== undefined) {
+                    return normalizeCountedOp('skipLast', negated);
+                }
+                if (!isSimpleReference(receiver))
+                    return undefined;
+                const m = matchLengthMinus(end, sourceCode.getText(receiver));
+                return m === undefined ? undefined : normalizeCountedOp('skipLast', m);
+            }
+            return undefined;
+        };
+        const classifyToSplicedArgs = (args, receiver, receiverText) => {
+            if (args.length === 1) {
+                const [start] = args;
+                if (start === undefined)
+                    return undefined;
+                const n = asNonNegativeIntegerLiteral(start);
+
+                if (n !== undefined)
+                    return normalizeCountedOp('take', n);
+                const negated = asNegatedPositiveIntegerLiteral(start);
+
+                return negated === undefined
+                    ? undefined
+                    : normalizeCountedOp('skipLast', negated);
+            }
+            if (args.length === 2) {
+                const [start, deleteCount] = args;
+                if (start === undefined ||
+                    deleteCount === undefined ||
+                    asNonNegativeIntegerLiteral(start) !== 0) {
+                    return undefined;
+                }
+
+                const n = asNonNegativeIntegerLiteral(deleteCount);
+                if (n !== undefined)
+                    return normalizeCountedOp('skip', n);
+
+
+
+                if (!isSimpleReference(receiver))
+                    return undefined;
+                const m = matchLengthMinus(deleteCount, receiverText);
+                return m === undefined ? undefined : normalizeCountedOp('takeLast', m);
+            }
+            if (args.length === 3) {
+                const [start, deleteCount, item] = args;
+                if (start === undefined ||
+                    deleteCount === undefined ||
+                    item === undefined ||
+                    item.type === AST_NODE_TYPES.SpreadElement ||
+                    asNonNegativeIntegerLiteral(deleteCount) !== 0) {
+                    return undefined;
+                }
+
+                if (asNonNegativeIntegerLiteral(start) === 0) {
+                    return { fn: 'toUnshifted', itemText: toArgText(item) };
+                }
+
+                if (isSimpleReference(receiver) &&
+                    isReceiverLengthAccess(start, receiverText)) {
+                    return { fn: 'toPushed', itemText: toArgText(item) };
+                }
+                return undefined;
+            }
+            return undefined;
+        };
+        return {
+            CallExpression: (node) => {
+                const callee = node.callee;
+                if (callee.type !== AST_NODE_TYPES.MemberExpression ||
+                    callee.computed ||
+                    callee.property.type !== AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const methodName = callee.property.name;
+                const receiver = callee.object;
+
+
+                if (methodName === 'skip' || methodName === 'skipLast') {
+                    const isArrObject = (receiver.type === AST_NODE_TYPES.Identifier &&
+                        receiver.name === arrLocalName) ||
+                        (receiver.type === AST_NODE_TYPES.MemberExpression &&
+                            !receiver.computed &&
+                            receiver.object.type === AST_NODE_TYPES.Identifier &&
+                            receiver.object.name === namespaceLocalName &&
+                            receiver.property.type === AST_NODE_TYPES.Identifier &&
+                            receiver.property.name === 'Arr');
+                    const [arrayArg, countArg] = node.arguments;
+                    if (isArrObject &&
+                        arrayArg !== undefined &&
+                        countArg !== undefined &&
+                        node.arguments.length === 2 &&
+                        arrayArg.type !== AST_NODE_TYPES.SpreadElement &&
+                        asNonNegativeIntegerLiteral(countArg) === 1) {
+                        report(node, { fn: methodName === 'skip' ? 'tail' : 'butLast' }, toArgText(arrayArg));
+                    }
+                    return;
+                }
+
+                if (methodName === 'concat' &&
+                    receiver.type === AST_NODE_TYPES.ArrayExpression) {
+                    const [element] = receiver.elements;
+                    const [arg] = node.arguments;
+                    if (element !== null &&
+                        element !== undefined &&
+                        arg !== undefined &&
+                        receiver.elements.length === 1 &&
+                        element.type !== AST_NODE_TYPES.SpreadElement &&
+                        node.arguments.length === 1 &&
+                        arg.type !== AST_NODE_TYPES.SpreadElement &&
+                        isArrayOrTupleType(getTypeOf(arg))) {
+                        report(node, { fn: 'toUnshifted', itemText: toArgText(element) }, toArgText(arg));
+                    }
+                    return;
+                }
+                if (methodName !== 'slice' &&
+                    methodName !== 'toSpliced' &&
+                    methodName !== 'filter' &&
+                    methodName !== 'concat') {
+                    return;
+                }
+
+
+                if (!isArrayOrTupleType(getTypeOf(receiver)))
+                    return;
+                const receiverText = sourceCode.getText(receiver);
+                switch (methodName) {
+                    case 'slice': {
+                        const op = classifySliceArgs(node.arguments, receiver);
+                        if (op !== undefined)
+                            report(node, op, toArgText(receiver));
+                        return;
+                    }
+                    case 'toSpliced': {
+                        const op = classifyToSplicedArgs(node.arguments, receiver, receiverText);
+                        if (op !== undefined)
+                            report(node, op, toArgText(receiver));
+                        return;
+                    }
+                    case 'filter': {
+                        const [callback] = node.arguments;
+                        if (callback === undefined || node.arguments.length !== 1) {
+                            return;
+                        }
+                        const op = classifyFilterCallback(callback, receiver, receiverText);
+                        if (op !== undefined)
+                            report(node, op, toArgText(receiver));
+                        return;
+                    }
+                    case 'concat': {
+                        const [arg] = node.arguments;
+                        if (arg === undefined ||
+                            node.arguments.length !== 1 ||
+                            arg.type === AST_NODE_TYPES.SpreadElement) {
+                            return;
+                        }
+
+                        if (arg.type === AST_NODE_TYPES.ArrayExpression) {
+                            const [element] = arg.elements;
+                            if (element !== null &&
+                                element !== undefined &&
+                                arg.elements.length === 1 &&
+                                element.type !== AST_NODE_TYPES.SpreadElement) {
+                                report(node, { fn: 'toPushed', itemText: toArgText(element) }, toArgText(receiver));
+                            }
+                            return;
+                        }
+
+
+                        if (isDefinitelyNotArrayType(getTypeOf(arg))) {
+                            report(node, { fn: 'toPushed', itemText: toArgText(arg) }, toArgText(receiver));
+                        }
+                    }
+                }
+            },
+            ArrayExpression: (node) => {
+
+
+                if (node.elements.length !== 2)
+                    return;
+                const [first, second] = node.elements;
+                if (first === null ||
+                    first === undefined ||
+                    second === null ||
+                    second === undefined) {
+                    return;
+                }
+                const [spread, item, fn] = first.type === AST_NODE_TYPES.SpreadElement &&
+                    second.type !== AST_NODE_TYPES.SpreadElement
+                    ? [first, second, 'toPushed']
+                    : first.type !== AST_NODE_TYPES.SpreadElement &&
+                        second.type === AST_NODE_TYPES.SpreadElement
+                        ? [second, first, 'toUnshifted']
+                        : [undefined, undefined, undefined];
+
+
+
+                if (spread === undefined)
+                    return;
+
+
+                if (!isArrayOrTupleType(getTypeOf(spread.argument)))
+                    return;
+                report(node, { fn, itemText: toArgText(item) }, toArgText(spread.argument));
+            },
+            'Program:exit': () => {
+                for (const [index, nodeInfo] of mut_nodesToFix.entries()) {
+                    context.report({
+                        node: nodeInfo.node,
+                        messageId: 'preferCanonicalArraySlicing',
+                        data: { replacement: nodeInfo.replacement },
+                        fix: (fixer) => {
+                            const importFixes = index === 0 && needsArrImport
+                                ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                                : [];
+                            return [
+                                ...importFixes,
+                                fixer.replaceText(nodeInfo.node, nodeInfo.replacement),
+                            ];
+                        },
+                    });
+                }
+            },
+        };
+    },
+    defaultOptions: [],
+};
+//# sourceMappingURL=prefer-canonical-array-slicing.mjs.map