Switch SCC annotations to a update style; it's more ergonomic

Author: amandasystems

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -76,12 +76,10 @@ pub(crate) struct PlaceholderReachability {
 
 impl PlaceholderReachability {
     /// Merge the reachable placeholders of two graph components.
-    fn merge(self, other: PlaceholderReachability) -> PlaceholderReachability {
-        PlaceholderReachability {
-            max_universe: self.max_universe.max(other.max_universe),
-            min_placeholder: self.min_placeholder.min(other.min_placeholder),
-            max_placeholder: self.max_placeholder.max(other.max_placeholder),
-        }
+    fn merge(&mut self, other: &PlaceholderReachability) {
+        self.max_universe = self.max_universe.max(other.max_universe);
+        self.min_placeholder = self.min_placeholder.min(other.min_placeholder);
+        self.max_placeholder = self.max_placeholder.max(other.max_placeholder);
     }
 }
 
@@ -192,34 +190,26 @@ impl RegionTracker {
 }
 
 impl scc::Annotation for RegionTracker {
-    fn merge_scc(self, other: Self) -> Self {
+    fn update_scc(&mut self, other: &Self) {
         trace!("{:?} << {:?}", self.representative, other.representative);
-        Self {
-            representative: self.representative.min(other.representative),
-            is_placeholder: self.is_placeholder.max(other.is_placeholder),
-            ..self.merge_reached(other)
-        }
+        self.representative = self.representative.min(other.representative);
+        self.is_placeholder = self.is_placeholder.max(other.is_placeholder);
+        self.update_reachable(other); // SCC membership implies reachability.
     }
 
     #[inline(always)]
-    fn merge_reached(self, other: Self) -> Self {
-        Self {
-            worst_existential: self
-                .worst_existential
-                .xor(other.worst_existential)
-                .or_else(|| self.worst_existential.min(other.worst_existential)),
-            min_max_nameable_universe: self
-                .min_max_nameable_universe
-                .min(other.min_max_nameable_universe),
-            reachable_placeholders: match (
-                self.reachable_placeholders,
-                other.reachable_placeholders,
-            ) {
-                (None, x) | (x, None) => x,
-                (Some(ours), Some(theirs)) => Some(ours.merge(theirs)),
-            },
-            ..self
-        }
+    fn update_reachable(&mut self, other: &Self) {
+        self.worst_existential = self
+            .worst_existential
+            .xor(other.worst_existential)
+            .or_else(|| self.worst_existential.min(other.worst_existential));
+        self.min_max_nameable_universe =
+            self.min_max_nameable_universe.min(other.min_max_nameable_universe);
+        match (self.reachable_placeholders.as_mut(), other.reachable_placeholders.as_ref()) {
+            (None, None) | (Some(_), None) => (),
+            (None, Some(theirs)) => self.reachable_placeholders = Some(*theirs),
+            (Some(ours), Some(theirs)) => ours.merge(theirs),
+        };
     }
 }
 
@@ -461,13 +451,12 @@ pub(crate) fn rewrite_placeholder_outlives<'tcx>(
             //   inference since `p` isn't empty)
             // - another placeholder (will flag an error above, but will reach here).
             //
-            // To avoid adding the invalid constraint "'p: 'static` due to `'p` being
+            // To avoid adding the invalid constraint "`'p: 'static` due to `'p` being
             // unnameable from the SCC represented by `'p`", we nope out early here
             // at no risk of soundness issues since at this point all paths lead
             // to an error.
             continue;
         }
-
         // This SCC outlives a placeholder it can't name and must outlive 'static.
 
         // FIXME: if we can extract a useful blame span here, future error

compiler/rustc_data_structures/src/graph/scc/mod.rs

@@ -27,26 +27,18 @@ mod tests;
 /// the max/min element of the SCC, or all of the above.
 ///
 /// Concretely, the both merge operations must commute, e.g. where `merge`
-/// is `merge_scc` and `merge_reached`: `a.merge(b) == b.merge(a)`
+/// is `update_scc` and `update_reached`: `a.merge(b) == b.merge(a)`
 ///
 /// In general, what you want is probably always min/max according
 /// to some ordering, potentially with side constraints (min x such
 /// that P holds).
 pub trait Annotation: Debug + Copy {
     /// Merge two existing annotations into one during
-    /// path compression.o
-    fn merge_scc(self, other: Self) -> Self;
+    /// path compression.
+    fn update_scc(&mut self, other: &Self);
 
     /// Merge a successor into this annotation.
-    fn merge_reached(self, other: Self) -> Self;
-
-    fn update_scc(&mut self, other: Self) {
-        *self = self.merge_scc(other)
-    }
-
-    fn update_reachable(&mut self, other: Self) {
-        *self = self.merge_reached(other)
-    }
+    fn update_reachable(&mut self, other: &Self);
 }
 
 /// An accumulator for annotations.
@@ -70,12 +62,8 @@ impl<N: Idx, S: Idx + Ord> Annotations<N> for NoAnnotations<S> {
 
 /// The empty annotation, which does nothing.
 impl Annotation for () {
-    fn merge_reached(self, _other: Self) -> Self {
-        ()
-    }
-    fn merge_scc(self, _other: Self) -> Self {
-        ()
-    }
+    fn update_reachable(&mut self, _other: &Self) {}
+    fn update_scc(&mut self, _other: &Self) {}
 }
 
 /// Strongly connected components (SCC) of a graph. The type `N` is
@@ -614,7 +602,7 @@ where
                             *min_depth = successor_min_depth;
                             *min_cycle_root = successor_node;
                         }
-                        current_component_annotation.update_scc(successor_annotation);
+                        current_component_annotation.update_scc(&successor_annotation);
                     }
                     // The starting node `node` is succeeded by a fully identified SCC
                     // which is now added to the set under `scc_index`.
@@ -629,7 +617,7 @@ where
                         // the `successors_stack` for later.
                         trace!(?node, ?successor_scc_index);
                         successors_stack.push(successor_scc_index);
-                        current_component_annotation.update_reachable(successor_annotation);
+                        current_component_annotation.update_reachable(&successor_annotation);
                     }
                     // `node` has no more (direct) successors; search recursively.
                     None => {

compiler/rustc_data_structures/src/graph/scc/tests.rs

@@ -32,12 +32,12 @@ impl Maxes {
 }
 
 impl Annotation for MaxReached {
-    fn merge_scc(self, other: Self) -> Self {
-        Self(std::cmp::max(other.0, self.0))
+    fn update_scc(&mut self, other: &Self) {
+        self.0 = self.0.max(other.0);
     }
 
-    fn merge_reached(self, other: Self) -> Self {
-        Self(std::cmp::max(other.0, self.0))
+    fn update_reachable(&mut self, other: &Self) {
+        self.0 = self.0.max(other.0);
     }
 }
 
@@ -75,13 +75,12 @@ impl Annotations<usize> for MinMaxes {
 }
 
 impl Annotation for MinMaxIn {
-    fn merge_scc(self, other: Self) -> Self {
-        Self { min: std::cmp::min(self.min, other.min), max: std::cmp::max(self.max, other.max) }
+    fn update_scc(&mut self, other: &Self) {
+        self.min = self.min.min(other.min);
+        self.max = self.max.max(other.max);
     }
 
-    fn merge_reached(self, _other: Self) -> Self {
-        self
-    }
+    fn update_reachable(&mut self, _other: &Self) {}
 }
 
 #[test]