Rollup merge of #123934 - WaffleLapkin:graph-mini-refactor, r=fmease

`rustc_data_structures::graph` mini refactor
Who doesn't love to breathe dust from the ancient times?

Author: jieyouxu

compiler/rustc_borrowck/src/constraints/graph.rs

@@ -216,23 +216,14 @@ impl<'s, 'tcx, D: ConstraintGraphDirection> Iterator for Successors<'s, 'tcx, D>
 
 impl<'s,'tcx,D:ConstraintGraphDirection> graph::DirectedGraphforRegionGraph<'s,'tcx,D>{
 typeNode = RegionVid;
-}
 
-impl<'s,'tcx,D:ConstraintGraphDirection> graph::WithNumNodesforRegionGraph<'s,'tcx,D>{
 fnnum_nodes(&self) -> usize{
 self.constraint_graph.first_constraints.len()
 }
 }
 
-impl<'s,'tcx,D:ConstraintGraphDirection> graph::WithSuccessorsforRegionGraph<'s,'tcx,D>{
-fnsuccessors(&self,node:Self::Node) -> <Selfas graph::GraphSuccessors<'_>>::Iter{
+impl<'s,'tcx,D:ConstraintGraphDirection> graph::SuccessorsforRegionGraph<'s,'tcx,D>{
+fnsuccessors(&self,node:Self::Node) -> implIterator<Item = Self::Node>{
 self.outgoing_regions(node)
 }
 }
-
-impl<'s,'tcx,D:ConstraintGraphDirection> graph::GraphSuccessors<'_>
-forRegionGraph<'s,'tcx,D>
-{
-typeItem = RegionVid;
-typeIter = Successors<'s,'tcx,D>;
-}

compiler/rustc_borrowck/src/dataflow.rs

@@ -1,5 +1,5 @@
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::graph::WithSuccessors;
+use rustc_data_structures::graph;
 use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::{
 self,BasicBlock,Body,CallReturnPlaces,Location,Place,TerminatorEdges,
@@ -262,7 +262,7 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
 
 // We first handle the cases where the loan doesn't go out of scope, depending on the issuing
 // region's successors.
-for successor inself.regioncx.region_graph().depth_first_search(issuing_region){
+for successor ingraph::depth_first_search(&self.regioncx.region_graph(),issuing_region){
 // 1. Via applied member constraints
 //
 // The issuing region can flow into the choice regions, and they are either:

compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs

@@ -1,8 +1,8 @@
 usecrate::constraints::ConstraintSccIndex;
 usecrate::RegionInferenceContext;
 use rustc_data_structures::fx::{FxIndexMap,FxIndexSet};
+use rustc_data_structures::graph;
 use rustc_data_structures::graph::vec_graph::VecGraph;
-use rustc_data_structures::graph::WithSuccessors;
 use rustc_middle::ty::RegionVid;
 use std::ops::Range;
 
@@ -23,8 +23,7 @@ impl ReverseSccGraph {
 scc0:ConstraintSccIndex,
 ) -> implIterator<Item = RegionVid> + 'a{
 letmut duplicates = FxIndexSet::default();
-self.graph
-.depth_first_search(scc0)
+ graph::depth_first_search(&self.graph, scc0)
 .flat_map(move |scc1| {
 self.scc_regions
 .get(&scc1)

compiler/rustc_borrowck/src/type_check/liveness/trace.rs

@@ -1,5 +1,4 @@
 use rustc_data_structures::fx::{FxIndexMap,FxIndexSet};
-use rustc_data_structures::graph::WithSuccessors;
 use rustc_index::bit_set::BitSet;
 use rustc_index::interval::IntervalSet;
 use rustc_infer::infer::canonical::QueryRegionConstraints;
@@ -64,7 +63,10 @@ pub(super) fn trace<'mir, 'tcx>(
 // Traverse each issuing region's constraints, and record the loan as flowing into the
 // outlived region.
 for(loan, issuing_region_data)in borrow_set.iter_enumerated(){
-for succ in region_graph.depth_first_search(issuing_region_data.region){
+for succ in rustc_data_structures::graph::depth_first_search(
+&region_graph,
+ issuing_region_data.region,
+){
 // We don't need to mention that a loan flows into its issuing region.
 if succ == issuing_region_data.region{
 continue;

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

@@ -1,19 +1,19 @@
-usesuper::{DirectedGraph,WithNumNodes,WithStartNode,WithSuccessors};
+usesuper::{DirectedGraph,StartNode,Successors};
 use rustc_index::bit_set::BitSet;
 use rustc_index::{IndexSlice,IndexVec};
 use std::ops::ControlFlow;
 
 #[cfg(test)]
 mod tests;
 
-pubfnpost_order_from<G:DirectedGraph + WithSuccessors + WithNumNodes>(
+pubfnpost_order_from<G:DirectedGraph + Successors>(
 graph:&G,
 start_node:G::Node,
 ) -> Vec<G::Node>{
 post_order_from_to(graph, start_node,None)
 }
 
-pubfnpost_order_from_to<G:DirectedGraph + WithSuccessors + WithNumNodes>(
+pubfnpost_order_from_to<G:DirectedGraph + Successors>(
 graph:&G,
 start_node:G::Node,
 end_node:Option<G::Node>,
@@ -27,7 +27,7 @@ pub fn post_order_from_to<G: DirectedGraph + WithSuccessors + WithNumNodes>(
  result
 }
 
-fnpost_order_walk<G:DirectedGraph + WithSuccessors + WithNumNodes>(
+fnpost_order_walk<G:DirectedGraph + Successors>(
 graph:&G,
 node:G::Node,
 result:&mutVec<G::Node>,
@@ -60,7 +60,7 @@ fn post_order_walk<G: DirectedGraph + WithSuccessors + WithNumNodes>(
 }
 }
 
-pubfnreverse_post_order<G:DirectedGraph + WithSuccessors + WithNumNodes>(
+pubfnreverse_post_order<G:DirectedGraph + Successors>(
 graph:&G,
 start_node:G::Node,
 ) -> Vec<G::Node>{
@@ -72,7 +72,7 @@ pub fn reverse_post_order<G: DirectedGraph + WithSuccessors + WithNumNodes>(
 /// A "depth-first search" iterator for a directed graph.
 pubstructDepthFirstSearch<'graph,G>
 where
-G: ?Sized + DirectedGraph + WithNumNodes + WithSuccessors,
+G: ?Sized + DirectedGraph + Successors,
 {
 graph:&'graphG,
 stack:Vec<G::Node>,
@@ -81,7 +81,7 @@ where
 
 impl<'graph,G>DepthFirstSearch<'graph,G>
 where
-G: ?Sized + DirectedGraph + WithNumNodes + WithSuccessors,
+G: ?Sized + DirectedGraph + Successors,
 {
 pubfnnew(graph:&'graphG) -> Self{
 Self{ graph,stack:vec![],visited:BitSet::new_empty(graph.num_nodes())}
@@ -127,7 +127,7 @@ where
 
 impl<G> std::fmt::DebugforDepthFirstSearch<'_,G>
 where
-G: ?Sized + DirectedGraph + WithNumNodes + WithSuccessors,
+G: ?Sized + DirectedGraph + Successors,
 {
 fnfmt(&self,fmt:&mut std::fmt::Formatter<'_>) -> std::fmt::Result{
 letmut f = fmt.debug_set();
@@ -140,7 +140,7 @@ where
 
 impl<G>IteratorforDepthFirstSearch<'_,G>
 where
-G: ?Sized + DirectedGraph + WithNumNodes + WithSuccessors,
+G: ?Sized + DirectedGraph + Successors,
 {
 typeItem = G::Node;
 
@@ -201,7 +201,7 @@ struct Event<N> {
 /// [CLR]: https://en.wikipedia.org/wiki/Introduction_to_Algorithms
 pubstructTriColorDepthFirstSearch<'graph,G>
 where
-G: ?Sized + DirectedGraph + WithNumNodes + WithSuccessors,
+G: ?Sized + DirectedGraph + Successors,
 {
 graph:&'graphG,
 stack:Vec<Event<G::Node>>,
@@ -211,7 +211,7 @@ where
 
 impl<'graph,G>TriColorDepthFirstSearch<'graph,G>
 where
-G: ?Sized + DirectedGraph + WithNumNodes + WithSuccessors,
+G: ?Sized + DirectedGraph + Successors,
 {
 pubfnnew(graph:&'graphG) -> Self{
 TriColorDepthFirstSearch{
@@ -278,7 +278,7 @@ where
 
 impl<G>TriColorDepthFirstSearch<'_,G>
 where
-G: ?Sized + DirectedGraph + WithNumNodes + WithSuccessors + WithStartNode,
+G: ?Sized + DirectedGraph + Successors + StartNode,
 {
 /// Performs a depth-first search, starting from `G::start_node()`.
 ///

compiler/rustc_data_structures/src/graph/mod.rs

@@ -12,70 +12,43 @@ mod tests;
 
 pubtraitDirectedGraph{
 typeNode:Idx;
-}
 
-pubtraitWithNumNodes:DirectedGraph{
 fnnum_nodes(&self) -> usize;
 }
 
-pubtraitWithNumEdges:DirectedGraph{
+pubtraitNumEdges:DirectedGraph{
 fnnum_edges(&self) -> usize;
 }
 
-pubtraitWithSuccessors:DirectedGraph
-where
-Self:for<'graph>GraphSuccessors<'graph,Item = <SelfasDirectedGraph>::Node>,
-{
-fnsuccessors(&self,node:Self::Node) -> <SelfasGraphSuccessors<'_>>::Iter;
-
-fndepth_first_search(&self,from:Self::Node) -> iterate::DepthFirstSearch<'_,Self>
-where
-Self:WithNumNodes,
-{
- iterate::DepthFirstSearch::new(self).with_start_node(from)
-}
-}
-
-#[allow(unused_lifetimes)]
-pubtraitGraphSuccessors<'graph>{
-typeItem;
-typeIter:Iterator<Item = Self::Item>;
-}
-
-pubtraitWithPredecessors:DirectedGraph
-where
-Self:for<'graph>GraphPredecessors<'graph,Item = <SelfasDirectedGraph>::Node>,
-{
-fnpredecessors(&self,node:Self::Node) -> <SelfasGraphPredecessors<'_>>::Iter;
-}
-
-#[allow(unused_lifetimes)]
-pubtraitGraphPredecessors<'graph>{
-typeItem;
-typeIter:Iterator<Item = Self::Item>;
-}
-
-pubtraitWithStartNode:DirectedGraph{
+pubtraitStartNode:DirectedGraph{
 fnstart_node(&self) -> Self::Node;
 }
 
-pubtraitControlFlowGraph:
-DirectedGraph + WithStartNode + WithPredecessors + WithSuccessors + WithNumNodes
-{
-// convenient trait
+pubtraitSuccessors:DirectedGraph{
+fnsuccessors(&self,node:Self::Node) -> implIterator<Item = Self::Node>;
 }
 
-impl<T>ControlFlowGraphforTwhere
-T:DirectedGraph + WithStartNode + WithPredecessors + WithSuccessors + WithNumNodes
-{
+pubtraitPredecessors:DirectedGraph{
+fnpredecessors(&self,node:Self::Node) -> implIterator<Item = Self::Node>;
 }
 
+/// Alias for [`DirectedGraph`] + [`StartNode`] + [`Predecessors`] + [`Successors`].
+pubtraitControlFlowGraph:DirectedGraph + StartNode + Predecessors + Successors{}
+impl<T>ControlFlowGraphforTwhereT:DirectedGraph + StartNode + Predecessors + Successors{}
+
 /// Returns `true` if the graph has a cycle that is reachable from the start node.
 pubfnis_cyclic<G>(graph:&G) -> bool
 where
-G: ?Sized + DirectedGraph + WithStartNode + WithSuccessors + WithNumNodes,
+G: ?Sized + DirectedGraph + StartNode + Successors,
 {
  iterate::TriColorDepthFirstSearch::new(graph)
 .run_from_start(&mut iterate::CycleDetector)
 .is_some()
 }
+
+pubfndepth_first_search<G>(graph:&G,from:G::Node) -> iterate::DepthFirstSearch<'_,G>
+where
+G: ?Sized + Successors,
+{
+ iterate::DepthFirstSearch::new(graph).with_start_node(from)
+}

compiler/rustc_data_structures/src/graph/reference.rs

@@ -2,38 +2,26 @@ use super::*;
 
 impl<'graph,G:DirectedGraph>DirectedGraphfor&'graphG{
 typeNode = G::Node;
-}
 
-impl<'graph,G:WithNumNodes>WithNumNodesfor&'graphG{
 fnnum_nodes(&self) -> usize{
 (**self).num_nodes()
 }
 }
 
-impl<'graph,G:WithStartNode>WithStartNodefor&'graphG{
+impl<'graph,G:StartNode>StartNodefor&'graphG{
 fnstart_node(&self) -> Self::Node{
 (**self).start_node()
 }
 }
 
-impl<'graph,G:WithSuccessors>WithSuccessorsfor&'graphG{
-fnsuccessors(&self,node:Self::Node) -> <SelfasGraphSuccessors<'_>>::Iter{
+impl<'graph,G:Successors>Successorsfor&'graphG{
+fnsuccessors(&self,node:Self::Node) -> implIterator<Item = Self::Node>{
 (**self).successors(node)
 }
 }
 
-impl<'graph,G:WithPredecessors>WithPredecessorsfor&'graphG{
-fnpredecessors(&self,node:Self::Node) -> <SelfasGraphPredecessors<'_>>::Iter{
+impl<'graph,G:Predecessors>Predecessorsfor&'graphG{
+fnpredecessors(&self,node:Self::Node) -> implIterator<Item = Self::Node>{
 (**self).predecessors(node)
 }
 }
-
-impl<'iter,'graph,G:WithPredecessors>GraphPredecessors<'iter>for&'graphG{
-typeItem = G::Node;
-typeIter = <GasGraphPredecessors<'iter>>::Iter;
-}
-
-impl<'iter,'graph,G:WithSuccessors>GraphSuccessors<'iter>for&'graphG{
-typeItem = G::Node;
-typeIter = <GasGraphSuccessors<'iter>>::Iter;
-}

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

@@ -7,7 +7,7 @@
 
 usecrate::fx::FxHashSet;
 usecrate::graph::vec_graph::VecGraph;
-usecrate::graph::{DirectedGraph,GraphSuccessors,WithNumEdges,WithNumNodes,WithSuccessors};
+usecrate::graph::{DirectedGraph,NumEdges,Successors};
 use rustc_index::{Idx,IndexSlice,IndexVec};
 use std::ops::Range;
 
@@ -39,7 +39,7 @@ pub struct SccData<S: Idx> {
 }
 
 impl<N:Idx,S:Idx + Ord>Sccs<N,S>{
-pubfnnew(graph:&(implDirectedGraph<Node = N> + WithNumNodes + WithSuccessors)) -> Self{
+pubfnnew(graph:&(implDirectedGraph<Node = N> + Successors)) -> Self{
 SccsConstruction::construct(graph)
 }
 
@@ -89,30 +89,22 @@ impl<N: Idx, S: Idx + Ord> Sccs<N, S> {
 }
 }
 
-impl<N:Idx,S:Idx>DirectedGraphforSccs<N,S>{
+impl<N:Idx,S:Idx + Ord>DirectedGraphforSccs<N,S>{
 typeNode = S;
-}
 
-impl<N:Idx,S:Idx + Ord>WithNumNodesforSccs<N,S>{
 fnnum_nodes(&self) -> usize{
 self.num_sccs()
 }
 }
 
-impl<N:Idx,S:Idx>WithNumEdgesforSccs<N,S>{
+impl<N:Idx,S:Idx + Ord>NumEdgesforSccs<N,S>{
 fnnum_edges(&self) -> usize{
 self.scc_data.all_successors.len()
 }
 }
 
-impl<'graph,N:Idx,S:Idx>GraphSuccessors<'graph>forSccs<N,S>{
-typeItem = S;
-
-typeIter = std::iter::Cloned<std::slice::Iter<'graph,S>>;
-}
-
-impl<N:Idx,S:Idx + Ord>WithSuccessorsforSccs<N,S>{
-fnsuccessors(&self,node:S) -> <SelfasGraphSuccessors<'_>>::Iter{
+impl<N:Idx,S:Idx + Ord>SuccessorsforSccs<N,S>{
+fnsuccessors(&self,node:S) -> implIterator<Item = Self::Node>{
 self.successors(node).iter().cloned()
 }
 }
@@ -158,7 +150,7 @@ impl<S: Idx> SccData<S> {
 }
 }
 
-structSccsConstruction<'c,G:DirectedGraph + WithNumNodes + WithSuccessors,S:Idx>{
+structSccsConstruction<'c,G:DirectedGraph + Successors,S:Idx>{
 graph:&'cG,
 
 /// The state of each node; used during walk to record the stack
@@ -218,7 +210,7 @@ enum WalkReturn<S> {
 
 impl<'c,G,S>SccsConstruction<'c,G,S>
 where
-G:DirectedGraph + WithNumNodes + WithSuccessors,
+G:DirectedGraph + Successors,
 S:Idx,
 {
 /// Identifies SCCs in the graph `G` and computes the resulting