You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
502 lines
21 KiB
502 lines
21 KiB
/** |
|
* @fileoverview A module that filters reported problems based on `eslint-disable` and `eslint-enable` comments |
|
* @author Teddy Katz |
|
*/ |
|
|
|
"use strict"; |
|
|
|
//------------------------------------------------------------------------------ |
|
// Typedefs |
|
//------------------------------------------------------------------------------ |
|
|
|
/** @typedef {import("../shared/types").LintMessage} LintMessage */ |
|
/** @typedef {import("@eslint/core").Language} Language */ |
|
/** @typedef {import("@eslint/core").Position} Position */ |
|
/** @typedef {import("@eslint/core").RulesConfig} RulesConfig */ |
|
|
|
//------------------------------------------------------------------------------ |
|
// Module Definition |
|
//------------------------------------------------------------------------------ |
|
|
|
const escapeRegExp = require("escape-string-regexp"); |
|
const { |
|
Legacy: { |
|
ConfigOps |
|
} |
|
} = require("@eslint/eslintrc/universal"); |
|
|
|
/** |
|
* Compares the locations of two objects in a source file |
|
* @param {Position} itemA The first object |
|
* @param {Position} itemB The second object |
|
* @returns {number} A value less than 1 if itemA appears before itemB in the source file, greater than 1 if |
|
* itemA appears after itemB in the source file, or 0 if itemA and itemB have the same location. |
|
*/ |
|
function compareLocations(itemA, itemB) { |
|
return itemA.line - itemB.line || itemA.column - itemB.column; |
|
} |
|
|
|
/** |
|
* Groups a set of directives into sub-arrays by their parent comment. |
|
* @param {Iterable<Directive>} directives Unused directives to be removed. |
|
* @returns {Directive[][]} Directives grouped by their parent comment. |
|
*/ |
|
function groupByParentDirective(directives) { |
|
const groups = new Map(); |
|
|
|
for (const directive of directives) { |
|
const { unprocessedDirective: { parentDirective } } = directive; |
|
|
|
if (groups.has(parentDirective)) { |
|
groups.get(parentDirective).push(directive); |
|
} else { |
|
groups.set(parentDirective, [directive]); |
|
} |
|
} |
|
|
|
return [...groups.values()]; |
|
} |
|
|
|
/** |
|
* Creates removal details for a set of directives within the same comment. |
|
* @param {Directive[]} directives Unused directives to be removed. |
|
* @param {{node: Token, value: string}} parentDirective Data about the backing directive. |
|
* @param {SourceCode} sourceCode The source code object for the file being linted. |
|
* @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems. |
|
*/ |
|
function createIndividualDirectivesRemoval(directives, parentDirective, sourceCode) { |
|
|
|
/* |
|
* Get the list of the rules text without any surrounding whitespace. In order to preserve the original |
|
* formatting, we don't want to change that whitespace. |
|
* |
|
* // eslint-disable-line rule-one , rule-two , rule-three -- comment |
|
* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |
|
*/ |
|
const listText = parentDirective.value.trim(); |
|
|
|
// Calculate where it starts in the source code text |
|
const listStart = sourceCode.text.indexOf(listText, sourceCode.getRange(parentDirective.node)[0]); |
|
|
|
/* |
|
* We can assume that `listText` contains multiple elements. |
|
* Otherwise, this function wouldn't be called - if there is |
|
* only one rule in the list, then the whole comment must be removed. |
|
*/ |
|
|
|
return directives.map(directive => { |
|
const { ruleId } = directive; |
|
|
|
const regex = new RegExp(String.raw`(?:^|\s*,\s*)(?<quote>['"]?)${escapeRegExp(ruleId)}\k<quote>(?:\s*,\s*|$)`, "u"); |
|
const match = regex.exec(listText); |
|
const matchedText = match[0]; |
|
const matchStart = listStart + match.index; |
|
const matchEnd = matchStart + matchedText.length; |
|
|
|
const firstIndexOfComma = matchedText.indexOf(","); |
|
const lastIndexOfComma = matchedText.lastIndexOf(","); |
|
|
|
let removalStart, removalEnd; |
|
|
|
if (firstIndexOfComma !== lastIndexOfComma) { |
|
|
|
/* |
|
* Since there are two commas, this must one of the elements in the middle of the list. |
|
* Matched range starts where the previous rule name ends, and ends where the next rule name starts. |
|
* |
|
* // eslint-disable-line rule-one , rule-two , rule-three -- comment |
|
* ^^^^^^^^^^^^^^ |
|
* |
|
* We want to remove only the content between the two commas, and also one of the commas. |
|
* |
|
* // eslint-disable-line rule-one , rule-two , rule-three -- comment |
|
* ^^^^^^^^^^^ |
|
*/ |
|
removalStart = matchStart + firstIndexOfComma; |
|
removalEnd = matchStart + lastIndexOfComma; |
|
|
|
} else { |
|
|
|
/* |
|
* This is either the first element or the last element. |
|
* |
|
* If this is the first element, matched range starts where the first rule name starts |
|
* and ends where the second rule name starts. This is exactly the range we want |
|
* to remove so that the second rule name will start where the first one was starting |
|
* and thus preserve the original formatting. |
|
* |
|
* // eslint-disable-line rule-one , rule-two , rule-three -- comment |
|
* ^^^^^^^^^^^ |
|
* |
|
* Similarly, if this is the last element, we've already matched the range we want to |
|
* remove. The previous rule name will end where the last one was ending, relative |
|
* to the content on the right side. |
|
* |
|
* // eslint-disable-line rule-one , rule-two , rule-three -- comment |
|
* ^^^^^^^^^^^^^ |
|
*/ |
|
removalStart = matchStart; |
|
removalEnd = matchEnd; |
|
} |
|
|
|
return { |
|
description: `'${ruleId}'`, |
|
fix: { |
|
range: [ |
|
removalStart, |
|
removalEnd |
|
], |
|
text: "" |
|
}, |
|
unprocessedDirective: directive.unprocessedDirective |
|
}; |
|
}); |
|
} |
|
|
|
/** |
|
* Creates a description of deleting an entire unused disable directive. |
|
* @param {Directive[]} directives Unused directives to be removed. |
|
* @param {Token} node The backing Comment token. |
|
* @param {SourceCode} sourceCode The source code object for the file being linted. |
|
* @returns {{ description, fix, unprocessedDirective }} Details for later creation of an output problem. |
|
*/ |
|
function createDirectiveRemoval(directives, node, sourceCode) { |
|
const range = sourceCode.getRange(node); |
|
const ruleIds = directives.filter(directive => directive.ruleId).map(directive => `'${directive.ruleId}'`); |
|
|
|
return { |
|
description: ruleIds.length <= 2 |
|
? ruleIds.join(" or ") |
|
: `${ruleIds.slice(0, ruleIds.length - 1).join(", ")}, or ${ruleIds.at(-1)}`, |
|
fix: { |
|
range, |
|
text: " " |
|
}, |
|
unprocessedDirective: directives[0].unprocessedDirective |
|
}; |
|
} |
|
|
|
/** |
|
* Parses details from directives to create output Problems. |
|
* @param {Iterable<Directive>} allDirectives Unused directives to be removed. |
|
* @param {SourceCode} sourceCode The source code object for the file being linted. |
|
* @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems. |
|
*/ |
|
function processUnusedDirectives(allDirectives, sourceCode) { |
|
const directiveGroups = groupByParentDirective(allDirectives); |
|
|
|
return directiveGroups.flatMap( |
|
directives => { |
|
const { parentDirective } = directives[0].unprocessedDirective; |
|
const remainingRuleIds = new Set(parentDirective.ruleIds); |
|
|
|
for (const directive of directives) { |
|
remainingRuleIds.delete(directive.ruleId); |
|
} |
|
|
|
return remainingRuleIds.size |
|
? createIndividualDirectivesRemoval(directives, parentDirective, sourceCode) |
|
: [createDirectiveRemoval(directives, parentDirective.node, sourceCode)]; |
|
} |
|
); |
|
} |
|
|
|
/** |
|
* Collect eslint-enable comments that are removing suppressions by eslint-disable comments. |
|
* @param {Directive[]} directives The directives to check. |
|
* @returns {Set<Directive>} The used eslint-enable comments |
|
*/ |
|
function collectUsedEnableDirectives(directives) { |
|
|
|
/** |
|
* A Map of `eslint-enable` keyed by ruleIds that may be marked as used. |
|
* If `eslint-enable` does not have a ruleId, the key will be `null`. |
|
* @type {Map<string|null, Directive>} |
|
*/ |
|
const enabledRules = new Map(); |
|
|
|
/** |
|
* A Set of `eslint-enable` marked as used. |
|
* It is also the return value of `collectUsedEnableDirectives` function. |
|
* @type {Set<Directive>} |
|
*/ |
|
const usedEnableDirectives = new Set(); |
|
|
|
/* |
|
* Checks the directives backwards to see if the encountered `eslint-enable` is used by the previous `eslint-disable`, |
|
* and if so, stores the `eslint-enable` in `usedEnableDirectives`. |
|
*/ |
|
for (let index = directives.length - 1; index >= 0; index--) { |
|
const directive = directives[index]; |
|
|
|
if (directive.type === "disable") { |
|
if (enabledRules.size === 0) { |
|
continue; |
|
} |
|
if (directive.ruleId === null) { |
|
|
|
// If encounter `eslint-disable` without ruleId, |
|
// mark all `eslint-enable` currently held in enabledRules as used. |
|
// e.g. |
|
// /* eslint-disable */ <- current directive |
|
// /* eslint-enable rule-id1 */ <- used |
|
// /* eslint-enable rule-id2 */ <- used |
|
// /* eslint-enable */ <- used |
|
for (const enableDirective of enabledRules.values()) { |
|
usedEnableDirectives.add(enableDirective); |
|
} |
|
enabledRules.clear(); |
|
} else { |
|
const enableDirective = enabledRules.get(directive.ruleId); |
|
|
|
if (enableDirective) { |
|
|
|
// If encounter `eslint-disable` with ruleId, and there is an `eslint-enable` with the same ruleId in enabledRules, |
|
// mark `eslint-enable` with ruleId as used. |
|
// e.g. |
|
// /* eslint-disable rule-id */ <- current directive |
|
// /* eslint-enable rule-id */ <- used |
|
usedEnableDirectives.add(enableDirective); |
|
} else { |
|
const enabledDirectiveWithoutRuleId = enabledRules.get(null); |
|
|
|
if (enabledDirectiveWithoutRuleId) { |
|
|
|
// If encounter `eslint-disable` with ruleId, and there is no `eslint-enable` with the same ruleId in enabledRules, |
|
// mark `eslint-enable` without ruleId as used. |
|
// e.g. |
|
// /* eslint-disable rule-id */ <- current directive |
|
// /* eslint-enable */ <- used |
|
usedEnableDirectives.add(enabledDirectiveWithoutRuleId); |
|
} |
|
} |
|
} |
|
} else if (directive.type === "enable") { |
|
if (directive.ruleId === null) { |
|
|
|
// If encounter `eslint-enable` without ruleId, the `eslint-enable` that follows it are unused. |
|
// So clear enabledRules. |
|
// e.g. |
|
// /* eslint-enable */ <- current directive |
|
// /* eslint-enable rule-id *// <- unused |
|
// /* eslint-enable */ <- unused |
|
enabledRules.clear(); |
|
enabledRules.set(null, directive); |
|
} else { |
|
enabledRules.set(directive.ruleId, directive); |
|
} |
|
} |
|
} |
|
return usedEnableDirectives; |
|
} |
|
|
|
/** |
|
* This is the same as the exported function, except that it |
|
* doesn't handle disable-line and disable-next-line directives, and it always reports unused |
|
* disable directives. |
|
* @param {Object} options options for applying directives. This is the same as the options |
|
* for the exported function, except that `reportUnusedDisableDirectives` is not supported |
|
* (this function always reports unused disable directives). |
|
* @returns {{problems: LintMessage[], unusedDirectives: LintMessage[]}} An object with a list |
|
* of problems (including suppressed ones) and unused eslint-disable directives |
|
*/ |
|
function applyDirectives(options) { |
|
const problems = []; |
|
const usedDisableDirectives = new Set(); |
|
const { sourceCode } = options; |
|
|
|
for (const problem of options.problems) { |
|
let disableDirectivesForProblem = []; |
|
let nextDirectiveIndex = 0; |
|
|
|
while ( |
|
nextDirectiveIndex < options.directives.length && |
|
compareLocations(options.directives[nextDirectiveIndex], problem) <= 0 |
|
) { |
|
const directive = options.directives[nextDirectiveIndex++]; |
|
|
|
if (directive.ruleId === null || directive.ruleId === problem.ruleId) { |
|
switch (directive.type) { |
|
case "disable": |
|
disableDirectivesForProblem.push(directive); |
|
break; |
|
|
|
case "enable": |
|
disableDirectivesForProblem = []; |
|
break; |
|
|
|
// no default |
|
} |
|
} |
|
} |
|
|
|
if (disableDirectivesForProblem.length > 0) { |
|
const suppressions = disableDirectivesForProblem.map(directive => ({ |
|
kind: "directive", |
|
justification: directive.unprocessedDirective.justification |
|
})); |
|
|
|
if (problem.suppressions) { |
|
problem.suppressions = problem.suppressions.concat(suppressions); |
|
} else { |
|
problem.suppressions = suppressions; |
|
usedDisableDirectives.add(disableDirectivesForProblem.at(-1)); |
|
} |
|
} |
|
|
|
problems.push(problem); |
|
} |
|
|
|
const unusedDisableDirectivesToReport = options.directives |
|
.filter(directive => directive.type === "disable" && !usedDisableDirectives.has(directive) && !options.rulesToIgnore.has(directive.ruleId)); |
|
|
|
|
|
const unusedEnableDirectivesToReport = new Set( |
|
options.directives.filter(directive => directive.unprocessedDirective.type === "enable" && !options.rulesToIgnore.has(directive.ruleId)) |
|
); |
|
|
|
/* |
|
* If directives has the eslint-enable directive, |
|
* check whether the eslint-enable comment is used. |
|
*/ |
|
if (unusedEnableDirectivesToReport.size > 0) { |
|
for (const directive of collectUsedEnableDirectives(options.directives)) { |
|
unusedEnableDirectivesToReport.delete(directive); |
|
} |
|
} |
|
|
|
const processed = processUnusedDirectives(unusedDisableDirectivesToReport, sourceCode) |
|
.concat(processUnusedDirectives(unusedEnableDirectivesToReport, sourceCode)); |
|
const columnOffset = options.language.columnStart === 1 ? 0 : 1; |
|
const lineOffset = options.language.lineStart === 1 ? 0 : 1; |
|
|
|
const unusedDirectives = processed |
|
.map(({ description, fix, unprocessedDirective }) => { |
|
const { parentDirective, type, line, column } = unprocessedDirective; |
|
|
|
let message; |
|
|
|
if (type === "enable") { |
|
message = description |
|
? `Unused eslint-enable directive (no matching eslint-disable directives were found for ${description}).` |
|
: "Unused eslint-enable directive (no matching eslint-disable directives were found)."; |
|
} else { |
|
message = description |
|
? `Unused eslint-disable directive (no problems were reported from ${description}).` |
|
: "Unused eslint-disable directive (no problems were reported)."; |
|
} |
|
|
|
const loc = sourceCode.getLoc(parentDirective.node); |
|
|
|
return { |
|
ruleId: null, |
|
message, |
|
line: type === "disable-next-line" ? loc.start.line + lineOffset : line, |
|
column: type === "disable-next-line" ? loc.start.column + columnOffset : column, |
|
severity: options.reportUnusedDisableDirectives === "warn" ? 1 : 2, |
|
nodeType: null, |
|
...options.disableFixes ? {} : { fix } |
|
}; |
|
}); |
|
|
|
return { problems, unusedDirectives }; |
|
} |
|
|
|
/** |
|
* Given a list of directive comments (i.e. metadata about eslint-disable and eslint-enable comments) and a list |
|
* of reported problems, adds the suppression information to the problems. |
|
* @param {Object} options Information about directives and problems |
|
* @param {Language} options.language The language being linted. |
|
* @param {SourceCode} options.sourceCode The source code object for the file being linted. |
|
* @param {{ |
|
* type: ("disable"|"enable"|"disable-line"|"disable-next-line"), |
|
* ruleId: (string|null), |
|
* line: number, |
|
* column: number, |
|
* justification: string |
|
* }} options.directives Directive comments found in the file, with one-based columns. |
|
* Two directive comments can only have the same location if they also have the same type (e.g. a single eslint-disable |
|
* comment for two different rules is represented as two directives). |
|
* @param {{ruleId: (string|null), line: number, column: number}[]} options.problems |
|
* A list of problems reported by rules, sorted by increasing location in the file, with one-based columns. |
|
* @param {"off" | "warn" | "error"} options.reportUnusedDisableDirectives If `"warn"` or `"error"`, adds additional problems for unused directives |
|
* @param {RulesConfig} options.configuredRules The rules configuration. |
|
* @param {Function} options.ruleFilter A predicate function to filter which rules should be executed. |
|
* @param {boolean} options.disableFixes If true, it doesn't make `fix` properties. |
|
* @returns {{ruleId: (string|null), line: number, column: number, suppressions?: {kind: string, justification: string}}[]} |
|
* An object with a list of reported problems, the suppressed of which contain the suppression information. |
|
*/ |
|
module.exports = ({ language, sourceCode, directives, disableFixes, problems, configuredRules, ruleFilter, reportUnusedDisableDirectives = "off" }) => { |
|
const blockDirectives = directives |
|
.filter(directive => directive.type === "disable" || directive.type === "enable") |
|
.map(directive => Object.assign({}, directive, { unprocessedDirective: directive })) |
|
.sort(compareLocations); |
|
|
|
const lineDirectives = directives.flatMap(directive => { |
|
switch (directive.type) { |
|
case "disable": |
|
case "enable": |
|
return []; |
|
|
|
case "disable-line": |
|
return [ |
|
{ type: "disable", line: directive.line, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive }, |
|
{ type: "enable", line: directive.line + 1, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive } |
|
]; |
|
|
|
case "disable-next-line": |
|
return [ |
|
{ type: "disable", line: directive.line + 1, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive }, |
|
{ type: "enable", line: directive.line + 2, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive } |
|
]; |
|
|
|
default: |
|
throw new TypeError(`Unrecognized directive type '${directive.type}'`); |
|
} |
|
}).sort(compareLocations); |
|
|
|
// This determines a list of rules that are not being run by the given ruleFilter, if present. |
|
const rulesToIgnore = configuredRules && ruleFilter |
|
? new Set(Object.keys(configuredRules).filter(ruleId => { |
|
const severity = ConfigOps.getRuleSeverity(configuredRules[ruleId]); |
|
|
|
// Ignore for disabled rules. |
|
if (severity === 0) { |
|
return false; |
|
} |
|
|
|
return !ruleFilter({ severity, ruleId }); |
|
})) |
|
: new Set(); |
|
|
|
// If no ruleId is supplied that means this directive is applied to all rules, so we can't determine if it's unused if any rules are filtered out. |
|
if (rulesToIgnore.size > 0) { |
|
rulesToIgnore.add(null); |
|
} |
|
|
|
const blockDirectivesResult = applyDirectives({ |
|
language, |
|
sourceCode, |
|
problems, |
|
directives: blockDirectives, |
|
disableFixes, |
|
reportUnusedDisableDirectives, |
|
rulesToIgnore |
|
}); |
|
const lineDirectivesResult = applyDirectives({ |
|
language, |
|
sourceCode, |
|
problems: blockDirectivesResult.problems, |
|
directives: lineDirectives, |
|
disableFixes, |
|
reportUnusedDisableDirectives, |
|
rulesToIgnore |
|
}); |
|
|
|
return reportUnusedDisableDirectives !== "off" |
|
? lineDirectivesResult.problems |
|
.concat(blockDirectivesResult.unusedDirectives) |
|
.concat(lineDirectivesResult.unusedDirectives) |
|
.sort(compareLocations) |
|
: lineDirectivesResult.problems; |
|
};
|
|
|