fix: updates ast (#402)

* fix: updates ast

* fix: updates ast helper

* chore: improves regex for array prototype updates

Author: yowainwright

lib/constants/es-features/13.js

@@ -48,6 +48,7 @@ const ES13_FEATURES = {
       property: "at",
       excludeCallerTypes: ["ObjectExpression"],
       requireNumericArg: true,
+      requireArrayLikeCall: true,
     },
   },
   ObjectHasOwn: {

lib/helpers/ast.js

@@ -32,6 +32,117 @@ function hasNumericArgument(node) {
   return isNumericLiteral || isNegativeNumeric;
 }
 
+const ARRAY_LIKE_NAMES = new Set([
+  "arr",
+  "array",
+  "list",
+  "items",
+  "values",
+  "arguments",
+]);
+
+const ARRAY_CONSTRUCTOR_FUNCTIONS = new Set([
+  "Array",
+  "from",
+  "of",
+  "slice",
+  "filter",
+  "map",
+  "concat",
+]);
+
+const ARRAY_METHODS = new Set([
+  "slice",
+  "filter",
+  "map",
+  "concat",
+  "from",
+  "of",
+]);
+
+const COMMON_NON_ARRAY_NAMES = new Set([
+  "obj",
+  "object",
+  "foo",
+  "bar",
+  "baz",
+  "data",
+  "config",
+  "options",
+  "params",
+  "props",
+  "state",
+  "item",
+  "element",
+  "node",
+  "target",
+  "source",
+  "result",
+  "response",
+  "request",
+  "payload",
+  "model",
+  "view",
+  "controller",
+  "service",
+  "utils",
+  "helpers",
+  "custom",
+]);
+function isArrayExpression(calleeObject) {
+  return calleeObject.type === "ArrayExpression";
+}
+
+function isArrayLikeIdentifier(calleeObject) {
+  const isIdentifier = calleeObject.type === "Identifier";
+  if (!isIdentifier) return false;
+
+  const objectName = calleeObject.name.toLowerCase();
+
+  const isCommonNonArrayName = COMMON_NON_ARRAY_NAMES.has(objectName);
+  if (isCommonNonArrayName) return false;
+
+  return ARRAY_LIKE_NAMES.has(objectName);
+}
+
+function isArrayConstructorCall(calleeObject) {
+  const isCallExpression = calleeObject.type === "CallExpression";
+  if (!isCallExpression) return false;
+
+  const innerCallee = calleeObject.callee;
+  const isIdentifierCallee = innerCallee?.type === "Identifier";
+  const isMemberExpressionCallee = innerCallee?.type === "MemberExpression";
+
+  if (isIdentifierCallee) {
+    const functionName = innerCallee.name;
+    return ARRAY_CONSTRUCTOR_FUNCTIONS.has(functionName);
+  }
+
+  if (isMemberExpressionCallee) {
+    const innerProperty = innerCallee.property;
+    const hasPropertyName = innerProperty?.name;
+    const isArrayMethod = hasPropertyName && ARRAY_METHODS.has(innerProperty.name);
+    return isArrayMethod;
+  }
+
+  return false;
+}
+
+function isArrayLikeCall(node) {
+  const callee = node.callee;
+  const calleeObject = callee?.object;
+  const hasCalleeObject = calleeObject != null;
+
+  if (!hasCalleeObject) return false;
+
+  const isArrayExpr = isArrayExpression(calleeObject);
+  const isArrayIdent = isArrayLikeIdentifier(calleeObject);
+  const isArrayConstr = isArrayConstructorCall(calleeObject);
+  const isArray = isArrayExpr || isArrayIdent || isArrayConstr;
+
+  return isArray;
+}
+
 function checkMap(node, astInfo) {
   const callee = node.callee;
   const calleeObject = callee?.object;
@@ -82,6 +193,9 @@ function checkMap(node, astInfo) {
   const hasNumericArgMismatch =
     astInfo.requireNumericArg && !hasNumericArgument(node);
 
+  const hasArrayLikeCallMismatch =
+    astInfo.requireArrayLikeCall && !isArrayLikeCall(node);
+
   const hasMismatch =
     hasKindMismatch ||
     hasOperatorMismatch ||
@@ -93,7 +207,8 @@ function checkMap(node, astInfo) {
     hasObjectAndPropertyMismatch ||
     hasOptionsCauseMismatch ||
     hasExcludedCallerType ||
-    hasNumericArgMismatch;
+    hasNumericArgMismatch ||
+    hasArrayLikeCallMismatch;
 
   if (hasMismatch) return false;
 

tests/unit/helpers/ast.test.js

@@ -162,5 +162,77 @@ describe("helpers/ast.js", () => {
       const result = checkMap(node, astInfo);
       assert.strictEqual(result, true);
     });
+
+    it("should require array-like call for ArrayPrototypeAt", () => {
+      const node = {
+        callee: {
+          object: { type: "ArrayExpression" },
+          property: { name: "at" },
+        },
+        arguments: [{ type: "Literal", value: -1 }],
+      };
+      const astInfo = {
+        property: "at",
+        requireNumericArg: true,
+        requireArrayLikeCall: true,
+      };
+
+      const result = checkMap(node, astInfo);
+      assert.strictEqual(result, true);
+    });
+
+    it("should reject custom object at() calls", () => {
+      const node = {
+        callee: {
+          object: { type: "Identifier", name: "foo" },
+          property: { name: "at" },
+        },
+        arguments: [{ type: "Literal", value: -1 }],
+      };
+      const astInfo = {
+        property: "at",
+        requireNumericArg: true,
+        requireArrayLikeCall: true,
+      };
+
+      const result = checkMap(node, astInfo);
+      assert.strictEqual(result, false);
+    });
+
+    it("should accept array-like variable names", () => {
+      const node = {
+        callee: {
+          object: { type: "Identifier", name: "arr" },
+          property: { name: "at" },
+        },
+        arguments: [{ type: "Literal", value: -1 }],
+      };
+      const astInfo = {
+        property: "at",
+        requireNumericArg: true,
+        requireArrayLikeCall: true,
+      };
+
+      const result = checkMap(node, astInfo);
+      assert.strictEqual(result, true);
+    });
+
+    it("should accept arguments object", () => {
+      const node = {
+        callee: {
+          object: { type: "Identifier", name: "arguments" },
+          property: { name: "at" },
+        },
+        arguments: [{ type: "Literal", value: 0 }],
+      };
+      const astInfo = {
+        property: "at",
+        requireNumericArg: true,
+        requireArrayLikeCall: true,
+      };
+
+      const result = checkMap(node, astInfo);
+      assert.strictEqual(result, true);
+    });
   });
 });

tests/unit/helpers/astDetector.test.js

@@ -418,6 +418,12 @@ describe("helpers/astDetector.js", () => {
       assert.strictEqual(result.ArrayPrototypeAt, true);
     });
 
+    it("should not detect ArrayPrototypeAt for custom object .at() with numeric arg (#387)", () => {
+      const ast = parse("const foo = { at() {} }; foo.at(-1);");
+      const result = detectFeaturesFromAST(ast);
+      assert.strictEqual(result.ArrayPrototypeAt, false);
+    });
+
     it("should not detect OptionalCatchBinding for catch with param (ES5-valid)", () => {
       const ast = parse("try { fn(); } catch (error) { fallback(); }");
       const result = detectFeaturesFromAST(ast);