fix(linter): handle variable references in replaceOverride

The migration generator (@nx/plugin:migration) fails when the project's
ESLint flat config contains variable references in property values, such as:
`plugins: { 'package-json': pluginPackageJson }`

This happens because `replaceOverride` uses `parseTextToJson` to parse
the config, which fails for non-JSON-serializable JavaScript expressions.

The migration generator should work correctly even when the ESLint config
contains variable references. The fix applies the same approach used in
PR #33548 for `hasOverride`: using AST-based property extraction instead
of JSON parsing.

Fixes #34010

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jaysoo

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

@@ -681,22 +681,22 @@ export default [
 
         export default [
             {
-              "files": [
-                "my-lib/**/*.ts",
-                "my-lib/**/*.tsx"
-              ],
-              "rules": {
-                "my-rule": "error"
-              }
+                files: [
+                    "my-lib/**/*.ts",
+                    "my-lib/**/*.tsx"
+                ],
+                rules: {
+              "my-rule": "error"
+            }
             },
             {
-              "files": [
-                "my-lib/**/*.ts",
-                "my-lib/**/*.js"
-              ],
-              "rules": {
-                "my-rule": "error"
-              }
+                files: [
+                    "my-lib/**/*.ts",
+                    "my-lib/**/*.js"
+                ],
+                rules: {
+              "my-rule": "error"
+            }
             },
             {
                 files: [
@@ -752,14 +752,14 @@ export default [
 
         export default [
             {
-              "files": [
-                "my-lib/**/*.ts",
-                "my-lib/**/*.tsx"
-              ],
-              "rules": {
-                "my-ts-rule": "error",
-                "my-new-rule": "error"
-              }
+                files: [
+                    "my-lib/**/*.ts",
+                    "my-lib/**/*.tsx"
+                ],
+                rules: {
+              "my-ts-rule": "error",
+              "my-new-rule": "error"
+            }
             },
             {
                 files: [
@@ -808,18 +808,132 @@ export default [
         export default [
             ...compat.config({ extends: ["plugin:@nx/typescript"] }).map(config => ({
             ...config,
-              "files": [
+            files: [
                 "my-lib/**/*.ts",
                 "my-lib/**/*.tsx"
-              ],
-              "rules": {
-                "my-ts-rule": "error",
-                "my-new-rule": "error"
-              }
+            ],
+            rules: {
+              "my-ts-rule": "error",
+              "my-new-rule": "error"
+            }
           }),
         ];"
       `);
     });
+
+    it('should update files while preserving variable references (ESM)', () => {
+      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,
+        },
+        rules: {
+            '@nx/nx-plugin-checks': 'error'
+        }
+    }
+];`;
+
+      const result = replaceOverride(
+        content,
+        '',
+        (o) =>
+          Object.keys(o.rules ?? {}).includes('@nx/nx-plugin-checks') ||
+          Object.keys(o.rules ?? {}).includes('@nrwl/nx/nx-plugin-checks'),
+        (o) => {
+          const files = Array.isArray(o.files) ? o.files : [o.files];
+          return {
+            ...o,
+            files: [...files, './migrations.json'],
+          };
+        }
+      );
+
+      // Property-level AST update: only files is modified, plugins with variable refs is preserved
+      expect(result).toMatchInlineSnapshot(`
+        "
+        import pluginPackageJson from "eslint-plugin-package-json";
+        import jsoncParser from "jsonc-eslint-parser";
+
+        export default [
+            {
+                files: [
+              "package.json",
+              "./migrations.json"
+            ],
+                plugins: { "package-json": pluginPackageJson },
+                languageOptions: {
+                    parser: jsoncParser,
+                },
+                rules: {
+                    '@nx/nx-plugin-checks': 'error'
+                }
+            }
+        ];"
+      `);
+    });
+
+    it('should update files while preserving variable references (CJS)', () => {
+      const content = `
+const pluginPackageJson = require("eslint-plugin-package-json");
+const jsoncParser = require("jsonc-eslint-parser");
+
+module.exports = [
+    {
+        files: ["package.json"],
+        plugins: { "package-json": pluginPackageJson },
+        languageOptions: {
+            parser: jsoncParser,
+        },
+        rules: {
+            '@nx/nx-plugin-checks': 'error'
+        }
+    }
+];`;
+
+      const result = replaceOverride(
+        content,
+        '',
+        (o) =>
+          Object.keys(o.rules ?? {}).includes('@nx/nx-plugin-checks') ||
+          Object.keys(o.rules ?? {}).includes('@nrwl/nx/nx-plugin-checks'),
+        (o) => {
+          const files = Array.isArray(o.files) ? o.files : [o.files];
+          return {
+            ...o,
+            files: [...files, './migrations.json'],
+          };
+        }
+      );
+
+      // Property-level AST update: only files is modified, plugins with variable refs is preserved
+      expect(result).toMatchInlineSnapshot(`
+        "
+        const pluginPackageJson = require("eslint-plugin-package-json");
+        const jsoncParser = require("jsonc-eslint-parser");
+
+        module.exports = [
+            {
+                files: [
+              "package.json",
+              "./migrations.json"
+            ],
+                plugins: { "package-json": pluginPackageJson },
+                languageOptions: {
+                    parser: jsoncParser,
+                },
+                rules: {
+                    '@nx/nx-plugin-checks': 'error'
+                }
+            }
+        ];"
+      `);
+    });
   });
 
   describe('removePlugin', () => {

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

@@ -295,7 +295,66 @@ function extractPropertiesFromObjectLiteral(
 }
 
 /**
- * Finds an override matching the lookup function and applies the update function to it
+ * Find a property assignment node by name in an object literal.
+ */
+function findPropertyNode(
+  node: ts.ObjectLiteralExpression,
+  propertyName: string
+): ts.PropertyAssignment | undefined {
+  for (const prop of node.properties) {
+    if (ts.isPropertyAssignment(prop)) {
+      const name = prop.name.getText().replace(/['"]/g, '');
+      if (name === propertyName) {
+        return prop;
+      }
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Find properties that are added, changed, or removed.
+ */
+function findChangedProperties(
+  original: Record<string, unknown>,
+  updated: Record<string, unknown>
+): string[] {
+  const changed: string[] = [];
+  // Check modified/added properties
+  for (const key of Object.keys(updated)) {
+    if (JSON.stringify(original[key]) !== JSON.stringify(updated[key])) {
+      changed.push(key);
+    }
+  }
+  // Check removed properties
+  for (const key of Object.keys(original)) {
+    if (!(key in updated)) {
+      changed.push(key);
+    }
+  }
+  return changed;
+}
+
+/**
+ * Serialize a value to JavaScript source code. Handles converting eslintrc parser format to flat config format.
+ */
+function serializeValue(value: unknown, format: 'mjs' | 'cjs'): string {
+  const parserReplacement =
+    format === 'mjs'
+      ? (parser: string) => `(await import('${parser}'))`
+      : (parser: string) => `require('${parser}')`;
+
+  return JSON.stringify(value, null, 2)
+    .replace(
+      /"parser": "([^"]+)"/g,
+      (_, parser) => `"parser": ${parserReplacement(parser)}`
+    )
+    .replaceAll(/\n/g, '\n    '); // Maintain indentation
+}
+
+/**
+ * Finds an override matching the lookup function and applies the update function to it.
+ * Uses property-level AST updates to preserve properties with variable references.
  */
 export function replaceOverride(
   content: string,
@@ -320,52 +379,78 @@ export function replaceOverride(
   }
   const changes: StringChange[] = [];
   exportsArray.forEach((node) => {
-    if (isOverride(node)) {
-      let objSource;
-      let start, end;
-      if (ts.isObjectLiteralExpression(node)) {
-        objSource = node.getFullText();
-        start = node.properties.pos + 1; // keep leading line break
-        end = node.properties.end;
+    if (!isOverride(node)) {
+      return;
+    }
+
+    let objectLiteralNode: ts.ObjectLiteralExpression;
+    if (ts.isObjectLiteralExpression(node)) {
+      objectLiteralNode = node;
+    } else {
+      // Handle compat.config(...).map(...) pattern
+      const arrowBody = node['expression'].arguments[0].body.expression;
+      if (ts.isObjectLiteralExpression(arrowBody)) {
+        objectLiteralNode = arrowBody;
       } else {
-        const fullNodeText =
-          node['expression'].arguments[0].body.expression.getFullText();
-        // strip any spread elements
-        objSource = fullNodeText.replace(SPREAD_ELEMENTS_REGEXP, '');
-        start =
-          node['expression'].arguments[0].body.expression.properties.pos +
-          (fullNodeText.length - objSource.length);
-        end = node['expression'].arguments[0].body.expression.properties.end;
+        return;
       }
-      const data = parseTextToJson(objSource);
-      if (lookup(data)) {
-        changes.push({
-          type: ChangeType.Delete,
-          start,
-          length: end - start,
-        });
-        let updatedData = update(data);
-        if (updatedData) {
-          updatedData = mapFilePaths(updatedData);
-
-          const parserReplacement =
-            format === 'mjs'
-              ? (parser: string) => `(await import('${parser}'))`
-              : (parser: string) => `require('${parser}')`;
+    }
 
-          changes.push({
-            type: ChangeType.Insert,
-            index: start,
-            text:
-              '    ' +
-              JSON.stringify(updatedData, null, 2)
-                .replace(
-                  /"parser": "([^"]+)"/g,
-                  (_, parser) => `"parser": ${parserReplacement(parser)}`
-                )
-                .slice(2, -2) // Remove curly braces and start/end line breaks
-                .replaceAll(/\n/g, '\n    '), // Maintain indentation
-          });
+    // Use AST-based extraction to handle variable references (e.g., plugins: { 'abc': abc })
+    const data = extractPropertiesFromObjectLiteral(objectLiteralNode);
+    if (lookup(data as Linter.ConfigOverride<Linter.RulesRecord>)) {
+      // Deep clone before update (update functions may mutate nested objects)
+      const originalData = structuredClone(data);
+
+      let updatedData = update?.(data);
+      if (updatedData) {
+        updatedData = mapFilePaths(updatedData);
+
+        const changedProps = findChangedProperties(
+          originalData as Record<string, unknown>,
+          updatedData as Record<string, unknown>
+        );
+
+        for (const propName of changedProps) {
+          const originalNode = findPropertyNode(objectLiteralNode, propName);
+          const updatedValue = updatedData[propName];
+
+          if (originalNode && !(propName in updatedData)) {
+            // Delete property that was removed
+            changes.push({
+              type: ChangeType.Delete,
+              start: originalNode.pos,
+              length: originalNode.end - originalNode.pos,
+            });
+          } else if (originalNode) {
+            // Replace existing property value
+            const valueNode = originalNode.initializer;
+            changes.push({
+              type: ChangeType.Delete,
+              start: valueNode.pos,
+              length: valueNode.end - valueNode.pos,
+            });
+            changes.push({
+              type: ChangeType.Insert,
+              index: valueNode.pos,
+              text: ' ' + serializeValue(updatedValue, format),
+            });
+          } else {
+            // Add new property at the end of the object
+            const lastProp =
+              objectLiteralNode.properties[
+                objectLiteralNode.properties.length - 1
+              ];
+            const insertPos = lastProp
+              ? lastProp.end
+              : objectLiteralNode.pos + 1;
+            const needsComma = lastProp ? ',' : '';
+            changes.push({
+              type: ChangeType.Insert,
+              index: insertPos,
+              text: `${needsComma}\n    "${propName}": ${serializeValue(updatedValue, format)}`,
+            });
+          }
         }
       }
     }

packages/next/src/generators/application/application.spec.ts

@@ -830,6 +830,7 @@ describe('app', () => {
                 '**/*.cjs',
                 '**/*.mjs',
               ],
+              // Override or add rules here
               rules: {
                 '@next/next/no-html-link-for-pages': ['error', './pages'],
               },