build: update npm install command to use --legacy-peer-deps
This change modifies the build scripts to use --legacy-peer-deps flag when installing npm dependencies to resolve potential peer dependency conflicts during the build process. The change is applied to both bash (build.sh) and batch (build.bat) build scripts.
This commit is contained in:
Luiz Costa
+373
-411
@@ -16,461 +16,423 @@ const astUtils = require("./utils/ast-utils");
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Formatting rules are being moved out of ESLint core.",
|
||||
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
|
||||
deprecatedSince: "8.53.0",
|
||||
availableUntil: "11.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"ESLint Stylistic now maintains deprecated stylistic core rules.",
|
||||
url: "https://eslint.style/guide/migration",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin",
|
||||
url: "https://eslint.style",
|
||||
},
|
||||
rule: {
|
||||
name: "semi",
|
||||
url: "https://eslint.style/rules/semi",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "layout",
|
||||
meta: {
|
||||
deprecated: true,
|
||||
replacedBy: [],
|
||||
type: "layout",
|
||||
|
||||
docs: {
|
||||
description: "Require or disallow semicolons instead of ASI",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/semi",
|
||||
},
|
||||
docs: {
|
||||
description: "Require or disallow semicolons instead of ASI",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/semi"
|
||||
},
|
||||
|
||||
fixable: "code",
|
||||
fixable: "code",
|
||||
|
||||
schema: {
|
||||
anyOf: [
|
||||
{
|
||||
type: "array",
|
||||
items: [
|
||||
{
|
||||
enum: ["never"],
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
beforeStatementContinuationChars: {
|
||||
enum: ["always", "any", "never"],
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
minItems: 0,
|
||||
maxItems: 2,
|
||||
},
|
||||
{
|
||||
type: "array",
|
||||
items: [
|
||||
{
|
||||
enum: ["always"],
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
omitLastInOneLineBlock: { type: "boolean" },
|
||||
omitLastInOneLineClassBody: { type: "boolean" },
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
minItems: 0,
|
||||
maxItems: 2,
|
||||
},
|
||||
],
|
||||
},
|
||||
schema: {
|
||||
anyOf: [
|
||||
{
|
||||
type: "array",
|
||||
items: [
|
||||
{
|
||||
enum: ["never"]
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
beforeStatementContinuationChars: {
|
||||
enum: ["always", "any", "never"]
|
||||
}
|
||||
},
|
||||
additionalProperties: false
|
||||
}
|
||||
],
|
||||
minItems: 0,
|
||||
maxItems: 2
|
||||
},
|
||||
{
|
||||
type: "array",
|
||||
items: [
|
||||
{
|
||||
enum: ["always"]
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
omitLastInOneLineBlock: { type: "boolean" },
|
||||
omitLastInOneLineClassBody: { type: "boolean" }
|
||||
},
|
||||
additionalProperties: false
|
||||
}
|
||||
],
|
||||
minItems: 0,
|
||||
maxItems: 2
|
||||
}
|
||||
]
|
||||
},
|
||||
|
||||
messages: {
|
||||
missingSemi: "Missing semicolon.",
|
||||
extraSemi: "Extra semicolon.",
|
||||
},
|
||||
},
|
||||
messages: {
|
||||
missingSemi: "Missing semicolon.",
|
||||
extraSemi: "Extra semicolon."
|
||||
}
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const OPT_OUT_PATTERN = /^[-[(/+`]/u; // One of [(/+-`
|
||||
const unsafeClassFieldNames = new Set(["get", "set", "static"]);
|
||||
const unsafeClassFieldFollowers = new Set(["*", "in", "instanceof"]);
|
||||
const options = context.options[1];
|
||||
const never = context.options[0] === "never";
|
||||
const exceptOneLine = Boolean(
|
||||
options && options.omitLastInOneLineBlock,
|
||||
);
|
||||
const exceptOneLineClassBody = Boolean(
|
||||
options && options.omitLastInOneLineClassBody,
|
||||
);
|
||||
const beforeStatementContinuationChars =
|
||||
(options && options.beforeStatementContinuationChars) || "any";
|
||||
const sourceCode = context.sourceCode;
|
||||
create(context) {
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//--------------------------------------------------------------------------
|
||||
const OPT_OUT_PATTERN = /^[-[(/+`]/u; // One of [(/+-`
|
||||
const unsafeClassFieldNames = new Set(["get", "set", "static"]);
|
||||
const unsafeClassFieldFollowers = new Set(["*", "in", "instanceof"]);
|
||||
const options = context.options[1];
|
||||
const never = context.options[0] === "never";
|
||||
const exceptOneLine = Boolean(options && options.omitLastInOneLineBlock);
|
||||
const exceptOneLineClassBody = Boolean(options && options.omitLastInOneLineClassBody);
|
||||
const beforeStatementContinuationChars = options && options.beforeStatementContinuationChars || "any";
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Reports a semicolon error with appropriate location and message.
|
||||
* @param {ASTNode} node The node with an extra or missing semicolon.
|
||||
* @param {boolean} missing True if the semicolon is missing.
|
||||
* @returns {void}
|
||||
*/
|
||||
function report(node, missing) {
|
||||
const lastToken = sourceCode.getLastToken(node);
|
||||
let messageId, fix, loc;
|
||||
//--------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
if (!missing) {
|
||||
messageId = "missingSemi";
|
||||
loc = {
|
||||
start: lastToken.loc.end,
|
||||
end: astUtils.getNextLocation(
|
||||
sourceCode,
|
||||
lastToken.loc.end,
|
||||
),
|
||||
};
|
||||
fix = function (fixer) {
|
||||
return fixer.insertTextAfter(lastToken, ";");
|
||||
};
|
||||
} else {
|
||||
messageId = "extraSemi";
|
||||
loc = lastToken.loc;
|
||||
fix = function (fixer) {
|
||||
/*
|
||||
* Expand the replacement range to include the surrounding
|
||||
* tokens to avoid conflicting with no-extra-semi.
|
||||
* https://github.com/eslint/eslint/issues/7928
|
||||
*/
|
||||
return new FixTracker(fixer, sourceCode)
|
||||
.retainSurroundingTokens(lastToken)
|
||||
.remove(lastToken);
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Reports a semicolon error with appropriate location and message.
|
||||
* @param {ASTNode} node The node with an extra or missing semicolon.
|
||||
* @param {boolean} missing True if the semicolon is missing.
|
||||
* @returns {void}
|
||||
*/
|
||||
function report(node, missing) {
|
||||
const lastToken = sourceCode.getLastToken(node);
|
||||
let messageId,
|
||||
fix,
|
||||
loc;
|
||||
|
||||
context.report({
|
||||
node,
|
||||
loc,
|
||||
messageId,
|
||||
fix,
|
||||
});
|
||||
}
|
||||
if (!missing) {
|
||||
messageId = "missingSemi";
|
||||
loc = {
|
||||
start: lastToken.loc.end,
|
||||
end: astUtils.getNextLocation(sourceCode, lastToken.loc.end)
|
||||
};
|
||||
fix = function(fixer) {
|
||||
return fixer.insertTextAfter(lastToken, ";");
|
||||
};
|
||||
} else {
|
||||
messageId = "extraSemi";
|
||||
loc = lastToken.loc;
|
||||
fix = function(fixer) {
|
||||
|
||||
/**
|
||||
* Check whether a given semicolon token is redundant.
|
||||
* @param {Token} semiToken A semicolon token to check.
|
||||
* @returns {boolean} `true` if the next token is `;` or `}`.
|
||||
*/
|
||||
function isRedundantSemi(semiToken) {
|
||||
const nextToken = sourceCode.getTokenAfter(semiToken);
|
||||
/*
|
||||
* Expand the replacement range to include the surrounding
|
||||
* tokens to avoid conflicting with no-extra-semi.
|
||||
* https://github.com/eslint/eslint/issues/7928
|
||||
*/
|
||||
return new FixTracker(fixer, sourceCode)
|
||||
.retainSurroundingTokens(lastToken)
|
||||
.remove(lastToken);
|
||||
};
|
||||
}
|
||||
|
||||
return (
|
||||
!nextToken ||
|
||||
astUtils.isClosingBraceToken(nextToken) ||
|
||||
astUtils.isSemicolonToken(nextToken)
|
||||
);
|
||||
}
|
||||
context.report({
|
||||
node,
|
||||
loc,
|
||||
messageId,
|
||||
fix
|
||||
});
|
||||
|
||||
/**
|
||||
* Check whether a given token is the closing brace of an arrow function.
|
||||
* @param {Token} lastToken A token to check.
|
||||
* @returns {boolean} `true` if the token is the closing brace of an arrow function.
|
||||
*/
|
||||
function isEndOfArrowBlock(lastToken) {
|
||||
if (!astUtils.isClosingBraceToken(lastToken)) {
|
||||
return false;
|
||||
}
|
||||
const node = sourceCode.getNodeByRangeIndex(lastToken.range[0]);
|
||||
}
|
||||
|
||||
return (
|
||||
node.type === "BlockStatement" &&
|
||||
node.parent.type === "ArrowFunctionExpression"
|
||||
);
|
||||
}
|
||||
/**
|
||||
* Check whether a given semicolon token is redundant.
|
||||
* @param {Token} semiToken A semicolon token to check.
|
||||
* @returns {boolean} `true` if the next token is `;` or `}`.
|
||||
*/
|
||||
function isRedundantSemi(semiToken) {
|
||||
const nextToken = sourceCode.getTokenAfter(semiToken);
|
||||
|
||||
/**
|
||||
* Checks if a given PropertyDefinition node followed by a semicolon
|
||||
* can safely remove that semicolon. It is not to safe to remove if
|
||||
* the class field name is "get", "set", or "static", or if
|
||||
* followed by a generator method.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} `true` if the node cannot have the semicolon
|
||||
* removed.
|
||||
*/
|
||||
function maybeClassFieldAsiHazard(node) {
|
||||
if (node.type !== "PropertyDefinition") {
|
||||
return false;
|
||||
}
|
||||
return (
|
||||
!nextToken ||
|
||||
astUtils.isClosingBraceToken(nextToken) ||
|
||||
astUtils.isSemicolonToken(nextToken)
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* Computed property names and non-identifiers are always safe
|
||||
* as they can be distinguished from keywords easily.
|
||||
*/
|
||||
const needsNameCheck =
|
||||
!node.computed && node.key.type === "Identifier";
|
||||
/**
|
||||
* Check whether a given token is the closing brace of an arrow function.
|
||||
* @param {Token} lastToken A token to check.
|
||||
* @returns {boolean} `true` if the token is the closing brace of an arrow function.
|
||||
*/
|
||||
function isEndOfArrowBlock(lastToken) {
|
||||
if (!astUtils.isClosingBraceToken(lastToken)) {
|
||||
return false;
|
||||
}
|
||||
const node = sourceCode.getNodeByRangeIndex(lastToken.range[0]);
|
||||
|
||||
/*
|
||||
* Certain names are problematic unless they also have a
|
||||
* a way to distinguish between keywords and property
|
||||
* names.
|
||||
*/
|
||||
if (needsNameCheck && unsafeClassFieldNames.has(node.key.name)) {
|
||||
/*
|
||||
* Special case: If the field name is `static`,
|
||||
* it is only valid if the field is marked as static,
|
||||
* so "static static" is okay but "static" is not.
|
||||
*/
|
||||
const isStaticStatic =
|
||||
node.static && node.key.name === "static";
|
||||
return (
|
||||
node.type === "BlockStatement" &&
|
||||
node.parent.type === "ArrowFunctionExpression"
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* For other unsafe names, we only care if there is no
|
||||
* initializer. No initializer = hazard.
|
||||
*/
|
||||
if (!isStaticStatic && !node.value) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Checks if a given PropertyDefinition node followed by a semicolon
|
||||
* can safely remove that semicolon. It is not to safe to remove if
|
||||
* the class field name is "get", "set", or "static", or if
|
||||
* followed by a generator method.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} `true` if the node cannot have the semicolon
|
||||
* removed.
|
||||
*/
|
||||
function maybeClassFieldAsiHazard(node) {
|
||||
|
||||
const followingToken = sourceCode.getTokenAfter(node);
|
||||
if (node.type !== "PropertyDefinition") {
|
||||
return false;
|
||||
}
|
||||
|
||||
return unsafeClassFieldFollowers.has(followingToken.value);
|
||||
}
|
||||
/*
|
||||
* Computed property names and non-identifiers are always safe
|
||||
* as they can be distinguished from keywords easily.
|
||||
*/
|
||||
const needsNameCheck = !node.computed && node.key.type === "Identifier";
|
||||
|
||||
/**
|
||||
* Check whether a given node is on the same line with the next token.
|
||||
* @param {Node} node A statement node to check.
|
||||
* @returns {boolean} `true` if the node is on the same line with the next token.
|
||||
*/
|
||||
function isOnSameLineWithNextToken(node) {
|
||||
const prevToken = sourceCode.getLastToken(node, 1);
|
||||
const nextToken = sourceCode.getTokenAfter(node);
|
||||
/*
|
||||
* Certain names are problematic unless they also have a
|
||||
* a way to distinguish between keywords and property
|
||||
* names.
|
||||
*/
|
||||
if (needsNameCheck && unsafeClassFieldNames.has(node.key.name)) {
|
||||
|
||||
return (
|
||||
!!nextToken && astUtils.isTokenOnSameLine(prevToken, nextToken)
|
||||
);
|
||||
}
|
||||
/*
|
||||
* Special case: If the field name is `static`,
|
||||
* it is only valid if the field is marked as static,
|
||||
* so "static static" is okay but "static" is not.
|
||||
*/
|
||||
const isStaticStatic = node.static && node.key.name === "static";
|
||||
|
||||
/**
|
||||
* Check whether a given node can connect the next line if the next line is unreliable.
|
||||
* @param {Node} node A statement node to check.
|
||||
* @returns {boolean} `true` if the node can connect the next line.
|
||||
*/
|
||||
function maybeAsiHazardAfter(node) {
|
||||
const t = node.type;
|
||||
/*
|
||||
* For other unsafe names, we only care if there is no
|
||||
* initializer. No initializer = hazard.
|
||||
*/
|
||||
if (!isStaticStatic && !node.value) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
t === "DoWhileStatement" ||
|
||||
t === "BreakStatement" ||
|
||||
t === "ContinueStatement" ||
|
||||
t === "DebuggerStatement" ||
|
||||
t === "ImportDeclaration" ||
|
||||
t === "ExportAllDeclaration"
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
if (t === "ReturnStatement") {
|
||||
return Boolean(node.argument);
|
||||
}
|
||||
if (t === "ExportNamedDeclaration") {
|
||||
return Boolean(node.declaration);
|
||||
}
|
||||
if (isEndOfArrowBlock(sourceCode.getLastToken(node, 1))) {
|
||||
return false;
|
||||
}
|
||||
const followingToken = sourceCode.getTokenAfter(node);
|
||||
|
||||
return true;
|
||||
}
|
||||
return unsafeClassFieldFollowers.has(followingToken.value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether a given token can connect the previous statement.
|
||||
* @param {Token} token A token to check.
|
||||
* @returns {boolean} `true` if the token is one of `[`, `(`, `/`, `+`, `-`, ```, `++`, and `--`.
|
||||
*/
|
||||
function maybeAsiHazardBefore(token) {
|
||||
return (
|
||||
Boolean(token) &&
|
||||
OPT_OUT_PATTERN.test(token.value) &&
|
||||
token.value !== "++" &&
|
||||
token.value !== "--"
|
||||
);
|
||||
}
|
||||
/**
|
||||
* Check whether a given node is on the same line with the next token.
|
||||
* @param {Node} node A statement node to check.
|
||||
* @returns {boolean} `true` if the node is on the same line with the next token.
|
||||
*/
|
||||
function isOnSameLineWithNextToken(node) {
|
||||
const prevToken = sourceCode.getLastToken(node, 1);
|
||||
const nextToken = sourceCode.getTokenAfter(node);
|
||||
|
||||
/**
|
||||
* Check if the semicolon of a given node is unnecessary, only true if:
|
||||
* - next token is a valid statement divider (`;` or `}`).
|
||||
* - next token is on a new line and the node is not connectable to the new line.
|
||||
* @param {Node} node A statement node to check.
|
||||
* @returns {boolean} whether the semicolon is unnecessary.
|
||||
*/
|
||||
function canRemoveSemicolon(node) {
|
||||
if (isRedundantSemi(sourceCode.getLastToken(node))) {
|
||||
return true; // `;;` or `;}`
|
||||
}
|
||||
if (maybeClassFieldAsiHazard(node)) {
|
||||
return false;
|
||||
}
|
||||
if (isOnSameLineWithNextToken(node)) {
|
||||
return false; // One liner.
|
||||
}
|
||||
return !!nextToken && astUtils.isTokenOnSameLine(prevToken, nextToken);
|
||||
}
|
||||
|
||||
// continuation characters should not apply to class fields
|
||||
if (
|
||||
node.type !== "PropertyDefinition" &&
|
||||
beforeStatementContinuationChars === "never" &&
|
||||
!maybeAsiHazardAfter(node)
|
||||
) {
|
||||
return true; // ASI works. This statement doesn't connect to the next.
|
||||
}
|
||||
if (!maybeAsiHazardBefore(sourceCode.getTokenAfter(node))) {
|
||||
return true; // ASI works. The next token doesn't connect to this statement.
|
||||
}
|
||||
/**
|
||||
* Check whether a given node can connect the next line if the next line is unreliable.
|
||||
* @param {Node} node A statement node to check.
|
||||
* @returns {boolean} `true` if the node can connect the next line.
|
||||
*/
|
||||
function maybeAsiHazardAfter(node) {
|
||||
const t = node.type;
|
||||
|
||||
return false;
|
||||
}
|
||||
if (t === "DoWhileStatement" ||
|
||||
t === "BreakStatement" ||
|
||||
t === "ContinueStatement" ||
|
||||
t === "DebuggerStatement" ||
|
||||
t === "ImportDeclaration" ||
|
||||
t === "ExportAllDeclaration"
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
if (t === "ReturnStatement") {
|
||||
return Boolean(node.argument);
|
||||
}
|
||||
if (t === "ExportNamedDeclaration") {
|
||||
return Boolean(node.declaration);
|
||||
}
|
||||
if (isEndOfArrowBlock(sourceCode.getLastToken(node, 1))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks a node to see if it's the last item in a one-liner block.
|
||||
* Block is any `BlockStatement` or `StaticBlock` node. Block is a one-liner if its
|
||||
* braces (and consequently everything between them) are on the same line.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} whether the node is the last item in a one-liner block.
|
||||
*/
|
||||
function isLastInOneLinerBlock(node) {
|
||||
const parent = node.parent;
|
||||
const nextToken = sourceCode.getTokenAfter(node);
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!nextToken || nextToken.value !== "}") {
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* Check whether a given token can connect the previous statement.
|
||||
* @param {Token} token A token to check.
|
||||
* @returns {boolean} `true` if the token is one of `[`, `(`, `/`, `+`, `-`, ```, `++`, and `--`.
|
||||
*/
|
||||
function maybeAsiHazardBefore(token) {
|
||||
return (
|
||||
Boolean(token) &&
|
||||
OPT_OUT_PATTERN.test(token.value) &&
|
||||
token.value !== "++" &&
|
||||
token.value !== "--"
|
||||
);
|
||||
}
|
||||
|
||||
if (parent.type === "BlockStatement") {
|
||||
return parent.loc.start.line === parent.loc.end.line;
|
||||
}
|
||||
/**
|
||||
* Check if the semicolon of a given node is unnecessary, only true if:
|
||||
* - next token is a valid statement divider (`;` or `}`).
|
||||
* - next token is on a new line and the node is not connectable to the new line.
|
||||
* @param {Node} node A statement node to check.
|
||||
* @returns {boolean} whether the semicolon is unnecessary.
|
||||
*/
|
||||
function canRemoveSemicolon(node) {
|
||||
if (isRedundantSemi(sourceCode.getLastToken(node))) {
|
||||
return true; // `;;` or `;}`
|
||||
}
|
||||
if (maybeClassFieldAsiHazard(node)) {
|
||||
return false;
|
||||
}
|
||||
if (isOnSameLineWithNextToken(node)) {
|
||||
return false; // One liner.
|
||||
}
|
||||
|
||||
if (parent.type === "StaticBlock") {
|
||||
const openingBrace = sourceCode.getFirstToken(parent, {
|
||||
skip: 1,
|
||||
}); // skip the `static` token
|
||||
// continuation characters should not apply to class fields
|
||||
if (
|
||||
node.type !== "PropertyDefinition" &&
|
||||
beforeStatementContinuationChars === "never" &&
|
||||
!maybeAsiHazardAfter(node)
|
||||
) {
|
||||
return true; // ASI works. This statement doesn't connect to the next.
|
||||
}
|
||||
if (!maybeAsiHazardBefore(sourceCode.getTokenAfter(node))) {
|
||||
return true; // ASI works. The next token doesn't connect to this statement.
|
||||
}
|
||||
|
||||
return openingBrace.loc.start.line === parent.loc.end.line;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* Checks a node to see if it's the last item in a one-liner block.
|
||||
* Block is any `BlockStatement` or `StaticBlock` node. Block is a one-liner if its
|
||||
* braces (and consequently everything between them) are on the same line.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} whether the node is the last item in a one-liner block.
|
||||
*/
|
||||
function isLastInOneLinerBlock(node) {
|
||||
const parent = node.parent;
|
||||
const nextToken = sourceCode.getTokenAfter(node);
|
||||
|
||||
/**
|
||||
* Checks a node to see if it's the last item in a one-liner `ClassBody` node.
|
||||
* ClassBody is a one-liner if its braces (and consequently everything between them) are on the same line.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} whether the node is the last item in a one-liner ClassBody.
|
||||
*/
|
||||
function isLastInOneLinerClassBody(node) {
|
||||
const parent = node.parent;
|
||||
const nextToken = sourceCode.getTokenAfter(node);
|
||||
if (!nextToken || nextToken.value !== "}") {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!nextToken || nextToken.value !== "}") {
|
||||
return false;
|
||||
}
|
||||
if (parent.type === "BlockStatement") {
|
||||
return parent.loc.start.line === parent.loc.end.line;
|
||||
}
|
||||
|
||||
if (parent.type === "ClassBody") {
|
||||
return parent.loc.start.line === parent.loc.end.line;
|
||||
}
|
||||
if (parent.type === "StaticBlock") {
|
||||
const openingBrace = sourceCode.getFirstToken(parent, { skip: 1 }); // skip the `static` token
|
||||
|
||||
return false;
|
||||
}
|
||||
return openingBrace.loc.start.line === parent.loc.end.line;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks a node to see if it's followed by a semicolon.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSemicolon(node) {
|
||||
const isSemi = astUtils.isSemicolonToken(
|
||||
sourceCode.getLastToken(node),
|
||||
);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (never) {
|
||||
if (isSemi && canRemoveSemicolon(node)) {
|
||||
report(node, true);
|
||||
} else if (
|
||||
!isSemi &&
|
||||
beforeStatementContinuationChars === "always" &&
|
||||
node.type !== "PropertyDefinition" &&
|
||||
maybeAsiHazardBefore(sourceCode.getTokenAfter(node))
|
||||
) {
|
||||
report(node);
|
||||
}
|
||||
} else {
|
||||
const oneLinerBlock =
|
||||
exceptOneLine && isLastInOneLinerBlock(node);
|
||||
const oneLinerClassBody =
|
||||
exceptOneLineClassBody && isLastInOneLinerClassBody(node);
|
||||
const oneLinerBlockOrClassBody =
|
||||
oneLinerBlock || oneLinerClassBody;
|
||||
/**
|
||||
* Checks a node to see if it's the last item in a one-liner `ClassBody` node.
|
||||
* ClassBody is a one-liner if its braces (and consequently everything between them) are on the same line.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} whether the node is the last item in a one-liner ClassBody.
|
||||
*/
|
||||
function isLastInOneLinerClassBody(node) {
|
||||
const parent = node.parent;
|
||||
const nextToken = sourceCode.getTokenAfter(node);
|
||||
|
||||
if (isSemi && oneLinerBlockOrClassBody) {
|
||||
report(node, true);
|
||||
} else if (!isSemi && !oneLinerBlockOrClassBody) {
|
||||
report(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!nextToken || nextToken.value !== "}") {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks to see if there's a semicolon after a variable declaration.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSemicolonForVariableDeclaration(node) {
|
||||
const parent = node.parent;
|
||||
if (parent.type === "ClassBody") {
|
||||
return parent.loc.start.line === parent.loc.end.line;
|
||||
}
|
||||
|
||||
if (
|
||||
(parent.type !== "ForStatement" || parent.init !== node) &&
|
||||
(!/^For(?:In|Of)Statement/u.test(parent.type) ||
|
||||
parent.left !== node)
|
||||
) {
|
||||
checkForSemicolon(node);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Public API
|
||||
//--------------------------------------------------------------------------
|
||||
/**
|
||||
* Checks a node to see if it's followed by a semicolon.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSemicolon(node) {
|
||||
const isSemi = astUtils.isSemicolonToken(sourceCode.getLastToken(node));
|
||||
|
||||
return {
|
||||
VariableDeclaration: checkForSemicolonForVariableDeclaration,
|
||||
ExpressionStatement: checkForSemicolon,
|
||||
ReturnStatement: checkForSemicolon,
|
||||
ThrowStatement: checkForSemicolon,
|
||||
DoWhileStatement: checkForSemicolon,
|
||||
DebuggerStatement: checkForSemicolon,
|
||||
BreakStatement: checkForSemicolon,
|
||||
ContinueStatement: checkForSemicolon,
|
||||
ImportDeclaration: checkForSemicolon,
|
||||
ExportAllDeclaration: checkForSemicolon,
|
||||
ExportNamedDeclaration(node) {
|
||||
if (!node.declaration) {
|
||||
checkForSemicolon(node);
|
||||
}
|
||||
},
|
||||
ExportDefaultDeclaration(node) {
|
||||
if (
|
||||
!/(?:Class|Function)Declaration/u.test(
|
||||
node.declaration.type,
|
||||
)
|
||||
) {
|
||||
checkForSemicolon(node);
|
||||
}
|
||||
},
|
||||
PropertyDefinition: checkForSemicolon,
|
||||
};
|
||||
},
|
||||
if (never) {
|
||||
if (isSemi && canRemoveSemicolon(node)) {
|
||||
report(node, true);
|
||||
} else if (
|
||||
!isSemi && beforeStatementContinuationChars === "always" &&
|
||||
node.type !== "PropertyDefinition" &&
|
||||
maybeAsiHazardBefore(sourceCode.getTokenAfter(node))
|
||||
) {
|
||||
report(node);
|
||||
}
|
||||
} else {
|
||||
const oneLinerBlock = (exceptOneLine && isLastInOneLinerBlock(node));
|
||||
const oneLinerClassBody = (exceptOneLineClassBody && isLastInOneLinerClassBody(node));
|
||||
const oneLinerBlockOrClassBody = oneLinerBlock || oneLinerClassBody;
|
||||
|
||||
if (isSemi && oneLinerBlockOrClassBody) {
|
||||
report(node, true);
|
||||
} else if (!isSemi && !oneLinerBlockOrClassBody) {
|
||||
report(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks to see if there's a semicolon after a variable declaration.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSemicolonForVariableDeclaration(node) {
|
||||
const parent = node.parent;
|
||||
|
||||
if ((parent.type !== "ForStatement" || parent.init !== node) &&
|
||||
(!/^For(?:In|Of)Statement/u.test(parent.type) || parent.left !== node)
|
||||
) {
|
||||
checkForSemicolon(node);
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Public API
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
return {
|
||||
VariableDeclaration: checkForSemicolonForVariableDeclaration,
|
||||
ExpressionStatement: checkForSemicolon,
|
||||
ReturnStatement: checkForSemicolon,
|
||||
ThrowStatement: checkForSemicolon,
|
||||
DoWhileStatement: checkForSemicolon,
|
||||
DebuggerStatement: checkForSemicolon,
|
||||
BreakStatement: checkForSemicolon,
|
||||
ContinueStatement: checkForSemicolon,
|
||||
ImportDeclaration: checkForSemicolon,
|
||||
ExportAllDeclaration: checkForSemicolon,
|
||||
ExportNamedDeclaration(node) {
|
||||
if (!node.declaration) {
|
||||
checkForSemicolon(node);
|
||||
}
|
||||
},
|
||||
ExportDefaultDeclaration(node) {
|
||||
if (!/(?:Class|Function)Declaration/u.test(node.declaration.type)) {
|
||||
checkForSemicolon(node);
|
||||
}
|
||||
},
|
||||
PropertyDefinition: checkForSemicolon
|
||||
};
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user