fix(linter): handle various flat config override structures (#33548)

Flat config overrides util may fail when it isn't a plain JS object.
This PR makes the `hasOverrides` function more robust against these
cases.

Fixes #31796

(cherry picked from commit 05bd3a4)

Author: jaysoo

packages/eslint/src/generators/utils/flat-config/ast-utils.spec.ts

@@ -1,11 +1,12 @@
-import ts = require('typescript');
+import * as ts from 'typescript';
 import {
   addBlockToFlatConfigExport,
   addFlatCompatToFlatConfig,
   addImportToFlatConfig,
   generateAst,
   generateFlatOverride,
   generatePluginExtendsElementWithCompatFixup,
+  hasOverride,
   removeCompatExtends,
   removeImportFromFlatConfig,
   removeOverridesFromLintConfig,
@@ -1175,6 +1176,160 @@ export default [
     });
   });
 
+  describe('hasOverride', () => {
+    it('should handle variable references in property values', () => {
+      const content = `
+import pluginPackageJson from "eslint-plugin-package-json";
+import jsoncParser from "jsonc-eslint-parser";
+
+export default [
+    {
+        files: ["package.json"],
+        plugins: { "package-json": pluginPackageJson },
+        languageOptions: {
+            parser: jsoncParser,
+        },
+    }
+];`;
+
+      const result = hasOverride(
+        content,
+        (o) => Array.isArray(o.files) && o.files.includes('package.json')
+      );
+      expect(result).toBe(true);
+    });
+
+    it('should handle spread elements', () => {
+      const content = `
+export default [
+    {
+        files: ['*.json'],
+        ...(jest.configs['flat/recommended'])
+        ...getConfig()
+        ...configs['recommended']
+    }
+];`;
+
+      const result = hasOverride(
+        content,
+        (o) => Array.isArray(o.files) && o.files.includes('*.json')
+      );
+      expect(result).toBe(true);
+    });
+
+    it('should extract rules property correctly', () => {
+      const content = `
+export default [
+    {
+        files: ['*.ts'],
+        rules: {
+          '@nx/enforce-module-boundaries': 'error'
+        }
+    }
+];`;
+
+      const result = hasOverride(
+        content,
+        (o) => !!o.rules?.['@nx/enforce-module-boundaries']
+      );
+      expect(result).toBe(true);
+    });
+
+    it('should return false when no matching override is found', () => {
+      const content = `
+export default [
+    {
+        files: ['*.ts'],
+        rules: {}
+    }
+];`;
+
+      const result = hasOverride(
+        content,
+        (o) => Array.isArray(o.files) && o.files.includes('*.js')
+      );
+      expect(result).toBe(false);
+    });
+
+    it('should handle simple spread elements', () => {
+      const content = `
+export default [
+    {
+        files: ['*.ts'],
+        ...baseConfig
+    }
+];`;
+
+      const result = hasOverride(
+        content,
+        (o) => Array.isArray(o.files) && o.files.includes('*.ts')
+      );
+      expect(result).toBe(true);
+    });
+
+    it('should handle nested object literals', () => {
+      const content = `
+export default [
+    {
+        files: ['*.ts'],
+        languageOptions: {
+            parserOptions: {
+                project: './tsconfig.json'
+            }
+        }
+    }
+];`;
+
+      const result = hasOverride(
+        content,
+        (o) =>
+          (o as any).languageOptions?.parserOptions?.project ===
+          './tsconfig.json'
+      );
+      expect(result).toBe(true);
+    });
+
+    it('should handle CJS format', () => {
+      const content = `
+const jest = require("eslint-plugin-jest");
+
+module.exports = [
+    {
+        files: ['**/*.spec.ts'],
+        ...(jest.configs['flat/recommended'])
+    }
+];`;
+
+      const result = hasOverride(
+        content,
+        (o) => Array.isArray(o.files) && o.files.includes('**/*.spec.ts')
+      );
+      expect(result).toBe(true);
+    });
+
+    it('should handle compat.config(...).map(...) pattern', () => {
+      const content = `
+export default [
+    ...compat.config({ extends: ["plugin:@nx/typescript"] }).map(config => ({
+        ...config,
+        files: [
+            "my-lib/**/*.ts",
+            "my-lib/**/*.tsx"
+        ],
+        rules: {
+            'my-ts-rule': 'error'
+        }
+    })),
+];`;
+
+      const result = hasOverride(
+        content,
+        (o) => Array.isArray(o.files) && o.files.includes('my-lib/**/*.ts')
+      );
+      expect(result).toBe(true);
+    });
+  });
+
   describe('generatePluginExtendsElementWithCompatFixup', () => {
     it('should return spread element with fixupConfigRules call wrapping the extended plugin', () => {
       const result = generatePluginExtendsElementWithCompatFixup('my-plugin');

packages/eslint/src/generators/utils/flat-config/ast-utils.ts

@@ -187,19 +187,21 @@ export function hasOverride(
   }
   for (const node of exportsArray) {
     if (isOverride(node)) {
-      let objSource;
+      let data: Partial<Linter.ConfigOverride<Linter.RulesRecord>>;
+
       if (ts.isObjectLiteralExpression(node)) {
-        objSource = node.getFullText();
-        // strip any spread elements
-        objSource = objSource.replace(SPREAD_ELEMENTS_REGEXP, '');
+        data = extractPropertiesFromObjectLiteral(node);
       } else {
-        const fullNodeText =
-          node['expression'].arguments[0].body.expression.getFullText();
-        // strip any spread elements
-        objSource = fullNodeText.replace(SPREAD_ELEMENTS_REGEXP, '');
+        // Handle compat.config(...).map(...) pattern
+        const arrowBody = node['expression'].arguments[0].body.expression;
+        if (ts.isObjectLiteralExpression(arrowBody)) {
+          data = extractPropertiesFromObjectLiteral(arrowBody);
+        } else {
+          continue;
+        }
       }
-      const data = parseTextToJson(objSource);
-      if (lookup(data)) {
+
+      if (lookup(data as Linter.ConfigOverride<Linter.RulesRecord>)) {
         return true;
       }
     }
@@ -219,6 +221,79 @@ function parseTextToJson(text: string): any {
   );
 }
 
+/**
+ * Extracts literal values from AST nodes.
+ * Returns undefined for complex expressions that can't be statically evaluated.
+ */
+function extractLiteralValue(node: ts.Node): unknown {
+  if (ts.isStringLiteral(node)) {
+    return node.text;
+  }
+  if (ts.isNumericLiteral(node)) {
+    return Number(node.text);
+  }
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+
+  if (ts.isArrayLiteralExpression(node)) {
+    const arr: unknown[] = [];
+    for (const element of node.elements) {
+      const value = extractLiteralValue(element);
+      if (value === undefined) return undefined;
+      arr.push(value);
+    }
+    return arr;
+  }
+
+  if (ts.isObjectLiteralExpression(node)) {
+    const obj: Record<string, unknown> = {};
+    for (const prop of node.properties) {
+      if (ts.isPropertyAssignment(prop)) {
+        const name = prop.name.getText().replace(/['"]/g, '');
+        const value = extractLiteralValue(prop.initializer);
+        if (value === undefined) {
+          // Skip properties with non-extractable values (like variable references)
+          continue;
+        }
+        obj[name] = value;
+      } else if (ts.isSpreadAssignment(prop)) {
+        // Cannot extract spread assignments statically, skip them
+        continue;
+      } else {
+        // Skip other property types (shorthand, method, etc.)
+        continue;
+      }
+    }
+    return obj;
+  }
+
+  // For complex expressions (identifiers, function calls, etc.), return undefined
+  return undefined;
+}
+
+/**
+ * Extracts property values from an ObjectLiteralExpression using AST.
+ * Only extracts properties that have simple literal values.
+ * Returns a partial object suitable for the lookup function.
+ */
+function extractPropertiesFromObjectLiteral(
+  node: ts.ObjectLiteralExpression
+): Partial<Linter.ConfigOverride<Linter.RulesRecord>> {
+  const result: Record<string, unknown> = {};
+  for (const prop of node.properties) {
+    if (ts.isPropertyAssignment(prop)) {
+      const name = prop.name.getText().replace(/['"]/g, '');
+      const value = extractLiteralValue(prop.initializer);
+      if (value !== undefined) {
+        result[name] = value;
+      }
+    }
+  }
+
+  return result as Partial<Linter.ConfigOverride<Linter.RulesRecord>>;
+}
+
 /**
  * Finds an override matching the lookup function and applies the update function to it
  */