+++ /dev/null
-/**
- * @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) {
- 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);
-}
-
-class SegmentInfo {
- constructor() {
- this.info = new WeakMap();
- }
-
- /**
- * Initialize the segment information.
- * @param {PathSegment} segment The segment to initialize.
- * @returns {void}
- */
- initialize(segment) {
- const outdatedReadVariableNames = new Set();
- const freshReadVariableNames = new Set();
-
- for (const prevSegment of segment.prevSegments) {
- const info = this.info.get(prevSegment);
-
- if (info) {
- info.outdatedReadVariableNames.forEach(Set.prototype.add, outdatedReadVariableNames);
- info.freshReadVariableNames.forEach(Set.prototype.add, freshReadVariableNames);
- }
- }
-
- this.info.set(segment, { outdatedReadVariableNames, freshReadVariableNames });
- }
-
- /**
- * Mark a given variable as read on given segments.
- * @param {PathSegment[]} segments The segments that it read the variable on.
- * @param {string} variableName The variable name to be read.
- * @returns {void}
- */
- markAsRead(segments, variableName) {
- for (const segment of segments) {
- const info = this.info.get(segment);
-
- if (info) {
- info.freshReadVariableNames.add(variableName);
- }
- }
- }
-
- /**
- * Move `freshReadVariableNames` to `outdatedReadVariableNames`.
- * @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.freshReadVariableNames.forEach(Set.prototype.add, info.outdatedReadVariableNames);
- info.freshReadVariableNames.clear();
- }
- }
- }
-
- /**
- * Check if a given variable is outdated on the current segments.
- * @param {PathSegment[]} segments The current segments.
- * @param {string} variableName The variable name to check.
- * @returns {boolean} `true` if the variable is outdated on the segments.
- */
- isOutdated(segments, variableName) {
- for (const segment of segments) {
- const info = this.info.get(segment);
-
- if (info && info.outdatedReadVariableNames.has(variableName)) {
- return true;
- }
- }
- return false;
- }
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
- meta: {
- type: "problem",
-
- docs: {
- description: "disallow assignments that can lead to race conditions due to usage of `await` or `yield`",
- category: "Possible Errors",
- recommended: false,
- url: "https://eslint.org/docs/rules/require-atomic-updates"
- },
-
- fixable: null,
- schema: [],
-
- messages: {
- nonAtomicUpdate: "Possible race condition: `{{value}}` might be reassigned based on an outdated value of `{{value}}`."
- }
- },
-
- create(context) {
- const sourceCode = context.getSourceCode();
- const assignmentReferences = new Map();
- const segmentInfo = new SegmentInfo();
- let stack = null;
-
- return {
- onCodePathStart(codePath) {
- const scope = context.getScope();
- const shouldVerify =
- scope.type === "function" &&
- (scope.block.async || scope.block.generator);
-
- stack = {
- upper: stack,
- codePath,
- referenceMap: shouldVerify ? createReferenceMap(scope) : null
- };
- },
- onCodePathEnd() {
- stack = stack.upper;
- },
-
- // Initialize the segment information.
- onCodePathSegmentStart(segment) {
- segmentInfo.initialize(segment);
- },
-
- // Handle references to prepare verification.
- Identifier(node) {
- const { codePath, referenceMap } = stack;
- const reference = referenceMap && referenceMap.get(node);
-
- // Ignore if this is not a valid variable reference.
- if (!reference) {
- return;
- }
- const name = reference.identifier.name;
- 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(codePath.currentSegments, name);
- }
-
- /*
- * 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 clausure.
- */
- 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 `outdatedReadVariableNames` list, report it.
- */
- ":expression:exit"(node) {
- const { codePath, referenceMap } = stack;
-
- // referenceMap exists if this is in a resumable function scope.
- if (!referenceMap) {
- return;
- }
-
- // Mark the read variables on this code path as outdated.
- if (node.type === "AwaitExpression" || node.type === "YieldExpression") {
- segmentInfo.makeOutdated(codePath.currentSegments);
- }
-
- // Verify.
- const references = assignmentReferences.get(node);
-
- if (references) {
- assignmentReferences.delete(node);
-
- for (const reference of references) {
- const name = reference.identifier.name;
-
- if (segmentInfo.isOutdated(codePath.currentSegments, name)) {
- context.report({
- node: node.parent,
- messageId: "nonAtomicUpdate",
- data: {
- value: sourceCode.getText(node.parent.left)
- }
- });
- }
- }
- }
- }
- };
- }
-};
projects / dotfiles / .git / blobdiff