fix(sort-regexp): skip sorting when alternatives contain unnamed captures

Author: azat-io

rules/sort-regexp.ts

@@ -10,6 +10,7 @@ import {
   commonJsonSchemas,
   groupsJsonSchema,
 } from '../utils/common-json-schemas'
+import { alternativesContainUnnamedCapturingGroups } from './sort-regexp/alternatives-contain-unnamed-capturing-groups'
 import { buildGetCustomGroupOverriddenOptionsFunction } from '../utils/get-custom-groups-compare-options'
 import { validateGeneratedGroupsConfiguration } from '../utils/validate-generated-groups-configuration'
 import { getCharacterClassElementSortKey } from './sort-regexp/get-character-class-element-sort-key'
@@ -164,6 +165,14 @@ export default createEslintRule<Options, MessageId>({
             return
           }
 
+          if (
+            alternativesContainUnnamedCapturingGroups(
+              alternative.parent.alternatives,
+            )
+          ) {
+            return
+          }
+
           if (
             hasShadowingAlternatives({
               alternatives: alternative.parent.alternatives,

rules/sort-regexp/alternatives-contain-unnamed-capturing-groups.ts

@@ -0,0 +1,71 @@
+import type { Alternative, Element } from '@eslint-community/regexpp/ast'
+
+/**
+ * Checks whether any alternative contains an unnamed capturing group.
+ *
+ * @param alternatives - Alternatives to inspect.
+ * @returns True if at least one unnamed capturing group is found.
+ */
+export function alternativesContainUnnamedCapturingGroups(
+  alternatives: Alternative[],
+): boolean {
+  return alternatives.some(alternativeContainsUnnamedCapturingGroups)
+}
+
+/**
+ * Determines whether the given element (or any nested element) contains an
+ * unnamed capturing group.
+ *
+ * @param element - Regex element to inspect.
+ * @returns True when an unnamed capturing group is found.
+ */
+function elementContainsUnnamedCapturingGroups(element: Element): boolean {
+  switch (element.type) {
+    case 'CapturingGroup': {
+      if (!element.name) {
+        return true
+      }
+
+      return element.alternatives.some(
+        alternativeContainsUnnamedCapturingGroups,
+      )
+    }
+
+    case 'Quantifier': {
+      return elementContainsUnnamedCapturingGroups(element.element)
+    }
+
+    case 'Assertion': {
+      if (element.kind === 'lookahead' || element.kind === 'lookbehind') {
+        return element.alternatives.some(
+          alternativeContainsUnnamedCapturingGroups,
+        )
+      }
+
+      return false
+    }
+
+    case 'Group': {
+      return element.alternatives.some(
+        alternativeContainsUnnamedCapturingGroups,
+      )
+    }
+
+    default: {
+      return false
+    }
+  }
+}
+
+/**
+ * Checks whether an alternative contains unnamed capturing groups by inspecting
+ * all of its direct elements.
+ *
+ * @param alternative - Alternative to inspect.
+ * @returns True when an unnamed capture appears within the alternative.
+ */
+function alternativeContainsUnnamedCapturingGroups(
+  alternative: Alternative,
+): boolean {
+  return alternative.elements.some(elementContainsUnnamedCapturingGroups)
+}

test/rules/sort-regexp.test.ts

@@ -634,6 +634,15 @@ describe('sort-regexp', () => {
       })
     })
 
+    it('skips sorting when alternatives contain unnamed capturing groups', async () => {
+      await valid({
+        code: dedent`
+          const regex = /\\(.)|(['"])/gsu;
+        `,
+        options: [options],
+      })
+    })
+
     it('sorts alternatives with escaped characters', async () => {
       await invalid({
         errors: [
@@ -800,17 +809,8 @@ describe('sort-regexp', () => {
       })
     })
 
-    it('sorts alternatives with alternation groups', async () => {
-      await invalid({
-        errors: [
-          {
-            data: { right: '(a|b)', left: '(c|d)' },
-            messageId: 'unexpectedRegExpOrder',
-          },
-        ],
-        output: dedent`
-          /((a|b)|(c|d)|(e|f))/
-        `,
+    it('skips sorting when alternatives are unnamed capturing groups', async () => {
+      await valid({
         code: dedent`
           /((c|d)|(a|b)|(e|f))/
         `,
@@ -2184,17 +2184,8 @@ describe('sort-regexp', () => {
       })
     })
 
-    it('sorts alternatives with alternation groups', async () => {
-      await invalid({
-        errors: [
-          {
-            data: { right: '(a|b)', left: '(c|d)' },
-            messageId: 'unexpectedRegExpOrder',
-          },
-        ],
-        output: dedent`
-          /((a|b)|(c|d)|(e|f))/
-        `,
+    it('skips sorting unnamed capturing group alternatives in secondary suite', async () => {
+      await valid({
         code: dedent`
           /((c|d)|(a|b)|(e|f))/
         `,