359 lines
11 KiB
JavaScript
359 lines
11 KiB
JavaScript
/**
|
|
* @fileoverview Look for useless escapes in strings and regexes
|
|
* @author Onur Temizkan
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
const astUtils = require('./utils/ast-utils');
|
|
const { RegExpParser, visitRegExpAST } = require('@eslint-community/regexpp');
|
|
|
|
/**
|
|
* @typedef {import('@eslint-community/regexpp').AST.CharacterClass} CharacterClass
|
|
* @typedef {import('@eslint-community/regexpp').AST.ExpressionCharacterClass} ExpressionCharacterClass
|
|
*/
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Returns the union of two sets.
|
|
* @param {Set} setA The first set
|
|
* @param {Set} setB The second set
|
|
* @returns {Set} The union of the two sets
|
|
*/
|
|
function union(setA, setB) {
|
|
return new Set(
|
|
(function* () {
|
|
yield* setA;
|
|
yield* setB;
|
|
})()
|
|
);
|
|
}
|
|
|
|
const VALID_STRING_ESCAPES = union(new Set('\\nrvtbfux'), astUtils.LINEBREAKS);
|
|
const REGEX_GENERAL_ESCAPES = new Set('\\bcdDfnpPrsStvwWxu0123456789]');
|
|
const REGEX_NON_CHARCLASS_ESCAPES = union(
|
|
REGEX_GENERAL_ESCAPES,
|
|
new Set('^/.$*+?[{}|()Bk')
|
|
);
|
|
|
|
/*
|
|
* Set of characters that require escaping in character classes in `unicodeSets` mode.
|
|
* ( ) [ ] { } / - \ | are ClassSetSyntaxCharacter
|
|
*/
|
|
const REGEX_CLASSSET_CHARACTER_ESCAPES = union(
|
|
REGEX_GENERAL_ESCAPES,
|
|
new Set('q/[{}|()-')
|
|
);
|
|
|
|
/*
|
|
* A single character set of ClassSetReservedDoublePunctuator.
|
|
* && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~ are ClassSetReservedDoublePunctuator
|
|
*/
|
|
const REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR = new Set(
|
|
'!#$%&*+,.:;<=>?@^`~'
|
|
);
|
|
|
|
/** @type {import('../types').Rule.RuleModule} */
|
|
module.exports = {
|
|
meta: {
|
|
type: 'suggestion',
|
|
|
|
docs: {
|
|
description: 'Disallow unnecessary escape characters',
|
|
recommended: true,
|
|
url: 'https://eslint.org/docs/latest/rules/no-useless-escape',
|
|
},
|
|
|
|
hasSuggestions: true,
|
|
|
|
messages: {
|
|
unnecessaryEscape: 'Unnecessary escape character: \\{{character}}.',
|
|
removeEscape:
|
|
'Remove the `\\`. This maintains the current functionality.',
|
|
removeEscapeDoNotKeepSemantics:
|
|
'Remove the `\\` if it was inserted by mistake.',
|
|
escapeBackslash:
|
|
'Replace the `\\` with `\\\\` to include the actual backslash character.',
|
|
},
|
|
|
|
schema: [],
|
|
},
|
|
|
|
create(context) {
|
|
const sourceCode = context.sourceCode;
|
|
const parser = new RegExpParser();
|
|
|
|
/**
|
|
* Reports a node
|
|
* @param {ASTNode} node The node to report
|
|
* @param {number} startOffset The backslash's offset from the start of the node
|
|
* @param {string} character The uselessly escaped character (not including the backslash)
|
|
* @param {boolean} [disableEscapeBackslashSuggest] `true` if escapeBackslash suggestion should be turned off.
|
|
* @returns {void}
|
|
*/
|
|
function report(
|
|
node,
|
|
startOffset,
|
|
character,
|
|
disableEscapeBackslashSuggest
|
|
) {
|
|
const rangeStart = node.range[0] + startOffset;
|
|
const range = [rangeStart, rangeStart + 1];
|
|
const start = sourceCode.getLocFromIndex(rangeStart);
|
|
|
|
context.report({
|
|
node,
|
|
loc: {
|
|
start,
|
|
end: { line: start.line, column: start.column + 1 },
|
|
},
|
|
messageId: 'unnecessaryEscape',
|
|
data: { character },
|
|
suggest: [
|
|
{
|
|
// Removing unnecessary `\` characters in a directive is not guaranteed to maintain functionality.
|
|
messageId:
|
|
astUtils.isDirective(node.parent) ?
|
|
'removeEscapeDoNotKeepSemantics'
|
|
: 'removeEscape',
|
|
fix(fixer) {
|
|
return fixer.removeRange(range);
|
|
},
|
|
},
|
|
...(disableEscapeBackslashSuggest ?
|
|
[]
|
|
: [
|
|
{
|
|
messageId: 'escapeBackslash',
|
|
fix(fixer) {
|
|
return fixer.insertTextBeforeRange(range, '\\');
|
|
},
|
|
},
|
|
]),
|
|
],
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks if the escape character in given string slice is unnecessary.
|
|
* @private
|
|
* @param {ASTNode} node node to validate.
|
|
* @param {string} match string slice to validate.
|
|
* @returns {void}
|
|
*/
|
|
function validateString(node, match) {
|
|
const isTemplateElement = node.type === 'TemplateElement';
|
|
const escapedChar = match[0][1];
|
|
let isUnnecessaryEscape = !VALID_STRING_ESCAPES.has(escapedChar);
|
|
let isQuoteEscape;
|
|
|
|
if (isTemplateElement) {
|
|
isQuoteEscape = escapedChar === '`';
|
|
|
|
if (escapedChar === '$') {
|
|
// Warn if `\$` is not followed by `{`
|
|
isUnnecessaryEscape = match.input[match.index + 2] !== '{';
|
|
} else if (escapedChar === '{') {
|
|
/*
|
|
* Warn if `\{` is not preceded by `$`. If preceded by `$`, escaping
|
|
* is necessary and the rule should not warn. If preceded by `/$`, the rule
|
|
* will warn for the `/$` instead, as it is the first unnecessarily escaped character.
|
|
*/
|
|
isUnnecessaryEscape = match.input[match.index - 1] !== '$';
|
|
}
|
|
} else {
|
|
isQuoteEscape = escapedChar === node.raw[0];
|
|
}
|
|
|
|
if (isUnnecessaryEscape && !isQuoteEscape) {
|
|
report(node, match.index, match[0].slice(1));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if the escape character in given regexp is unnecessary.
|
|
* @private
|
|
* @param {ASTNode} node node to validate.
|
|
* @returns {void}
|
|
*/
|
|
function validateRegExp(node) {
|
|
const { pattern, flags } = node.regex;
|
|
let patternNode;
|
|
const unicode = flags.includes('u');
|
|
const unicodeSets = flags.includes('v');
|
|
|
|
try {
|
|
patternNode = parser.parsePattern(pattern, 0, pattern.length, {
|
|
unicode,
|
|
unicodeSets,
|
|
});
|
|
} catch {
|
|
// Ignore regular expressions with syntax errors
|
|
return;
|
|
}
|
|
|
|
/** @type {(CharacterClass | ExpressionCharacterClass)[]} */
|
|
const characterClassStack = [];
|
|
|
|
visitRegExpAST(patternNode, {
|
|
onCharacterClassEnter: (characterClassNode) =>
|
|
characterClassStack.unshift(characterClassNode),
|
|
onCharacterClassLeave: () => characterClassStack.shift(),
|
|
onExpressionCharacterClassEnter: (characterClassNode) =>
|
|
characterClassStack.unshift(characterClassNode),
|
|
onExpressionCharacterClassLeave: () => characterClassStack.shift(),
|
|
onCharacterEnter(characterNode) {
|
|
if (!characterNode.raw.startsWith('\\')) {
|
|
// It's not an escaped character.
|
|
return;
|
|
}
|
|
|
|
const escapedChar = characterNode.raw.slice(1);
|
|
|
|
if (escapedChar !== String.fromCodePoint(characterNode.value)) {
|
|
// It's a valid escape.
|
|
return;
|
|
}
|
|
let allowedEscapes;
|
|
|
|
if (characterClassStack.length) {
|
|
allowedEscapes =
|
|
unicodeSets ?
|
|
REGEX_CLASSSET_CHARACTER_ESCAPES
|
|
: REGEX_GENERAL_ESCAPES;
|
|
} else {
|
|
allowedEscapes = REGEX_NON_CHARCLASS_ESCAPES;
|
|
}
|
|
if (allowedEscapes.has(escapedChar)) {
|
|
return;
|
|
}
|
|
|
|
const reportedIndex = characterNode.start + 1;
|
|
let disableEscapeBackslashSuggest = false;
|
|
|
|
if (characterClassStack.length) {
|
|
const characterClassNode = characterClassStack[0];
|
|
|
|
if (escapedChar === '^') {
|
|
/*
|
|
* The '^' character is also a special case; it must always be escaped outside of character classes, but
|
|
* it only needs to be escaped in character classes if it's at the beginning of the character class. To
|
|
* account for this, consider it to be a valid escape character outside of character classes, and filter
|
|
* out '^' characters that appear at the start of a character class.
|
|
*/
|
|
if (characterClassNode.start + 1 === characterNode.start) {
|
|
return;
|
|
}
|
|
}
|
|
if (!unicodeSets) {
|
|
if (escapedChar === '-') {
|
|
/*
|
|
* The '-' character is a special case, because it's only valid to escape it if it's in a character
|
|
* class, and is not at either edge of the character class. To account for this, don't consider '-'
|
|
* characters to be valid in general, and filter out '-' characters that appear in the middle of a
|
|
* character class.
|
|
*/
|
|
if (
|
|
characterClassNode.start + 1 !== characterNode.start &&
|
|
characterNode.end !== characterClassNode.end - 1
|
|
) {
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
// unicodeSets mode
|
|
if (REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR.has(escapedChar)) {
|
|
// Escaping is valid if it is a ClassSetReservedDoublePunctuator.
|
|
if (pattern[characterNode.end] === escapedChar) {
|
|
return;
|
|
}
|
|
if (pattern[characterNode.start - 1] === escapedChar) {
|
|
if (escapedChar !== '^') {
|
|
return;
|
|
}
|
|
|
|
// If the previous character is a `negate` caret(`^`), escape to caret is unnecessary.
|
|
|
|
if (!characterClassNode.negate) {
|
|
return;
|
|
}
|
|
const negateCaretIndex = characterClassNode.start + 1;
|
|
|
|
if (negateCaretIndex < characterNode.start - 1) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (
|
|
characterNode.parent.type === 'ClassIntersection' ||
|
|
characterNode.parent.type === 'ClassSubtraction'
|
|
) {
|
|
disableEscapeBackslashSuggest = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
report(
|
|
node,
|
|
reportedIndex,
|
|
escapedChar,
|
|
disableEscapeBackslashSuggest
|
|
);
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks if a node has an escape.
|
|
* @param {ASTNode} node node to check.
|
|
* @returns {void}
|
|
*/
|
|
function check(node) {
|
|
const isTemplateElement = node.type === 'TemplateElement';
|
|
|
|
if (
|
|
isTemplateElement &&
|
|
node.parent &&
|
|
node.parent.parent &&
|
|
node.parent.parent.type === 'TaggedTemplateExpression' &&
|
|
node.parent === node.parent.parent.quasi
|
|
) {
|
|
// Don't report tagged template literals, because the backslash character is accessible to the tag function.
|
|
return;
|
|
}
|
|
|
|
if (typeof node.value === 'string' || isTemplateElement) {
|
|
/*
|
|
* JSXAttribute doesn't have any escape sequence: https://facebook.github.io/jsx/.
|
|
* In addition, backticks are not supported by JSX yet: https://github.com/facebook/jsx/issues/25.
|
|
*/
|
|
if (
|
|
node.parent.type === 'JSXAttribute' ||
|
|
node.parent.type === 'JSXElement' ||
|
|
node.parent.type === 'JSXFragment'
|
|
) {
|
|
return;
|
|
}
|
|
|
|
const value = isTemplateElement ? sourceCode.getText(node) : node.raw;
|
|
const pattern = /\\[^\d]/gu;
|
|
let match;
|
|
|
|
while ((match = pattern.exec(value))) {
|
|
validateString(node, match);
|
|
}
|
|
} else if (node.regex) {
|
|
validateRegExp(node);
|
|
}
|
|
}
|
|
|
|
return {
|
|
Literal: check,
|
|
TemplateElement: check,
|
|
};
|
|
},
|
|
};
|