Add override fix

Author: jdalton

src/shadow/arborist.ts

@@ -478,92 +478,138 @@ function walk(
 function deleteEdgeIn(node: NodeClass, edge: SafeEdge) {
   node.edgesIn.delete(edge)
   if (edge.overrides) {
-    // updateNodeOverrideSetDueToEdgeRemoval(node, edge.overrides)
+    updateNodeOverrideSetDueToEdgeRemoval(node, edge.overrides)
   }
 }
 
-// function recalculateOutEdgesOverrides (node: NodeClass) {
-//   // For each edge out propogate the new overrides through.
-//   for (const [, edge] of node.edgesOut) {
-//     edge.reload(true)
-//     if (edge.to) {
-//       updateNodeOverrideSet(edge.to, edge.overrides)
-//     }
-//   }
-// }
-
-// function findSpecificOverrideSet (first, second) {
-//   for (let OverrideSet = second; OverrideSet; OverrideSet = OverrideSet.parent) {
-//     if (OverrideSet.isEqual(first)) {
-//       return second
-//     }
-//   }
-//   for (let OverrideSet = first; OverrideSet; OverrideSet = OverrideSet.parent) {
-//     if (OverrideSet.isEqual(second)) {
-//       return first
-//     }
-//   }
-//   console.log('Conflicting override sets')
-// }
-
-// function updateNodeOverrideSetDueToEdgeRemoval (node: NodeClass, otherOverrideSet) {
-//   // If this edge's overrides isn't equal to this node's overrides, then removing it won't change newOverrideSet later.
-//   if (!node.overrides || !node.overrides.isEqual(otherOverrideSet)) {
-//     return false
-//   }
-//   let newOverrideSet
-//   for (const edge of node.edgesIn) {
-//     if (newOverrideSet) {
-//       newOverrideSet = findSpecificOverrideSet(node, edge.overrides, newOverrideSet)
-//     } else {
-//       newOverrideSet = edge.overrides
-//     }
-//   }
-//   if (overrides.isEqual(newOverrideSet)) {
-//     return false
-//   }
-//   this.overrides = newOverrideSet
-//   if (this.overrides) {
-//     // Optimization: if there's any override set at all, then no non-extraneous node has an empty override set. So if we temporarily have no
-//     // override set (for example, we removed all the edges in), there's no use updating all the edges out right now. Let's just wait until
-//     // we have an actual override set later.
-//     recalculateOutEdgesOverrides(node)
-//   }
-//   return true
-// }
-
-// // This logic isn't perfect either. When we have two edges in that have different override sets, then we have to decide which set is correct.
-// // This function assumes the more specific override set is applicable, so if we have dependencies A->B->C and A->C
-// // and an override set that specifies what happens for C under A->B, this will work even if the new A->C edge comes along and tries to change
-// // the override set.
-// // The strictly correct logic is not to allow two edges with different overrides to point to the same node, because even if this node can satisfy
-// // both, one of its dependencies might need to be different depending on the edge leading to it.
-// // However, this might cause a lot of duplication, because the conflict in the dependencies might never actually happen.
-// function updateNodeOverrideSet (otherOverrideSet) {
-//   if (!this.overrides) {
-//     // Assuming there are any overrides at all, the overrides field is never undefined for any node at the end state of the tree.
-//     // So if the new edge's overrides is undefined it will be updated later. So we can wait with updating the node's overrides field.
-//     if (!otherOverrideSet) {
-//       return false
-//     }
-//     this.overrides = otherOverrideSet
-//     this.recalculateOutEdgesOverrides()
-//     return true
-//   }
-//   if (this.overrides.isEqual(otherOverrideSet)) {
-//     return false
-//   }
-//   const newOverrideSet = this.findSpecificOverrideSet(this.overrides, otherOverrideSet)
-//   if (newOverrideSet) {
-//     if (!this.overrides.isEqual(newOverrideSet)) {
-//       this.overrides = newOverrideSet
-//       this.recalculateOutEdgesOverrides()
-//       return true
-//     }
-//     return false
-//   }
-//   // This is an error condition. We can only get here if the new override set is in conflict with the existing.
-// }
+function findSpecificOverrideSet (first: OverrideSet | undefined, second: OverrideSet | undefined) {
+  let overrideSet = second
+  while (overrideSet) {
+    if (overrideSetsEqual(overrideSet, first)) {
+      return second
+    }
+    overrideSet = overrideSet.parent
+  }
+  overrideSet = first
+  while (overrideSet) {
+    if (overrideSetsEqual(overrideSet, second)) {
+      return first
+    }
+    overrideSet = overrideSet.parent
+  }
+  console.error('Conflicting override sets')
+}
+
+function recalculateOutEdgesOverrides (node: NodeClass) {
+  // For each edge out propagate the new overrides through.
+  for (const [, edge] of node.edgesOut) {
+    edge.reload(true)
+    if (edge.to) {
+      updateNodeOverrideSet(edge.to, edge.overrides)
+    }
+  }
+}
+
+function updateNodeOverrideSetDueToEdgeRemoval (node: NodeClass, other: OverrideSet) {
+  // If this edge's overrides isn't equal to this node's overrides, then removing it won't change newOverrideSet later.
+  if (!node.overrides || !overrideSetsEqual(node.overrides, other)) {
+    return false
+  }
+  let newOverrideSet
+  for (const edge of node.edgesIn) {
+    if (newOverrideSet) {
+      newOverrideSet = findSpecificOverrideSet(edge.overrides, newOverrideSet)
+    } else {
+      newOverrideSet = edge.overrides
+    }
+  }
+  if (overrideSetsEqual(node.overrides, newOverrideSet)) {
+    return false
+  }
+  node.overrides = newOverrideSet
+  if (node.overrides) {
+    // Optimization: if there's any override set at all, then no non-extraneous node has an empty override set. So if we temporarily have no
+    // override set (for example, we removed all the edges in), there's no use updating all the edges out right now. Let's just wait until
+    // we have an actual override set later.
+    recalculateOutEdgesOverrides(node)
+  }
+  return true
+}
+
+// This logic isn't perfect either. When we have two edges in that have different override sets, then we have to decide which set is correct.
+// This function assumes the more specific override set is applicable, so if we have dependencies A->B->C and A->C
+// and an override set that specifies what happens for C under A->B, this will work even if the new A->C edge comes along and tries to change
+// the override set.
+// The strictly correct logic is not to allow two edges with different overrides to point to the same node, because even if this node can satisfy
+// both, one of its dependencies might need to be different depending on the edge leading to it.
+// However, this might cause a lot of duplication, because the conflict in the dependencies might never actually happen.
+function updateNodeOverrideSet (node: NodeClass, otherOverrideSet: OverrideSet | undefined) {
+  if (!node.overrides) {
+    // Assuming there are any overrides at all, the overrides field is never undefined for any node at the end state of the tree.
+    // So if the new edge's overrides is undefined it will be updated later. So we can wait with updating the node's overrides field.
+    if (!otherOverrideSet) {
+      return false
+    }
+    node.overrides = otherOverrideSet
+    recalculateOutEdgesOverrides(node)
+    return true
+  }
+  const { overrides } = node
+  if (overrideSetsEqual(overrides, otherOverrideSet)) {
+    return false
+  }
+  const newOverrideSet = findSpecificOverrideSet(overrides, otherOverrideSet)
+  if (newOverrideSet) {
+    if (!overrideSetsEqual(overrides, newOverrideSet)) {
+      node.overrides = newOverrideSet
+      recalculateOutEdgesOverrides(node)
+      return true
+    }
+    return false
+  }
+  // This is an error condition. We can only get here if the new override set is in conflict with the existing.
+}
+
+function overrideSetsChildrenAreEqual(overrideSet: OverrideSet, other: OverrideSet) {
+  const { children } = overrideSet
+  const { children: otherChildren } = other
+  if (children.size !== otherChildren.size) {
+    return false
+  }
+  for (const key of children.keys()) {
+    if (!otherChildren.has(key)) {
+      return false
+    }
+    const child = <OverrideSet>children.get(key)
+    const otherChild = <OverrideSet>otherChildren.get(key)
+    if (child!.value !== otherChild!.value) {
+      return false
+    }
+    if (!overrideSetsChildrenAreEqual(child, otherChild)) {
+      return false
+    }
+  }
+  return true
+}
+
+function overrideSetsEqual (overrideSet: OverrideSet, other: OverrideSet | undefined) {
+  if (overrideSet === other) {
+    return true
+  }
+  if (!other) {
+    return false
+  }
+  if (overrideSet.key !== other.key || overrideSet.value !== other.value) {
+    return false
+  }
+  if (!overrideSetsChildrenAreEqual(overrideSet, other)) {
+    return false
+  }
+  if (!overrideSet.parent) {
+    return !other.parent
+  }
+  return overrideSetsEqual(overrideSet.parent, other.parent)
+}
 
 // An edge in the dependency graph
 // Represents a dependency relationship of some kind