Make optimal-quantifier-concatenation consistent (#257)

Author: RunDevelopment

docs/rules/optimal-quantifier-concatenation.md

@@ -34,7 +34,6 @@ var foo = /a\w*/;
 /* ✗ BAD */
 var foo = /\w+\d+/;
 var foo = /\w+\d?/;
-var foo = /\w?\w/;
 var foo = /[ab]*(?:a|b)/;
 var foo = /\w+(?:(a)|b)*/;
 ```

lib/rules/optimal-quantifier-concatenation.ts

@@ -293,6 +293,41 @@ function getQuantifierRepeatedElementReplacement(
     return { messageId: "combine", raw }
 }
 
+/**
+ * Whether the computed replacement is to be ignored.
+ */
+function ignoreReplacement(
+    left: Element,
+    right: Element,
+    result: Replacement,
+): boolean {
+    // There is a relatively common case for which we want to make
+    // an exception: `aa?`
+    // We will only suggest the replacement if the new raw is
+    // shorter than the current one.
+    if (left.type === "Quantifier") {
+        if (
+            left.raw.length + right.raw.length <= result.raw.length &&
+            isGroupOrCharacter(right) &&
+            left.min === 0 &&
+            left.max === 1
+        ) {
+            return true
+        }
+    }
+    if (right.type === "Quantifier") {
+        if (
+            left.raw.length + right.raw.length <= result.raw.length &&
+            isGroupOrCharacter(left) &&
+            right.min === 0 &&
+            right.max === 1
+        ) {
+            return true
+        }
+    }
+    return false
+}
+
 /**
  * Returns the replacement for the two adjacent elements.
  */
@@ -303,7 +338,7 @@ function getReplacement(
 ): Replacement | null {
     if (left.type === "Quantifier" && right.type === "Quantifier") {
         const result = getQuantifiersReplacement(left, right, context)
-        if (result) return result
+        if (result && !ignoreReplacement(left, right, result)) return result
     }
 
     if (left.type === "Quantifier") {
@@ -313,7 +348,7 @@ function getReplacement(
                 [left, rightRep],
                 context,
             )
-            if (result) return result
+            if (result && !ignoreReplacement(left, right, result)) return result
         }
     }
 
@@ -324,22 +359,7 @@ function getReplacement(
                 [leftRep, right],
                 context,
             )
-            if (result) {
-                // There is a relatively common case for which we want to make
-                // an exception: `aa?`
-                // We will only suggest the replacement if the new raw is
-                // shorter than the current one.
-                if (
-                    isGroupOrCharacter(left) &&
-                    right.min === 0 &&
-                    right.max === 1 &&
-                    left.raw.length + right.raw.length <= result.raw.length
-                ) {
-                    return null
-                }
-
-                return result
-            }
+            if (result && !ignoreReplacement(left, right, result)) return result
         }
     }
 

tests/lib/rules/optimal-quantifier-concatenation.ts

@@ -17,6 +17,7 @@ tester.run("optimal-quantifier-concatenation", rule as any, {
         String.raw`/a+b+c+d+[abc]+/`,
         String.raw`/(?:a|::)?\w+/`,
         String.raw`/aa?/`,
+        String.raw`/\w?\w/`,
     ],
     invalid: [
         {
@@ -103,13 +104,6 @@ tester.run("optimal-quantifier-concatenation", rule as any, {
                 "'\\w*' and '\\w' can be combined into one quantifier '\\w+'.",
             ],
         },
-        {
-            code: String.raw`/\w?\w/`,
-            output: String.raw`/\w{1,2}/`,
-            errors: [
-                "'\\w?' and '\\w' can be combined into one quantifier '\\w{1,2}'.",
-            ],
-        },
         {
             code: String.raw`/\w+\w/`,
             output: String.raw`/\w{2,}/`,