Added lookbehind option for prefer-lookaround (#499)

Author: RunDevelopment

docs/rules/prefer-lookaround.md

@@ -34,13 +34,23 @@ var str = 'JavaScript'.replace(/Java(Script)/g, 'Type$1')
 ```json
 {
   "regexp/prefer-lookaround": ["error", {
+      "lookbehind": true,
       "strictTypes": true
   }]
 }
 ```
 
-- `strictTypes` ... If `true`, strictly check the type of object to determine if the regex instance was used in `replace()` and `replaceAll()`. Default is `true`.\
-  This option is always on when using TypeScript.
+### `lookbehind`
+
+This option controls whether this rule will suggest using lookbehinds. Default is `true`.
+
+Safari is the last major browser that still does not support regex lookbehind assertions (as of December 2022). So if your code base targets Safari, you cannot use lookbehinds.
+
+### `strictTypes`
+
+If `true`, strictly check the type of object to determine if the regex instance was used in `replace()` and `replaceAll()`. Default is `true`.
+
+This option is always on when using TypeScript.
 
 ## :rocket: Version
 

lib/rules/prefer-lookaround.ts

@@ -364,19 +364,14 @@ function leadingTrailingElementsToLookaroundAssertionPatternText(
 function parseOption(
     userOption:
         | {
+              lookbehind?: boolean
               strictTypes?: boolean
           }
         | undefined,
 ) {
-    let strictTypes = true
-    if (userOption) {
-        if (userOption.strictTypes != null) {
-            strictTypes = userOption.strictTypes
-        }
-    }
-
     return {
-        strictTypes,
+        lookbehind: userOption?.lookbehind ?? true,
+        strictTypes: userOption?.strictTypes ?? true,
     }
 }
 
@@ -393,6 +388,7 @@ export default createRule("prefer-lookaround", {
             {
                 type: "object",
                 properties: {
+                    lookbehind: { type: "boolean" },
                     strictTypes: { type: "boolean" },
                 },
                 additionalProperties: false,
@@ -406,7 +402,7 @@ export default createRule("prefer-lookaround", {
         type: "suggestion",
     },
     create(context) {
-        const { strictTypes } = parseOption(context.options[0])
+        const { lookbehind, strictTypes } = parseOption(context.options[0])
         const typeTracer = createTypeTracker(context)
 
         /**
@@ -645,7 +641,7 @@ export default createRule("prefer-lookaround", {
                 },
                 onPatternLeave() {
                     // verify
-                    let reportStart = null
+                    let reportStart: ParsedStartPattern | null = null
                     if (
                         !startRefState.isUseOther &&
                         startRefState.capturingGroups.length === 1 && // It will not be referenced from more than one, but check it just in case.
@@ -654,7 +650,7 @@ export default createRule("prefer-lookaround", {
                     ) {
                         reportStart = parsedElements.start
                     }
-                    let reportEnd = null
+                    let reportEnd: ParsedEndPattern | null = null
                     if (
                         !endRefState.isUseOther &&
                         endRefState.capturingGroups.length === 1 && // It will not be referenced from more than one, but check it just in case.
@@ -676,6 +672,9 @@ export default createRule("prefer-lookaround", {
                     if (sideEffects.has(SideEffect.endRef)) {
                         reportEnd = null
                     }
+                    if (!lookbehind) {
+                        reportStart = null
+                    }
 
                     if (reportStart && reportEnd) {
                         const fix = buildFixer(

tests/lib/rules/prefer-lookaround.ts

@@ -202,6 +202,14 @@ tester.run("prefer-lookaround", rule as any, {
         // cannot replace assertions
         `var str = 'JavaScriptCode'.replace(/Java(Script)(?:Code)/g, 'Type$1')`,
         `var str = 'JavaScriptCode'.replace(/(?:Java)(Script)Code/g, '$1Element')`,
+
+        // no lookbehinds
+        {
+            code: `
+            const str = 'A JavaScript formatter written in JavaScript.'.replace(/(Java)Script/g, '$1');
+            `,
+            options: [{ lookbehind: false }],
+        },
     ],
     invalid: [
         {
@@ -800,5 +808,24 @@ tester.run("prefer-lookaround", rule as any, {
                 "This capturing group can be replaced with a lookbehind assertion ('(?<=((?<=Java))Script)').",
             ],
         },
+
+        // no lookbehinds
+        {
+            code: `
+            const str = 'I love unicorn! I hate unicorn?'.replace(/(?<before>love )unicorn(?<after>!)/, '$<before>🦄$<after>');
+            `,
+            output: `
+            const str = 'I love unicorn! I hate unicorn?'.replace(/(?<before>love )unicorn(?=!)/, '$<before>🦄');
+            `,
+            options: [{ lookbehind: false }],
+            errors: [
+                {
+                    message:
+                        "This capturing group can be replaced with a lookahead assertion ('(?=!)').",
+                    column: 91,
+                    endColumn: 102,
+                },
+            ],
+        },
     ],
 })