| /** |
| * @fileoverview Rule to disallow useless backreferences in regular expressions |
| * @author Milos Djermanovic |
| */ |
| |
| "use strict"; |
| |
| //------------------------------------------------------------------------------ |
| // Requirements |
| //------------------------------------------------------------------------------ |
| |
| const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("eslint-utils"); |
| const { RegExpParser, visitRegExpAST } = require("regexpp"); |
| |
| //------------------------------------------------------------------------------ |
| // Helpers |
| //------------------------------------------------------------------------------ |
| |
| const parser = new RegExpParser(); |
| |
| /** |
| * Finds the path from the given `regexpp` AST node to the root node. |
| * @param {regexpp.Node} node Node. |
| * @returns {regexpp.Node[]} Array that starts with the given node and ends with the root node. |
| */ |
| function getPathToRoot(node) { |
| const path = []; |
| let current = node; |
| |
| do { |
| path.push(current); |
| current = current.parent; |
| } while (current); |
| |
| return path; |
| } |
| |
| /** |
| * Determines whether the given `regexpp` AST node is a lookaround node. |
| * @param {regexpp.Node} node Node. |
| * @returns {boolean} `true` if it is a lookaround node. |
| */ |
| function isLookaround(node) { |
| return node.type === "Assertion" && |
| (node.kind === "lookahead" || node.kind === "lookbehind"); |
| } |
| |
| /** |
| * Determines whether the given `regexpp` AST node is a negative lookaround node. |
| * @param {regexpp.Node} node Node. |
| * @returns {boolean} `true` if it is a negative lookaround node. |
| */ |
| function isNegativeLookaround(node) { |
| return isLookaround(node) && node.negate; |
| } |
| |
| //------------------------------------------------------------------------------ |
| // Rule Definition |
| //------------------------------------------------------------------------------ |
| |
| /** @type {import('../shared/types').Rule} */ |
| module.exports = { |
| meta: { |
| type: "problem", |
| |
| docs: { |
| description: "disallow useless backreferences in regular expressions", |
| recommended: true, |
| url: "https://eslint.org/docs/rules/no-useless-backreference" |
| }, |
| |
| schema: [], |
| |
| messages: { |
| nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' from within that group.", |
| forward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which appears later in the pattern.", |
| backward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which appears before in the same lookbehind.", |
| disjunctive: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which is in another alternative.", |
| intoNegativeLookaround: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which is in a negative lookaround." |
| } |
| }, |
| |
| create(context) { |
| |
| /** |
| * Checks and reports useless backreferences in the given regular expression. |
| * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call. |
| * @param {string} pattern Regular expression pattern. |
| * @param {string} flags Regular expression flags. |
| * @returns {void} |
| */ |
| function checkRegex(node, pattern, flags) { |
| let regExpAST; |
| |
| try { |
| regExpAST = parser.parsePattern(pattern, 0, pattern.length, flags.includes("u")); |
| } catch { |
| |
| // Ignore regular expressions with syntax errors |
| return; |
| } |
| |
| visitRegExpAST(regExpAST, { |
| onBackreferenceEnter(bref) { |
| const group = bref.resolved, |
| brefPath = getPathToRoot(bref), |
| groupPath = getPathToRoot(group); |
| let messageId = null; |
| |
| if (brefPath.includes(group)) { |
| |
| // group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match. |
| messageId = "nested"; |
| } else { |
| |
| // Start from the root to find the lowest common ancestor. |
| let i = brefPath.length - 1, |
| j = groupPath.length - 1; |
| |
| do { |
| i--; |
| j--; |
| } while (brefPath[i] === groupPath[j]); |
| |
| const indexOfLowestCommonAncestor = j + 1, |
| groupCut = groupPath.slice(0, indexOfLowestCommonAncestor), |
| commonPath = groupPath.slice(indexOfLowestCommonAncestor), |
| lowestCommonLookaround = commonPath.find(isLookaround), |
| isMatchingBackward = lowestCommonLookaround && lowestCommonLookaround.kind === "lookbehind"; |
| |
| if (!isMatchingBackward && bref.end <= group.start) { |
| |
| // bref is left, group is right ('forward reference') => group hasn't matched yet when bref starts to match. |
| messageId = "forward"; |
| } else if (isMatchingBackward && group.end <= bref.start) { |
| |
| // the opposite of the previous when the regex is matching backward in a lookbehind context. |
| messageId = "backward"; |
| } else if (groupCut[groupCut.length - 1].type === "Alternative") { |
| |
| // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive. |
| messageId = "disjunctive"; |
| } else if (groupCut.some(isNegativeLookaround)) { |
| |
| // group is in a negative lookaround which isn't bref's ancestor => group has already failed when bref starts to match. |
| messageId = "intoNegativeLookaround"; |
| } |
| } |
| |
| if (messageId) { |
| context.report({ |
| node, |
| messageId, |
| data: { |
| bref: bref.raw, |
| group: group.raw |
| } |
| }); |
| } |
| } |
| }); |
| } |
| |
| return { |
| "Literal[regex]"(node) { |
| const { pattern, flags } = node.regex; |
| |
| checkRegex(node, pattern, flags); |
| }, |
| Program() { |
| const scope = context.getScope(), |
| tracker = new ReferenceTracker(scope), |
| traceMap = { |
| RegExp: { |
| [CALL]: true, |
| [CONSTRUCT]: true |
| } |
| }; |
| |
| for (const { node } of tracker.iterateGlobalReferences(traceMap)) { |
| const [patternNode, flagsNode] = node.arguments, |
| pattern = getStringIfConstant(patternNode, scope), |
| flags = getStringIfConstant(flagsNode, scope); |
| |
| if (typeof pattern === "string") { |
| checkRegex(node, pattern, flags || ""); |
| } |
| } |
| } |
| }; |
| } |
| }; |