@alexlit/lint-kit 164.15.0 → 165.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/require-atomic-updates.js

@@ -0,0 +1,365 @@
+/**
+ * @fileoverview disallow assignments that can lead to race conditions due to usage of `await` or `yield`
+ * @author Teddy Katz
+ * @author Toru Nagashima
+ */
+"use strict";
+
+/**
+ * Make the map from identifiers to each reference.
+ * @param {escope.Scope} scope The scope to get references.
+ * @param {Map<Identifier, escope.Reference>} [outReferenceMap] The map from identifier nodes to each reference object.
+ * @returns {Map<Identifier, escope.Reference>} `referenceMap`.
+ */
+function createReferenceMap(scope, outReferenceMap = new Map()) {
+	for (const reference of scope.references) {
+		if (reference.resolved === null) {
+			continue;
+		}
+
+		outReferenceMap.set(reference.identifier, reference);
+	}
+	for (const childScope of scope.childScopes) {
+		if (childScope.type !== "function") {
+			createReferenceMap(childScope, outReferenceMap);
+		}
+	}
+
+	return outReferenceMap;
+}
+
+/**
+ * Get `reference.writeExpr` of a given reference.
+ * If it's the read reference of MemberExpression in LHS, returns RHS in order to address `a.b = await a`
+ * @param {escope.Reference} reference The reference to get.
+ * @returns {Expression|null} The `reference.writeExpr`.
+ */
+function getWriteExpr(reference) {
+	if (reference.writeExpr) {
+		return reference.writeExpr;
+	}
+	let node = reference.identifier;
+
+	while (node) {
+		const t = node.parent.type;
+
+		if (t === "AssignmentExpression" && node.parent.left === node) {
+			return node.parent.right;
+		}
+		if (t === "MemberExpression" && node.parent.object === node) {
+			node = node.parent;
+			continue;
+		}
+
+		break;
+	}
+
+	return null;
+}
+
+/**
+ * Checks if an expression is a variable that can only be observed within the given function.
+ * @param {Variable|null} variable The variable to check
+ * @param {boolean} isMemberAccess If `true` then this is a member access.
+ * @returns {boolean} `true` if the variable is local to the given function, and is never referenced in a closure.
+ */
+function isLocalVariableWithoutEscape(variable, isMemberAccess) {
+	if (!variable) {
+		return false; // A global variable which was not defined.
+	}
+
+	// If the reference is a property access and the variable is a parameter, it handles the variable is not local.
+	if (isMemberAccess && variable.defs.some(d => d.type === "Parameter")) {
+		return false;
+	}
+
+	const functionScope = variable.scope.variableScope;
+
+	return variable.references.every(
+		reference => reference.from.variableScope === functionScope,
+	);
+}
+
+/**
+ * Represents segment information.
+ */
+class SegmentInfo {
+	constructor() {
+		this.info = new WeakMap();
+	}
+
+	/**
+	 * Initialize the segment information.
+	 * @param {PathSegment} segment The segment to initialize.
+	 * @returns {void}
+	 */
+	initialize(segment) {
+		const outdatedReadVariables = new Set();
+		const freshReadVariables = new Set();
+
+		for (const prevSegment of segment.prevSegments) {
+			const info = this.info.get(prevSegment);
+
+			if (info) {
+				info.outdatedReadVariables.forEach(
+					Set.prototype.add,
+					outdatedReadVariables,
+				);
+				info.freshReadVariables.forEach(
+					Set.prototype.add,
+					freshReadVariables,
+				);
+			}
+		}
+
+		this.info.set(segment, { outdatedReadVariables, freshReadVariables });
+	}
+
+	/**
+	 * Mark a given variable as read on given segments.
+	 * @param {PathSegment[]} segments The segments that it read the variable on.
+	 * @param {Variable} variable The variable to be read.
+	 * @returns {void}
+	 */
+	markAsRead(segments, variable) {
+		for (const segment of segments) {
+			const info = this.info.get(segment);
+
+			if (info) {
+				info.freshReadVariables.add(variable);
+
+				// If a variable is freshly read again, then it's no more out-dated.
+				info.outdatedReadVariables.delete(variable);
+			}
+		}
+	}
+
+	/**
+	 * Move `freshReadVariables` to `outdatedReadVariables`.
+	 * @param {PathSegment[]} segments The segments to process.
+	 * @returns {void}
+	 */
+	makeOutdated(segments) {
+		for (const segment of segments) {
+			const info = this.info.get(segment);
+
+			if (info) {
+				info.freshReadVariables.forEach(
+					Set.prototype.add,
+					info.outdatedReadVariables,
+				);
+				info.freshReadVariables.clear();
+			}
+		}
+	}
+
+	/**
+	 * Check if a given variable is outdated on the current segments.
+	 * @param {PathSegment[]} segments The current segments.
+	 * @param {Variable} variable The variable to check.
+	 * @returns {boolean} `true` if the variable is outdated on the segments.
+	 */
+	isOutdated(segments, variable) {
+		for (const segment of segments) {
+			const info = this.info.get(segment);
+
+			if (info && info.outdatedReadVariables.has(variable)) {
+				return true;
+			}
+		}
+		return false;
+	}
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		defaultOptions: [
+			{
+				allowProperties: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Disallow assignments that can lead to race conditions due to usage of `await` or `yield`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/require-atomic-updates",
+		},
+
+		fixable: null,
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowProperties: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			nonAtomicUpdate:
+				"Possible race condition: `{{value}}` might be reassigned based on an outdated value of `{{value}}`.",
+			nonAtomicObjectUpdate:
+				"Possible race condition: `{{value}}` might be assigned based on an outdated state of `{{object}}`.",
+		},
+	},
+
+	create(context) {
+		const [{ allowProperties }] = context.options;
+
+		const sourceCode = context.sourceCode;
+		const assignmentReferences = new Map();
+		const segmentInfo = new SegmentInfo();
+		let stack = null;
+
+		return {
+			onCodePathStart(codePath, node) {
+				const scope = sourceCode.getScope(node);
+				const shouldVerify =
+					scope.type === "function" &&
+					(scope.block.async || scope.block.generator);
+
+				stack = {
+					upper: stack,
+					codePath,
+					referenceMap: shouldVerify
+						? createReferenceMap(scope)
+						: null,
+					currentSegments: new Set(),
+				};
+			},
+			onCodePathEnd() {
+				stack = stack.upper;
+			},
+
+			// Initialize the segment information.
+			onCodePathSegmentStart(segment) {
+				segmentInfo.initialize(segment);
+				stack.currentSegments.add(segment);
+			},
+
+			onUnreachableCodePathSegmentStart(segment) {
+				stack.currentSegments.add(segment);
+			},
+
+			onUnreachableCodePathSegmentEnd(segment) {
+				stack.currentSegments.delete(segment);
+			},
+
+			onCodePathSegmentEnd(segment) {
+				stack.currentSegments.delete(segment);
+			},
+
+			// Handle references to prepare verification.
+			Identifier(node) {
+				const { referenceMap } = stack;
+				const reference = referenceMap && referenceMap.get(node);
+
+				// Ignore if this is not a valid variable reference.
+				if (!reference) {
+					return;
+				}
+				const variable = reference.resolved;
+				const writeExpr = getWriteExpr(reference);
+				const isMemberAccess =
+					reference.identifier.parent.type === "MemberExpression";
+
+				// Add a fresh read variable.
+				if (
+					reference.isRead() &&
+					!(writeExpr && writeExpr.parent.operator === "=")
+				) {
+					segmentInfo.markAsRead(stack.currentSegments, variable);
+				}
+
+				/*
+				 * Register the variable to verify after ESLint traversed the `writeExpr` node
+				 * if this reference is an assignment to a variable which is referred from other closure.
+				 */
+				if (
+					writeExpr &&
+					writeExpr.parent.right === writeExpr && // ← exclude variable declarations.
+					!isLocalVariableWithoutEscape(variable, isMemberAccess)
+				) {
+					let refs = assignmentReferences.get(writeExpr);
+
+					if (!refs) {
+						refs = [];
+						assignmentReferences.set(writeExpr, refs);
+					}
+
+					refs.push(reference);
+				}
+			},
+
+			/*
+			 * Verify assignments.
+			 * If the reference exists in `outdatedReadVariables` list, report it.
+			 */
+			":expression:exit"(node) {
+				// referenceMap exists if this is in a resumable function scope.
+				if (!stack.referenceMap) {
+					return;
+				}
+
+				// Mark the read variables on this code path as outdated.
+				if (
+					node.type === "AwaitExpression" ||
+					node.type === "YieldExpression"
+				) {
+					segmentInfo.makeOutdated(stack.currentSegments);
+				}
+
+				// Verify.
+				const references = assignmentReferences.get(node);
+
+				if (references) {
+					assignmentReferences.delete(node);
+
+					for (const reference of references) {
+						const variable = reference.resolved;
+
+						if (
+							segmentInfo.isOutdated(
+								stack.currentSegments,
+								variable,
+							)
+						) {
+							if (node.parent.left === reference.identifier) {
+								context.report({
+									node: node.parent,
+									messageId: "nonAtomicUpdate",
+									data: {
+										value: variable.name,
+									},
+								});
+							} else if (!allowProperties) {
+								context.report({
+									node: node.parent,
+									messageId: "nonAtomicObjectUpdate",
+									data: {
+										value: sourceCode.getText(
+											node.parent.left,
+										),
+										object: variable.name,
+									},
+								});
+							}
+						}
+					}
+				}
+			},
+		};
+	},
+};

package/packages/config-eslint/node_modules/eslint/lib/rules/require-await.js

@@ -0,0 +1,184 @@
+/**
+ * @fileoverview Rule to disallow async functions which have no `await` expression.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Capitalize the 1st letter of the given text.
+ * @param {string} text The text to capitalize.
+ * @returns {string} The text that the 1st letter was capitalized.
+ */
+function capitalizeFirstLetter(text) {
+	return text[0].toUpperCase() + text.slice(1);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow async functions which have no `await` expression",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/require-await",
+		},
+
+		schema: [],
+
+		messages: {
+			missingAwait: "{{name}} has no 'await' expression.",
+			removeAsync: "Remove 'async'.",
+		},
+
+		hasSuggestions: true,
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		let scopeInfo = null;
+
+		/**
+		 * Push the scope info object to the stack.
+		 * @returns {void}
+		 */
+		function enterFunction() {
+			scopeInfo = {
+				upper: scopeInfo,
+				hasAwait: false,
+			};
+		}
+
+		/**
+		 * Pop the top scope info object from the stack.
+		 * Also, it reports the function if needed.
+		 * @param {ASTNode} node The node to report.
+		 * @returns {void}
+		 */
+		function exitFunction(node) {
+			if (
+				!node.generator &&
+				node.async &&
+				!scopeInfo.hasAwait &&
+				!astUtils.isEmptyFunction(node)
+			) {
+				/*
+				 * If the function belongs to a method definition or
+				 * property, then the function's range may not include the
+				 * `async` keyword and we should look at the parent instead.
+				 */
+				const nodeWithAsyncKeyword =
+					(node.parent.type === "MethodDefinition" &&
+						node.parent.value === node) ||
+					(node.parent.type === "Property" &&
+						node.parent.method &&
+						node.parent.value === node)
+						? node.parent
+						: node;
+
+				const asyncToken = sourceCode.getFirstToken(
+					nodeWithAsyncKeyword,
+					token => token.value === "async",
+				);
+				const asyncRange = [
+					asyncToken.range[0],
+					sourceCode.getTokenAfter(asyncToken, {
+						includeComments: true,
+					}).range[0],
+				];
+
+				/*
+				 * Removing the `async` keyword can cause parsing errors if the current
+				 * statement is relying on automatic semicolon insertion. If ASI is currently
+				 * being used, then we should replace the `async` keyword with a semicolon.
+				 */
+				const nextToken = sourceCode.getTokenAfter(asyncToken);
+				const addSemiColon =
+					nextToken.type === "Punctuator" &&
+					(nextToken.value === "[" || nextToken.value === "(") &&
+					(nodeWithAsyncKeyword.type === "MethodDefinition" ||
+						astUtils.isStartOfExpressionStatement(
+							nodeWithAsyncKeyword,
+						)) &&
+					astUtils.needsPrecedingSemicolon(
+						sourceCode,
+						nodeWithAsyncKeyword,
+					);
+
+				context.report({
+					node,
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					messageId: "missingAwait",
+					data: {
+						name: capitalizeFirstLetter(
+							astUtils.getFunctionNameWithKind(node),
+						),
+					},
+					suggest: [
+						{
+							messageId: "removeAsync",
+							fix: fixer =>
+								fixer.replaceTextRange(
+									asyncRange,
+									addSemiColon ? ";" : "",
+								),
+						},
+					],
+				});
+			}
+
+			scopeInfo = scopeInfo.upper;
+		}
+
+		return {
+			FunctionDeclaration: enterFunction,
+			FunctionExpression: enterFunction,
+			ArrowFunctionExpression: enterFunction,
+			"FunctionDeclaration:exit": exitFunction,
+			"FunctionExpression:exit": exitFunction,
+			"ArrowFunctionExpression:exit": exitFunction,
+
+			AwaitExpression() {
+				if (!scopeInfo) {
+					return;
+				}
+
+				scopeInfo.hasAwait = true;
+			},
+			ForOfStatement(node) {
+				if (!scopeInfo) {
+					return;
+				}
+
+				if (node.await) {
+					scopeInfo.hasAwait = true;
+				}
+			},
+			VariableDeclaration(node) {
+				if (!scopeInfo) {
+					return;
+				}
+
+				if (node.kind === "await using") {
+					scopeInfo.hasAwait = true;
+				}
+			},
+		};
+	},
+};