bahlint 28.58.6934

package/lib/rules/newline-after-var.js

@@ -0,0 +1,307 @@
+/**
+ * @fileoverview Rule to check empty newline after "var" statement
+ * @author Gopal Venkatesan
+ * @deprecated in ESLint v4.0.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "layout",
+
+		docs: {
+			description:
+				"Require or disallow an empty line after variable declarations",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/newline-after-var",
+		},
+		schema: [
+			{
+				enum: ["never", "always"],
+			},
+		],
+		fixable: "whitespace",
+		messages: {
+			expected: "Expected blank line after variable declarations.",
+			unexpected: "Unexpected blank line after variable declarations.",
+		},
+
+		deprecated: {
+			message: "The rule was replaced with a more general rule.",
+			url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/",
+			deprecatedSince: "4.0.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message: "The new rule moved to a plugin.",
+					url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "padding-line-between-statements",
+						url: "https://eslint.style/rules/padding-line-between-statements",
+					},
+				},
+			],
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		// Default `mode` to "always".
+		const mode = context.options[0] === "never" ? "never" : "always";
+
+		// Cache starting and ending line numbers of comments for faster lookup
+		const commentEndLine = sourceCode
+			.getAllComments()
+			.reduce((result, token) => {
+				result[token.loc.start.line] = token.loc.end.line;
+				return result;
+			}, {});
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Gets a token from the given node to compare line to the next statement.
+		 *
+		 * In general, the token is the last token of the node. However, the token is the second last token if the following conditions satisfy.
+		 *
+		 * - The last token is semicolon.
+		 * - The semicolon is on a different line from the previous token of the semicolon.
+		 *
+		 * This behavior would address semicolon-less style code. e.g.:
+		 *
+		 *     var foo = 1
+		 *
+		 *     ;(a || b).doSomething()
+		 * @param {ASTNode} node The node to get.
+		 * @returns {Token} The token to compare line to the next statement.
+		 */
+		function getLastToken(node) {
+			const lastToken = sourceCode.getLastToken(node);
+
+			if (lastToken.type === "Punctuator" && lastToken.value === ";") {
+				const prevToken = sourceCode.getTokenBefore(lastToken);
+
+				if (prevToken.loc.end.line !== lastToken.loc.start.line) {
+					return prevToken;
+				}
+			}
+
+			return lastToken;
+		}
+
+		/**
+		 * Determine if provided keyword is a variable declaration
+		 * @private
+		 * @param {string} keyword keyword to test
+		 * @returns {boolean} True if `keyword` is a type of var
+		 */
+		function isVar(keyword) {
+			return (
+				keyword === "var" || keyword === "let" || keyword === "const"
+			);
+		}
+
+		/**
+		 * Determine if provided keyword is a variant of for specifiers
+		 * @private
+		 * @param {string} keyword keyword to test
+		 * @returns {boolean} True if `keyword` is a variant of for specifier
+		 */
+		function isForTypeSpecifier(keyword) {
+			return (
+				keyword === "ForStatement" ||
+				keyword === "ForInStatement" ||
+				keyword === "ForOfStatement"
+			);
+		}
+
+		/**
+		 * Determine if provided keyword is an export specifiers
+		 * @private
+		 * @param {string} nodeType nodeType to test
+		 * @returns {boolean} True if `nodeType` is an export specifier
+		 */
+		function isExportSpecifier(nodeType) {
+			return (
+				nodeType === "ExportNamedDeclaration" ||
+				nodeType === "ExportSpecifier" ||
+				nodeType === "ExportDefaultDeclaration" ||
+				nodeType === "ExportAllDeclaration"
+			);
+		}
+
+		/**
+		 * Determine if provided node is the last of their parent block.
+		 * @private
+		 * @param {ASTNode} node node to test
+		 * @returns {boolean} True if `node` is last of their parent block.
+		 */
+		function isLastNode(node) {
+			const token = sourceCode.getTokenAfter(node);
+
+			return (
+				!token || (token.type === "Punctuator" && token.value === "}")
+			);
+		}
+
+		/**
+		 * Gets the last line of a group of consecutive comments
+		 * @param {number} commentStartLine The starting line of the group
+		 * @returns {number} The number of the last comment line of the group
+		 */
+		function getLastCommentLineOfBlock(commentStartLine) {
+			const currentCommentEnd = commentEndLine[commentStartLine];
+
+			return commentEndLine[currentCommentEnd + 1]
+				? getLastCommentLineOfBlock(currentCommentEnd + 1)
+				: currentCommentEnd;
+		}
+
+		/**
+		 * Determine if a token starts more than one line after a comment ends
+		 * @param {token} token The token being checked
+		 * @param {integer} commentStartLine The line number on which the comment starts
+		 * @returns {boolean} True if `token` does not start immediately after a comment
+		 */
+		function hasBlankLineAfterComment(token, commentStartLine) {
+			return (
+				token.loc.start.line >
+				getLastCommentLineOfBlock(commentStartLine) + 1
+			);
+		}
+
+		/**
+		 * Checks that a blank line exists after a variable declaration when mode is
+		 * set to "always", or checks that there is no blank line when mode is set
+		 * to "never"
+		 * @private
+		 * @param {ASTNode} node `VariableDeclaration` node to test
+		 * @returns {void}
+		 */
+		function checkForBlankLine(node) {
+			/*
+			 * lastToken is the last token on the node's line. It will usually also be the last token of the node, but it will
+			 * sometimes be second-last if there is a semicolon on a different line.
+			 */
+			const lastToken = getLastToken(node),
+				/*
+				 * If lastToken is the last token of the node, nextToken should be the token after the node. Otherwise, nextToken
+				 * is the last token of the node.
+				 */
+				nextToken =
+					lastToken === sourceCode.getLastToken(node)
+						? sourceCode.getTokenAfter(node)
+						: sourceCode.getLastToken(node),
+				nextLineNum = lastToken.loc.end.line + 1;
+
+			// Ignore if there is no following statement
+			if (!nextToken) {
+				return;
+			}
+
+			// Ignore if parent of node is a for variant
+			if (isForTypeSpecifier(node.parent.type)) {
+				return;
+			}
+
+			// Ignore if parent of node is an export specifier
+			if (isExportSpecifier(node.parent.type)) {
+				return;
+			}
+
+			/*
+			 * Some coding styles use multiple `var` statements, so do nothing if
+			 * the next token is a `var` statement.
+			 */
+			if (nextToken.type === "Keyword" && isVar(nextToken.value)) {
+				return;
+			}
+
+			// Ignore if it is last statement in a block
+			if (isLastNode(node)) {
+				return;
+			}
+
+			// Next statement is not a `var`...
+			const noNextLineToken = nextToken.loc.start.line > nextLineNum;
+			const hasNextLineComment =
+				typeof commentEndLine[nextLineNum] !== "undefined";
+
+			if (mode === "never" && noNextLineToken && !hasNextLineComment) {
+				context.report({
+					node,
+					messageId: "unexpected",
+					fix(fixer) {
+						const linesBetween = sourceCode
+							.getText()
+							.slice(lastToken.range[1], nextToken.range[0])
+							.split(astUtils.LINEBREAK_MATCHER);
+
+						return fixer.replaceTextRange(
+							[lastToken.range[1], nextToken.range[0]],
+							`${linesBetween.slice(0, -1).join("")}\n${linesBetween.at(-1)}`,
+						);
+					},
+				});
+			}
+
+			// Token on the next line, or comment without blank line
+			if (
+				mode === "always" &&
+				(!noNextLineToken ||
+					(hasNextLineComment &&
+						!hasBlankLineAfterComment(nextToken, nextLineNum)))
+			) {
+				context.report({
+					node,
+					messageId: "expected",
+					fix(fixer) {
+						if (
+							(noNextLineToken
+								? getLastCommentLineOfBlock(nextLineNum)
+								: lastToken.loc.end.line) ===
+							nextToken.loc.start.line
+						) {
+							return fixer.insertTextBefore(nextToken, "\n\n");
+						}
+
+						return fixer.insertTextBeforeRange(
+							[
+								nextToken.range[0] - nextToken.loc.start.column,
+								nextToken.range[1],
+							],
+							"\n",
+						);
+					},
+				});
+			}
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			VariableDeclaration: checkForBlankLine,
+		};
+	},
+};

package/lib/rules/newline-before-return.js

@@ -0,0 +1,242 @@
+/**
+ * @fileoverview Rule to require newlines before `return` statement
+ * @author Kai Cataldo
+ * @deprecated in ESLint v4.0.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "layout",
+
+		docs: {
+			description: "Require an empty line before `return` statements",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/newline-before-return",
+		},
+
+		fixable: "whitespace",
+		schema: [],
+		messages: {
+			expected: "Expected newline before return statement.",
+		},
+
+		deprecated: {
+			message: "The rule was replaced with a more general rule.",
+			url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/",
+			deprecatedSince: "4.0.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message: "The new rule moved to a plugin.",
+					url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "padding-line-between-statements",
+						url: "https://eslint.style/rules/padding-line-between-statements",
+					},
+				},
+			],
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Tests whether node is preceded by supplied tokens
+		 * @param {ASTNode} node node to check
+		 * @param {Array} testTokens array of tokens to test against
+		 * @returns {boolean} Whether or not the node is preceded by one of the supplied tokens
+		 * @private
+		 */
+		function isPrecededByTokens(node, testTokens) {
+			const tokenBefore = sourceCode.getTokenBefore(node);
+
+			return testTokens.includes(tokenBefore.value);
+		}
+
+		/**
+		 * Checks whether node is the first node after statement or in block
+		 * @param {ASTNode} node node to check
+		 * @returns {boolean} Whether or not the node is the first node after statement or in block
+		 * @private
+		 */
+		function isFirstNode(node) {
+			const parentType = node.parent.type;
+
+			if (node.parent.body) {
+				return Array.isArray(node.parent.body)
+					? node.parent.body[0] === node
+					: node.parent.body === node;
+			}
+
+			if (parentType === "IfStatement") {
+				return isPrecededByTokens(node, ["else", ")"]);
+			}
+			if (parentType === "DoWhileStatement") {
+				return isPrecededByTokens(node, ["do"]);
+			}
+			if (parentType === "SwitchCase") {
+				return isPrecededByTokens(node, [":"]);
+			}
+			return isPrecededByTokens(node, [")"]);
+		}
+
+		/**
+		 * Returns the number of lines of comments that precede the node
+		 * @param {ASTNode} node node to check for overlapping comments
+		 * @param {number} lineNumTokenBefore line number of previous token, to check for overlapping comments
+		 * @returns {number} Number of lines of comments that precede the node
+		 * @private
+		 */
+		function calcCommentLines(node, lineNumTokenBefore) {
+			const comments = sourceCode.getCommentsBefore(node);
+			let numLinesComments = 0;
+
+			if (!comments.length) {
+				return numLinesComments;
+			}
+
+			comments.forEach(comment => {
+				numLinesComments++;
+
+				if (comment.type === "Block") {
+					numLinesComments +=
+						comment.loc.end.line - comment.loc.start.line;
+				}
+
+				// avoid counting lines with inline comments twice
+				if (comment.loc.start.line === lineNumTokenBefore) {
+					numLinesComments--;
+				}
+
+				if (comment.loc.end.line === node.loc.start.line) {
+					numLinesComments--;
+				}
+			});
+
+			return numLinesComments;
+		}
+
+		/**
+		 * Returns the line number of the token before the node that is passed in as an argument
+		 * @param {ASTNode} node The node to use as the start of the calculation
+		 * @returns {number} Line number of the token before `node`
+		 * @private
+		 */
+		function getLineNumberOfTokenBefore(node) {
+			const tokenBefore = sourceCode.getTokenBefore(node);
+			let lineNumTokenBefore;
+
+			/**
+			 * Global return (at the beginning of a script) is a special case.
+			 * If there is no token before `return`, then we expect no line
+			 * break before the return. Comments are allowed to occupy lines
+			 * before the global return, just no blank lines.
+			 * Setting lineNumTokenBefore to zero in that case results in the
+			 * desired behavior.
+			 */
+			if (tokenBefore) {
+				lineNumTokenBefore = tokenBefore.loc.end.line;
+			} else {
+				lineNumTokenBefore = 0; // global return at beginning of script
+			}
+
+			return lineNumTokenBefore;
+		}
+
+		/**
+		 * Checks whether node is preceded by a newline
+		 * @param {ASTNode} node node to check
+		 * @returns {boolean} Whether or not the node is preceded by a newline
+		 * @private
+		 */
+		function hasNewlineBefore(node) {
+			const lineNumNode = node.loc.start.line;
+			const lineNumTokenBefore = getLineNumberOfTokenBefore(node);
+			const commentLines = calcCommentLines(node, lineNumTokenBefore);
+
+			return lineNumNode - lineNumTokenBefore - commentLines > 1;
+		}
+
+		/**
+		 * Checks whether it is safe to apply a fix to a given return statement.
+		 *
+		 * The fix is not considered safe if the given return statement has leading comments,
+		 * as we cannot safely determine if the newline should be added before or after the comments.
+		 * For more information, see: https://github.com/eslint/eslint/issues/5958#issuecomment-222767211
+		 * @param {ASTNode} node The return statement node to check.
+		 * @returns {boolean} `true` if it can fix the node.
+		 * @private
+		 */
+		function canFix(node) {
+			const leadingComments = sourceCode.getCommentsBefore(node);
+			const lastLeadingComment = leadingComments.at(-1);
+			const tokenBefore = sourceCode.getTokenBefore(node);
+
+			if (leadingComments.length === 0) {
+				return true;
+			}
+
+			/*
+			 * if the last leading comment ends in the same line as the previous token and
+			 * does not share a line with the `return` node, we can consider it safe to fix.
+			 * Example:
+			 * function a() {
+			 *     var b; //comment
+			 *     return;
+			 * }
+			 */
+			if (
+				lastLeadingComment.loc.end.line === tokenBefore.loc.end.line &&
+				lastLeadingComment.loc.end.line !== node.loc.start.line
+			) {
+				return true;
+			}
+
+			return false;
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			ReturnStatement(node) {
+				if (!isFirstNode(node) && !hasNewlineBefore(node)) {
+					context.report({
+						node,
+						messageId: "expected",
+						fix(fixer) {
+							if (canFix(node)) {
+								const tokenBefore =
+									sourceCode.getTokenBefore(node);
+								const newlines =
+									node.loc.start.line ===
+									tokenBefore.loc.end.line
+										? "\n\n"
+										: "\n";
+
+								return fixer.insertTextBefore(node, newlines);
+							}
+							return null;
+						},
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/newline-per-chained-call.js

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Rule to ensure newline per method call when chaining calls
+ * @author Rajendra Patil
+ * @author Burak Yigit Kaya
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+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: "newline-per-chained-call",
+						url: "https://eslint.style/rules/newline-per-chained-call",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Require a newline after each call in a method chain",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/newline-per-chained-call",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					ignoreChainWithDepth: {
+						type: "integer",
+						minimum: 1,
+						maximum: 10,
+						default: 2,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		messages: {
+			expected: "Expected line break before `{{callee}}`.",
+		},
+	},
+
+	create(context) {
+		const options = context.options[0] || {},
+			ignoreChainWithDepth = options.ignoreChainWithDepth || 2;
+
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Get the prefix of a given MemberExpression node.
+		 * If the MemberExpression node is a computed value it returns a
+		 * left bracket. If not it returns a period.
+		 * @param {ASTNode} node A MemberExpression node to get
+		 * @returns {string} The prefix of the node.
+		 */
+		function getPrefix(node) {
+			if (node.computed) {
+				if (node.optional) {
+					return "?.[";
+				}
+				return "[";
+			}
+			if (node.optional) {
+				return "?.";
+			}
+			return ".";
+		}
+
+		/**
+		 * Gets the property text of a given MemberExpression node.
+		 * If the text is multiline, this returns only the first line.
+		 * @param {ASTNode} node A MemberExpression node to get.
+		 * @returns {string} The property text of the node.
+		 */
+		function getPropertyText(node) {
+			const prefix = getPrefix(node);
+			const lines = sourceCode
+				.getText(node.property)
+				.split(astUtils.LINEBREAK_MATCHER);
+			const suffix = node.computed && lines.length === 1 ? "]" : "";
+
+			return prefix + lines[0] + suffix;
+		}
+
+		return {
+			"CallExpression:exit"(node) {
+				const callee = astUtils.skipChainExpression(node.callee);
+
+				if (callee.type !== "MemberExpression") {
+					return;
+				}
+
+				let parent = astUtils.skipChainExpression(callee.object);
+				let depth = 1;
+
+				while (parent && parent.callee) {
+					depth += 1;
+					parent = astUtils.skipChainExpression(
+						astUtils.skipChainExpression(parent.callee).object,
+					);
+				}
+
+				if (
+					depth > ignoreChainWithDepth &&
+					astUtils.isTokenOnSameLine(callee.object, callee.property)
+				) {
+					const firstTokenAfterObject = sourceCode.getTokenAfter(
+						callee.object,
+						astUtils.isNotClosingParenToken,
+					);
+
+					context.report({
+						node: callee.property,
+						loc: {
+							start: firstTokenAfterObject.loc.start,
+							end: callee.loc.end,
+						},
+						messageId: "expected",
+						data: {
+							callee: getPropertyText(callee),
+						},
+						fix(fixer) {
+							return fixer.insertTextBefore(
+								firstTokenAfterObject,
+								"\n",
+							);
+						},
+					});
+				}
+			},
+		};
+	},
+};