Add regexp/no-useless-dollar-replacements and regexp/prefer-escape-replacement-dollar-char rules (#62)

* Add `regexp/no-useless-dollar-replacements` rule

* update doc

* Add regexp/prefer-escape-replacement-dollar-char rule

* fix

Author: ota-meshi

README.md

@@ -97,6 +97,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-octal](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-octal.html) | disallow octal escape sequence | :star: |
 | [regexp/no-useless-backreference](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-backreference.html) | disallow useless backreferences in regular expressions |  |
 | [regexp/no-useless-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-character-class.html) | disallow character class with one character | :wrench: |
+| [regexp/no-useless-dollar-replacements](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-dollar-replacements.html) | disallow useless `$` replacements in replacement string |  |
 | [regexp/no-useless-escape](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-escape.html) | disallow unnecessary escape characters in RegExp |  |
 | [regexp/no-useless-exactly-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-exactly-quantifier.html) | disallow unnecessary exactly quantifier | :star: |
 | [regexp/no-useless-non-capturing-group](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-non-capturing-group.html) | disallow unnecessary Non-capturing group | :wrench: |
@@ -106,6 +107,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/order-in-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/order-in-character-class.html) | enforces elements order in character class | :wrench: |
 | [regexp/prefer-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-character-class.html) | enforce using character class | :wrench: |
 | [regexp/prefer-d](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-d.html) | enforce using `\d` | :star::wrench: |
+| [regexp/prefer-escape-replacement-dollar-char](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-escape-replacement-dollar-char.html) | enforces escape of replacement `$` character (`$$`). |  |
 | [regexp/prefer-plus-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-plus-quantifier.html) | enforce using `+` quantifier | :star::wrench: |
 | [regexp/prefer-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-quantifier.html) | enforce using quantifier | :wrench: |
 | [regexp/prefer-question-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-question-quantifier.html) | enforce using `?` quantifier | :star::wrench: |

docs/rules/README.md

@@ -25,6 +25,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-octal](./no-octal.md) | disallow octal escape sequence | :star: |
 | [regexp/no-useless-backreference](./no-useless-backreference.md) | disallow useless backreferences in regular expressions |  |
 | [regexp/no-useless-character-class](./no-useless-character-class.md) | disallow character class with one character | :wrench: |
+| [regexp/no-useless-dollar-replacements](./no-useless-dollar-replacements.md) | disallow useless `$` replacements in replacement string |  |
 | [regexp/no-useless-escape](./no-useless-escape.md) | disallow unnecessary escape characters in RegExp |  |
 | [regexp/no-useless-exactly-quantifier](./no-useless-exactly-quantifier.md) | disallow unnecessary exactly quantifier | :star: |
 | [regexp/no-useless-non-capturing-group](./no-useless-non-capturing-group.md) | disallow unnecessary Non-capturing group | :wrench: |
@@ -34,6 +35,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/order-in-character-class](./order-in-character-class.md) | enforces elements order in character class | :wrench: |
 | [regexp/prefer-character-class](./prefer-character-class.md) | enforce using character class | :wrench: |
 | [regexp/prefer-d](./prefer-d.md) | enforce using `\d` | :star::wrench: |
+| [regexp/prefer-escape-replacement-dollar-char](./prefer-escape-replacement-dollar-char.md) | enforces escape of replacement `$` character (`$$`). |  |
 | [regexp/prefer-plus-quantifier](./prefer-plus-quantifier.md) | enforce using `+` quantifier | :star::wrench: |
 | [regexp/prefer-quantifier](./prefer-quantifier.md) | enforce using quantifier | :wrench: |
 | [regexp/prefer-question-quantifier](./prefer-question-quantifier.md) | enforce using `?` quantifier | :star::wrench: |

docs/rules/no-useless-dollar-replacements.md

@@ -0,0 +1,62 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/no-useless-dollar-replacements"
+description: "disallow useless `$` replacements in replacement string"
+---
+# regexp/no-useless-dollar-replacements
+
+> disallow useless `$` replacements in replacement string
+
+- :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 aims to detect and disallow useless `$` replacements in regular expression replacements.
+
+<eslint-code-block>
+
+```js
+/* eslint regexp/no-useless-dollar-replacements: "error" */
+const str = 'John Smith';
+
+/* ✓ GOOD */
+var newStr = str.replace(/(\w+)\s(\w+)/, '$2, $1');
+// newStr = "Smith, John"
+
+var newStr = str.replace(/(?<first>\w+)\s(?<last>\w+)/, '$<last>, $<first>');
+// newStr = "Smith, John"
+
+'123456789012'.replaceAll(/(.)../g, '$1**'); // "1**4**7**0**"
+
+/* ✗ BAD */
+var newStr = str.replace(/(\w+)\s(\w+)/, '$3, $1 $2');
+// newStr = "$3, John Smith"
+
+var newStr = str.replace(/(?<first>\w+)\s(?<last>\w+)/, '$<last>, $<first> $<middle>');
+// newStr = "Smith, John "
+
+var newStr = str.replace(/(\w+)\s(\w+)/, '$<last>, $<first>');
+// newStr = "$<last>, $<first>"
+
+'123456789012'.replaceAll(/.(.)./g, '*$2*'); // "*$2**$2**$2**$2*"
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :couple: Related rules
+
+- [regexp/prefer-escape-replacement-dollar-char](./prefer-escape-replacement-dollar-char.md)
+
+## :books: Further reading
+
+- [MDN Web Docs - String.prototype.replace() > Specifying a string as a parameter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter)
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/no-useless-dollar-replacements.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/no-useless-dollar-replacements.ts)

docs/rules/prefer-escape-replacement-dollar-char.md

@@ -0,0 +1,47 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/prefer-escape-replacement-dollar-char"
+description: "enforces escape of replacement `$` character (`$$`)."
+---
+# regexp/prefer-escape-replacement-dollar-char
+
+> enforces escape of replacement `$` character (`$$`).
+
+- :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 aims to enforce escape when using the `$` character in replacement pattern of string replacement.
+
+<eslint-code-block>
+
+```js
+/* eslint regexp/prefer-escape-replacement-dollar-char: "error" */
+
+/* ✓ GOOD */
+'€1,234'.replace(/€/, '$$'); // "$1,234"
+
+
+/* ✗ BAD */
+'€1,234'.replace(/€/, '$'); // "$1,234"
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :couple: Related rules
+
+- [regexp/no-useless-dollar-replacements](./no-useless-dollar-replacements.md)
+
+## :books: Further reading
+
+- [MDN Web Docs - String.prototype.replace() > Specifying a string as a parameter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter)
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/prefer-escape-replacement-dollar-char.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/prefer-escape-replacement-dollar-char.ts)

lib/rules/no-useless-dollar-replacements.ts

@@ -0,0 +1,130 @@
+import type { CallExpression, Literal } from "estree"
+import { createRule } from "../utils"
+import { createTypeTracker } from "../utils/type-tracker"
+import type { RegExpLiteral, Pattern } from "regexpp/ast"
+import type { Rule } from "eslint"
+import type { ReferenceElement } from "../utils/ast-utils"
+import { isKnownMethodCall, parseReplacements } from "../utils/ast-utils"
+import {
+    extractCaptures,
+    getRegExpNodeFromExpression,
+} from "../utils/regexp-ast"
+
+/**
+ * Extract `$` replacements
+ */
+function extractDollarReplacements(context: Rule.RuleContext, node: Literal) {
+    return parseReplacements(context, node).filter(
+        (e): e is ReferenceElement => e.type === "ReferenceElement",
+    )
+}
+
+export default createRule("no-useless-dollar-replacements", {
+    meta: {
+        docs: {
+            description:
+                "disallow useless `$` replacements in replacement string",
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            numberRef:
+                "'${{ refText }}' replacement will insert '${{ refText }}' because there are less than {{ num }} capturing groups. Use '$$' if you want to escape '$'.",
+            numberRefCapturingNotFound:
+                "'${{ refText }}' replacement will insert '${{ refText }}' because capturing group does not found. Use '$$' if you want to escape '$'.",
+            namedRef:
+                "'$<{{ refText }}>' replacement will be ignored because the named capturing group is not found. Use '$$' if you want to escape '$'.",
+            namedRefNamedCapturingNotFound:
+                "'$<{{ refText }}>' replacement will insert '$<{{ refText }}>' because named capturing group does not found. Use '$$' if you want to escape '$'.",
+        },
+        type: "suggestion", // "problem",
+    },
+    create(context) {
+        const typeTracer = createTypeTracker(context)
+        const sourceCode = context.getSourceCode()
+
+        /** Verify */
+        function verify(
+            patternNode: Pattern | RegExpLiteral,
+            replacement: Literal,
+        ) {
+            const captures = extractCaptures(patternNode)
+            for (const dollarReplacement of extractDollarReplacements(
+                context,
+                replacement,
+            )) {
+                if (typeof dollarReplacement.ref === "number") {
+                    if (captures.count < dollarReplacement.ref) {
+                        context.report({
+                            node: replacement,
+                            loc: {
+                                start: sourceCode.getLocFromIndex(
+                                    dollarReplacement.range[0],
+                                ),
+                                end: sourceCode.getLocFromIndex(
+                                    dollarReplacement.range[1],
+                                ),
+                            },
+                            messageId:
+                                captures.count > 0
+                                    ? "numberRef"
+                                    : "numberRefCapturingNotFound",
+                            data: {
+                                refText: dollarReplacement.refText,
+                                num: String(dollarReplacement.ref),
+                            },
+                        })
+                    }
+                } else {
+                    if (!captures.names.has(dollarReplacement.ref)) {
+                        context.report({
+                            node: replacement,
+                            loc: {
+                                start: sourceCode.getLocFromIndex(
+                                    dollarReplacement.range[0],
+                                ),
+                                end: sourceCode.getLocFromIndex(
+                                    dollarReplacement.range[1],
+                                ),
+                            },
+                            messageId:
+                                captures.names.size > 0
+                                    ? "namedRef"
+                                    : "namedRefNamedCapturingNotFound",
+                            data: {
+                                refText: dollarReplacement.refText,
+                            },
+                        })
+                    }
+                }
+            }
+        }
+
+        return {
+            CallExpression(node: CallExpression) {
+                if (!isKnownMethodCall(node, { replace: 2, replaceAll: 2 })) {
+                    return
+                }
+                const mem = node.callee
+                const replacementTextNode = node.arguments[1]
+                if (
+                    replacementTextNode.type !== "Literal" ||
+                    typeof replacementTextNode.value !== "string"
+                ) {
+                    return
+                }
+                const patternNode = getRegExpNodeFromExpression(
+                    node.arguments[0],
+                    context,
+                )
+                if (!patternNode) {
+                    return
+                }
+                if (!typeTracer.isString(mem.object)) {
+                    return
+                }
+                verify(patternNode, replacementTextNode)
+            },
+        }
+    },
+})

lib/rules/prefer-escape-replacement-dollar-char.ts

@@ -0,0 +1,65 @@
+import type { CallExpression, Literal } from "estree"
+import { createRule } from "../utils"
+import { isKnownMethodCall, parseReplacements } from "../utils/ast-utils"
+import { createTypeTracker } from "../utils/type-tracker"
+
+export default createRule("prefer-escape-replacement-dollar-char", {
+    meta: {
+        docs: {
+            description: "enforces escape of replacement `$` character (`$$`).",
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            unexpected:
+                "Unexpected replacement `$` character without escaping. Use `$$` instead.",
+        },
+        type: "suggestion", // "problem",
+    },
+    create(context) {
+        const typeTracer = createTypeTracker(context)
+        const sourceCode = context.getSourceCode()
+
+        /** Verify */
+        function verify(replacement: Literal) {
+            for (const element of parseReplacements(context, replacement)) {
+                if (
+                    element.type === "CharacterElement" &&
+                    element.value === "$"
+                ) {
+                    context.report({
+                        node: replacement,
+                        loc: {
+                            start: sourceCode.getLocFromIndex(element.range[0]),
+                            end: sourceCode.getLocFromIndex(element.range[1]),
+                        },
+                        messageId: "unexpected",
+                    })
+                }
+            }
+        }
+
+        return {
+            CallExpression(node: CallExpression) {
+                if (!isKnownMethodCall(node, { replace: 2, replaceAll: 2 })) {
+                    return
+                }
+                const mem = node.callee
+                const replacementTextNode = node.arguments[1]
+                if (
+                    replacementTextNode.type !== "Literal" ||
+                    typeof replacementTextNode.value !== "string"
+                ) {
+                    return
+                }
+                if (!typeTracer.isRegExp(node.arguments[0])) {
+                    return
+                }
+                if (!typeTracer.isString(mem.object)) {
+                    return
+                }
+                verify(replacementTextNode)
+            },
+        }
+    },
+})

lib/rules/prefer-regexp-exec.ts

@@ -2,6 +2,7 @@ import type { CallExpression } from "estree"
 import { createRule } from "../utils"
 import { createTypeTracker } from "../utils/type-tracker"
 import { getStaticValue } from "eslint-utils"
+import { isKnownMethodCall } from "../utils/ast-utils"
 
 // Inspired by https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/prefer-regexp-exec.md
 export default createRule("prefer-regexp-exec", {
@@ -22,16 +23,7 @@ export default createRule("prefer-regexp-exec", {
 
         return {
             CallExpression(node: CallExpression) {
-                if (node.arguments.length !== 1) {
-                    return
-                }
-                if (
-                    node.callee.type !== "MemberExpression" ||
-                    node.callee.computed ||
-                    node.callee.property.type !== "Identifier" ||
-                    node.callee.property.name !== "match" ||
-                    node.callee.object.type === "Super"
-                ) {
+                if (!isKnownMethodCall(node, { match: 1 })) {
                     return
                 }
                 const arg = node.arguments[0]

lib/rules/prefer-regexp-test.ts

@@ -2,6 +2,7 @@ import type * as ES from "estree"
 import { hasSideEffect, isOpeningParenToken } from "eslint-utils"
 import { createRule } from "../utils"
 import { createTypeTracker } from "../utils/type-tracker"
+import { isKnownMethodCall } from "../utils/ast-utils"
 
 // Inspired by https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-regexp-test.md
 export default createRule("prefer-regexp-test", {
@@ -25,21 +26,7 @@ export default createRule("prefer-regexp-test", {
 
         return {
             CallExpression(node: ES.CallExpression) {
-                if (node.arguments.length !== 1) {
-                    return
-                }
-                if (
-                    node.callee.type !== "MemberExpression" ||
-                    node.callee.computed ||
-                    node.callee.property.type !== "Identifier" ||
-                    node.callee.object.type === "Super"
-                ) {
-                    return
-                }
-                if (
-                    node.callee.property.name !== "match" &&
-                    node.callee.property.name !== "exec"
-                ) {
+                if (!isKnownMethodCall(node, { match: 1, exec: 1 })) {
                     return
                 }
                 if (!isUseBoolean(node)) {