Add no-non-standard-flag rule (#167)

* Add `no-non-standard-flags` rule

* Renamed rule

* Fixed example

Author: RunDevelopment

README.md

@@ -98,6 +98,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-invisible-character](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-invisible-character.html) | disallow invisible raw character | :star::wrench: |
 | [regexp/no-lazy-ends](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-lazy-ends.html) | disallow lazy quantifiers at the end of an expression |  |
 | [regexp/no-legacy-features](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-legacy-features.html) | disallow legacy RegExp features |  |
+| [regexp/no-non-standard-flag](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-non-standard-flag.html) | disallow non-standard flags |  |
 | [regexp/no-obscure-range](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-obscure-range.html) | disallow obscure character ranges |  |
 | [regexp/no-octal](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-octal.html) | disallow octal escape sequence | :star: |
 | [regexp/no-optional-assertion](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-optional-assertion.html) | disallow optional assertions |  |

docs/rules/README.md

@@ -26,6 +26,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-invisible-character](./no-invisible-character.md) | disallow invisible raw character | :star::wrench: |
 | [regexp/no-lazy-ends](./no-lazy-ends.md) | disallow lazy quantifiers at the end of an expression |  |
 | [regexp/no-legacy-features](./no-legacy-features.md) | disallow legacy RegExp features |  |
+| [regexp/no-non-standard-flag](./no-non-standard-flag.md) | disallow non-standard flags |  |
 | [regexp/no-obscure-range](./no-obscure-range.md) | disallow obscure character ranges |  |
 | [regexp/no-octal](./no-octal.md) | disallow octal escape sequence | :star: |
 | [regexp/no-optional-assertion](./no-optional-assertion.md) | disallow optional assertions |  |

docs/rules/no-non-standard-flag.md

@@ -0,0 +1,40 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/no-non-standard-flag"
+description: "disallow non-standard flags"
+---
+# regexp/no-non-standard-flag
+
+> disallow non-standard flags
+
+- :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+
+## :book: Rule Details
+
+This rule reports non-standard flags.
+
+Some JavaScript runtime implementations allow special flags not defined in the ECMAScript standard. These flags are experimental and should not be used in production code.
+
+<eslint-code-block>
+
+```js
+/* eslint regexp/no-non-standard-flag: "error" */
+
+/* ✓ GOOD */
+var foo = /a*b*c/guy;
+
+/* ✗ BAD */
+var foo = RegExp("(?:a|a)*b", "l");
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/no-non-standard-flag.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/no-non-standard-flag.ts)

lib/rules/no-non-standard-flag.ts

@@ -0,0 +1,51 @@
+import type { RegExpVisitor } from "regexpp/visitor"
+import type { RegExpContext } from "../utils"
+import { createRule, defineRegexpVisitor } from "../utils"
+
+const STANDARD_FLAGS = "gimsuy"
+
+export default createRule("no-non-standard-flag", {
+    meta: {
+        docs: {
+            description: "disallow non-standard flags",
+            // TODO Switch to recommended in the major version.
+            // recommended: true,
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            unexpected: "Unexpected non-standard flag '{{flag}}'.",
+        },
+        type: "suggestion", // "problem",
+    },
+    create(context) {
+        /**
+         * Create visitor
+         */
+        function createVisitor({
+            node,
+            getFlagsLocation,
+            flagsString,
+        }: RegExpContext): RegExpVisitor.Handlers {
+            if (flagsString) {
+                const nonStandard = [...flagsString].filter(
+                    (f) => !STANDARD_FLAGS.includes(f),
+                )
+
+                if (nonStandard.length > 0) {
+                    context.report({
+                        node,
+                        loc: getFlagsLocation(),
+                        messageId: "unexpected",
+                        data: { flag: nonStandard[0] },
+                    })
+                }
+            }
+            return {}
+        }
+
+        return defineRegexpVisitor(context, {
+            createVisitor,
+        })
+    },
+})

lib/rules/no-useless-flag.ts

@@ -13,7 +13,7 @@ import type { KnownMethodCall } from "../utils/ast-utils"
 import { findVariable, isKnownMethodCall, getParent } from "../utils/ast-utils"
 import { createTypeTracker } from "../utils/type-tracker"
 import type { RuleListener } from "../types"
-import type { Rule, SourceCode } from "eslint"
+import type { Rule } from "eslint"
 
 type CodePathStack = {
     codePathId: string
@@ -191,26 +191,11 @@ function getFlagLocation(
  * Returns a fixer that removes the given flag.
  */
 function fixRemoveFlag(
-    fixer: Rule.RuleFixer,
-    node: RegExpExpression,
+    { flagsString, fixReplaceFlags }: RegExpContext,
     flag: "i" | "m" | "s" | "g",
-    sourceCode: SourceCode,
 ) {
-    if (node.type === "Literal") {
-        const flagIndex =
-            node.range![1] -
-            node.regex.flags.length +
-            node.regex.flags.indexOf(flag)
-        const beforeRange: [number, number] = [node.range![0], flagIndex]
-        return [
-            // Replace the range of regular expression literals to avoid conflicts.
-            fixer.replaceTextRange(
-                beforeRange,
-                sourceCode.text.slice(...beforeRange),
-            ),
-            // Remove flag
-            fixer.removeRange([flagIndex, flagIndex + 1]),
-        ]
+    if (flagsString) {
+        return fixReplaceFlags(flagsString.replace(flag, ""))
     }
     return null
 }
@@ -220,8 +205,10 @@ function fixRemoveFlag(
  */
 function createUselessIgnoreCaseFlagVisitor(context: Rule.RuleContext) {
     return defineRegexpVisitor(context, {
-        createVisitor({ flags, regexpNode, toCharSet }: RegExpContext) {
-            if (!flags.ignoreCase) {
+        createVisitor(regExpContext: RegExpContext) {
+            const { flags, regexpNode, toCharSet, ownsFlags } = regExpContext
+
+            if (!flags.ignoreCase || !ownsFlags) {
                 return {}
             }
 
@@ -273,14 +260,7 @@ function createUselessIgnoreCaseFlagVisitor(context: Rule.RuleContext) {
                             node: regexpNode,
                             loc: getFlagLocation(context, regexpNode, "i"),
                             messageId: "uselessIgnoreCaseFlag",
-                            fix(fixer) {
-                                return fixRemoveFlag(
-                                    fixer,
-                                    regexpNode,
-                                    "i",
-                                    context.getSourceCode(),
-                                )
-                            },
+                            fix: fixRemoveFlag(regExpContext, "i"),
                         })
                     }
                 },
@@ -294,8 +274,10 @@ function createUselessIgnoreCaseFlagVisitor(context: Rule.RuleContext) {
  */
 function createUselessMultilineFlagVisitor(context: Rule.RuleContext) {
     return defineRegexpVisitor(context, {
-        createVisitor({ flags, regexpNode }: RegExpContext) {
-            if (!flags.multiline) {
+        createVisitor(regExpContext: RegExpContext) {
+            const { flags, regexpNode, ownsFlags } = regExpContext
+
+            if (!flags.multiline || !ownsFlags) {
                 return {}
             }
             let unnecessary = true
@@ -311,14 +293,7 @@ function createUselessMultilineFlagVisitor(context: Rule.RuleContext) {
                             node: regexpNode,
                             loc: getFlagLocation(context, regexpNode, "m"),
                             messageId: "uselessMultilineFlag",
-                            fix(fixer) {
-                                return fixRemoveFlag(
-                                    fixer,
-                                    regexpNode,
-                                    "m",
-                                    context.getSourceCode(),
-                                )
-                            },
+                            fix: fixRemoveFlag(regExpContext, "m"),
                         })
                     }
                 },
@@ -332,8 +307,10 @@ function createUselessMultilineFlagVisitor(context: Rule.RuleContext) {
  */
 function createUselessDotAllFlagVisitor(context: Rule.RuleContext) {
     return defineRegexpVisitor(context, {
-        createVisitor({ flags, regexpNode }: RegExpContext) {
-            if (!flags.dotAll) {
+        createVisitor(regExpContext: RegExpContext) {
+            const { flags, regexpNode, ownsFlags } = regExpContext
+
+            if (!flags.dotAll || !ownsFlags) {
                 return {}
             }
             let unnecessary = true
@@ -349,14 +326,7 @@ function createUselessDotAllFlagVisitor(context: Rule.RuleContext) {
                             node: regexpNode,
                             loc: getFlagLocation(context, regexpNode, "s"),
                             messageId: "uselessDotAllFlag",
-                            fix(fixer) {
-                                return fixRemoveFlag(
-                                    fixer,
-                                    regexpNode,
-                                    "s",
-                                    context.getSourceCode(),
-                                )
-                            },
+                            fix: fixRemoveFlag(regExpContext, "s"),
                         })
                     }
                 },

lib/rules/sort-flags.ts

@@ -1,4 +1,3 @@
-import type { Literal } from "estree"
 import type { RegExpVisitor } from "regexpp/visitor"
 import type { RegExpContext } from "../utils"
 import { createRule, defineRegexpVisitor } from "../utils"
@@ -20,30 +19,6 @@ export default createRule("sort-flags", {
         type: "suggestion", // "problem",
     },
     create(context) {
-        /**
-         * Report
-         */
-        function report(
-            node: Literal,
-            flags: string,
-            sortedFlags: string,
-            flagsRange: [number, number],
-        ) {
-            const sourceCode = context.getSourceCode()
-            context.report({
-                node,
-                loc: {
-                    start: sourceCode.getLocFromIndex(flagsRange[0]),
-                    end: sourceCode.getLocFromIndex(flagsRange[1]),
-                },
-                messageId: "sortFlags",
-                data: { flags, sortedFlags },
-                fix(fixer) {
-                    return fixer.replaceTextRange(flagsRange, sortedFlags)
-                },
-            })
-        }
-
         /**
          * Sort regexp flags
          */
@@ -58,30 +33,21 @@ export default createRule("sort-flags", {
          */
         function createVisitor({
             regexpNode,
+            flagsString,
+            ownsFlags,
+            getFlagsLocation,
+            fixReplaceFlags,
         }: RegExpContext): RegExpVisitor.Handlers {
-            if (regexpNode.type === "Literal") {
-                const flags = regexpNode.regex.flags
-                const sortedFlags = sortFlags(flags)
-                if (flags !== sortedFlags) {
-                    report(regexpNode, flags, sortedFlags, [
-                        regexpNode.range![1] - regexpNode.regex.flags.length,
-                        regexpNode.range![1],
-                    ])
-                }
-            } else {
-                const flagsArg = regexpNode.arguments[1]
-                if (
-                    flagsArg.type === "Literal" &&
-                    typeof flagsArg.value === "string"
-                ) {
-                    const flags = flagsArg.value
-                    const sortedFlags = sortFlags(flags)
-                    if (flags !== sortedFlags) {
-                        report(flagsArg, flags, sortedFlags, [
-                            flagsArg.range![0] + 1,
-                            flagsArg.range![1] - 1,
-                        ])
-                    }
+            if (flagsString && ownsFlags) {
+                const sortedFlags = sortFlags(flagsString)
+                if (flagsString !== sortedFlags) {
+                    context.report({
+                        node: regexpNode,
+                        loc: getFlagsLocation(),
+                        messageId: "sortFlags",
+                        data: { flags: flagsString, sortedFlags },
+                        fix: fixReplaceFlags(sortedFlags),
+                    })
                 }
             }