*/
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) {
* @returns {void}
*/
initialize(segment) {
- const outdatedReadVariableNames = new Set();
- const freshReadVariableNames = new Set();
+ const outdatedReadVariables = new Set();
+ const freshReadVariables = 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);
+ info.outdatedReadVariables.forEach(Set.prototype.add, outdatedReadVariables);
+ info.freshReadVariables.forEach(Set.prototype.add, freshReadVariables);
}
}
- this.info.set(segment, { outdatedReadVariableNames, freshReadVariableNames });
+ 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 {string} variableName The variable name to be read.
+ * @param {Variable} variable The variable to be read.
* @returns {void}
*/
- markAsRead(segments, variableName) {
+ markAsRead(segments, variable) {
for (const segment of segments) {
const info = this.info.get(segment);
if (info) {
- info.freshReadVariableNames.add(variableName);
+ info.freshReadVariables.add(variable);
// If a variable is freshly read again, then it's no more out-dated.
- info.outdatedReadVariableNames.delete(variableName);
+ info.outdatedReadVariables.delete(variable);
}
}
}
/**
- * Move `freshReadVariableNames` to `outdatedReadVariableNames`.
+ * Move `freshReadVariables` to `outdatedReadVariables`.
* @param {PathSegment[]} segments The segments to process.
* @returns {void}
*/
const info = this.info.get(segment);
if (info) {
- info.freshReadVariableNames.forEach(Set.prototype.add, info.outdatedReadVariableNames);
- info.freshReadVariableNames.clear();
+ 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 {string} variableName The variable name to check.
+ * @param {Variable} variable The variable to check.
* @returns {boolean} `true` if the variable is outdated on the segments.
*/
- isOutdated(segments, variableName) {
+ isOutdated(segments, variable) {
for (const segment of segments) {
const info = this.info.get(segment);
- if (info && info.outdatedReadVariableNames.has(variableName)) {
+ if (info && info.outdatedReadVariables.has(variable)) {
return true;
}
}
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);
+ segmentInfo.markAsRead(codePath.currentSegments, variable);
}
/*
/*
* Verify assignments.
- * If the reference exists in `outdatedReadVariableNames` list, report it.
+ * If the reference exists in `outdatedReadVariables` list, report it.
*/
":expression:exit"(node) {
const { codePath, referenceMap } = stack;
assignmentReferences.delete(node);
for (const reference of references) {
- const name = reference.identifier.name;
+ const variable = reference.resolved;
- if (segmentInfo.isOutdated(codePath.currentSegments, name)) {
+ if (segmentInfo.isOutdated(codePath.currentSegments, variable)) {
context.report({
node: node.parent,
messageId: "nonAtomicUpdate",