prefer-array-at.ts

import type {TSESLint, TSESTree} from '@typescript-eslint/utils';
import {isArrayType, isStringType} from '../utils/typescript.js';
import {needsParensForPropertyAccess} from '../utils/ast.js';

type MessageIds = 'preferAt';

function isWriteTarget(node: TSESTree.Node): boolean {
  let target = node;

  while (
    target.parent?.type === 'TSAsExpression' ||
    target.parent?.type === 'TSNonNullExpression' ||
    target.parent?.type === 'TSTypeAssertion'
  ) {
    target = target.parent;
  }

  const parent = target.parent;

  return (
    (parent?.type === 'AssignmentExpression' && parent.left === target) ||
    (parent?.type === 'UpdateExpression' && parent.argument === target) ||
    (parent?.type === 'ForInStatement' && parent.left === target) ||
    (parent?.type === 'ForOfStatement' && parent.left === target) ||
    (parent?.type === 'AssignmentPattern' && parent.left === target) ||
    (parent?.type === 'RestElement' && parent.argument === target) ||
    (parent?.type === 'UnaryExpression' &&
      parent.operator === 'delete' &&
      parent.argument === target)
  );
}

export const preferArrayAt: TSESLint.RuleModule<MessageIds, []> = {
  meta: {
    type: 'suggestion',
    docs: {
      description: 'Prefer Array.prototype.at() over length-based indexing'
    },
    fixable: 'code',
    schema: [],
    messages: {
      preferAt: 'Use .at(-1) instead of [{{array}}.length - 1]'
    }
  },
  defaultOptions: [],
  create(context) {
    const sourceCode = context.sourceCode;

    return {
      MemberExpression(node: TSESTree.MemberExpression) {
        if (!node.computed || !node.property) {
          return;
        }

        if (node.property.type !== 'BinaryExpression') {
          return;
        }

        const propertyExpr = node.property;

        if (propertyExpr.operator !== '-') {
          return;
        }

        if (
          propertyExpr.right.type !== 'Literal' ||
          propertyExpr.right.value !== 1
        ) {
          return;
        }

        if (propertyExpr.left.type !== 'MemberExpression') {
          return;
        }

        const leftMember = propertyExpr.left;

        if (
          leftMember.property.type !== 'Identifier' ||
          leftMember.property.name !== 'length'
        ) {
          return;
        }

        const arrayText = sourceCode.getText(node.object);
        const lengthArrayText = sourceCode.getText(leftMember.object);

        if (arrayText !== lengthArrayText) {
          return;
        }

        if (isWriteTarget(node)) {
          return;
        }

        // Check if the object supports .at() (array or string, when types are available)
        if (
          isArrayType(node.object, context) === false &&
          isStringType(node.object, context) === false
        ) {
          return;
        }

        context.report({
          node,
          messageId: 'preferAt',
          data: {
            array: arrayText
          },
          fix(fixer) {
            const objectText = needsParensForPropertyAccess(node.object)
              ? `(${arrayText})`
              : arrayText;
            return fixer.replaceText(node, `${objectText}.at(-1)`);
          }
        });
      }
    };
  }
};