Merge {With,Graph}{Successors,Predecessors} into {Successors,Predecessors}

Now with GAT!

Author: WaffleLapkin

compiler/rustc_borrowck/src/constraints/graph.rs

@@ -222,15 +222,10 @@ impl<'s, 'tcx, D: ConstraintGraphDirection> graph::DirectedGraph for RegionGraph
 }
 }
 
-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>{
+typeSuccessors<'g> = Successors<'s,'tcx,D>whereSelf:'g;
+
+fnsuccessors(&self,node:Self::Node) -> Self::Successors<'_>{
 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::Successors;
 use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::{
 self,BasicBlock,Body,CallReturnPlaces,Location,Place,TerminatorEdges,

compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs

@@ -2,7 +2,7 @@ use crate::constraints::ConstraintSccIndex;
 usecrate::RegionInferenceContext;
 use rustc_data_structures::fx::{FxIndexMap,FxIndexSet};
 use rustc_data_structures::graph::vec_graph::VecGraph;
-use rustc_data_structures::graph::WithSuccessors;
+use rustc_data_structures::graph::Successors;
 use rustc_middle::ty::RegionVid;
 use std::ops::Range;
 

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

@@ -1,5 +1,5 @@
 use rustc_data_structures::fx::{FxIndexMap,FxIndexSet};
-use rustc_data_structures::graph::WithSuccessors;
+use rustc_data_structures::graph::Successors;
 use rustc_index::bit_set::BitSet;
 use rustc_index::interval::IntervalSet;
 use rustc_infer::infer::canonical::QueryRegionConstraints;

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

@@ -1,19 +1,19 @@
-usesuper::{DirectedGraph,WithStartNode,WithSuccessors};
+usesuper::{DirectedGraph,Successors,WithStartNode};
 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>(
+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>(
+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>(
  result
 }
 
-fnpost_order_walk<G:DirectedGraph + WithSuccessors>(
+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>(
 }
 }
 
-pubfnreverse_post_order<G:DirectedGraph + WithSuccessors>(
+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>(
 /// A "depth-first search" iterator for a directed graph.
 pubstructDepthFirstSearch<'graph,G>
 where
-G: ?Sized + DirectedGraph + 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 + 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 + 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 + 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 + 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 + WithSuccessors,
+G: ?Sized + DirectedGraph + Successors,
 {
 pubfnnew(graph:&'graphG) -> Self{
 TriColorDepthFirstSearch{
@@ -278,7 +278,7 @@ where
 
 impl<G>TriColorDepthFirstSearch<'_,G>
 where
-G: ?Sized + DirectedGraph + WithSuccessors + WithStartNode,
+G: ?Sized + DirectedGraph + Successors + WithStartNode,
 {
 /// Performs a depth-first search, starting from `G::start_node()`.
 ///

compiler/rustc_data_structures/src/graph/mod.rs

@@ -20,55 +20,40 @@ pub trait WithNumEdges: DirectedGraph {
 fnnum_edges(&self) -> usize;
 }
 
-pubtraitWithSuccessors:DirectedGraph
-where
-Self:for<'graph>GraphSuccessors<'graph,Item = <SelfasDirectedGraph>::Node>,
-{
-fnsuccessors(&self,node:Self::Node) -> <SelfasGraphSuccessors<'_>>::Iter;
+pubtraitSuccessors:DirectedGraph{
+typeSuccessors<'g>:Iterator<Item = Self::Node>
+where
+Self:'g;
+
+fnsuccessors(&self,node:Self::Node) -> Self::Successors<'_>;
 
 fndepth_first_search(&self,from:Self::Node) -> iterate::DepthFirstSearch<'_,Self>{
  iterate::DepthFirstSearch::new(self).with_start_node(from)
 }
 }
 
-#[allow(unused_lifetimes)]
-pubtraitGraphSuccessors<'graph>{
-typeItem;
-typeIter:Iterator<Item = Self::Item>;
-}
+pubtraitPredecessors:DirectedGraph{
+typePredecessors<'g>:Iterator<Item = Self::Node>
+where
+Self:'g;
 
-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>;
+fnpredecessors(&self,node:Self::Node) -> Self::Predecessors<'_>;
 }
 
 pubtraitWithStartNode:DirectedGraph{
 fnstart_node(&self) -> Self::Node;
 }
 
-pubtraitControlFlowGraph:
-DirectedGraph + WithStartNode + WithPredecessors + WithSuccessors
-{
+pubtraitControlFlowGraph:DirectedGraph + WithStartNode + Predecessors + Successors{
 // convenient trait
 }
 
-impl<T>ControlFlowGraphforTwhere
-T:DirectedGraph + WithStartNode + WithPredecessors + WithSuccessors
-{
-}
+impl<T>ControlFlowGraphforTwhereT:DirectedGraph + WithStartNode + 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,
+G: ?Sized + DirectedGraph + WithStartNode + Successors,
 {
  iterate::TriColorDepthFirstSearch::new(graph)
 .run_from_start(&mut iterate::CycleDetector)

compiler/rustc_data_structures/src/graph/reference.rs

@@ -14,24 +14,18 @@ impl<'graph, G: WithStartNode> WithStartNode for &'graph G {
 }
 }
 
-impl<'graph,G:WithSuccessors>WithSuccessorsfor&'graphG{
-fnsuccessors(&self,node:Self::Node) -> <SelfasGraphSuccessors<'_>>::Iter{
+impl<'graph,G:Successors>Successorsfor&'graphG{
+typeSuccessors<'g> = G::Successors<'g>where'graph:'g;
+
+fnsuccessors(&self,node:Self::Node) -> Self::Successors<'_>{
 (**self).successors(node)
 }
 }
 
-impl<'graph,G:WithPredecessors>WithPredecessorsfor&'graphG{
-fnpredecessors(&self,node:Self::Node) -> <SelfasGraphPredecessors<'_>>::Iter{
+impl<'graph,G:Predecessors>Predecessorsfor&'graphG{
+typePredecessors<'g> = G::Predecessors<'g>where'graph:'g;
+
+fnpredecessors(&self,node:Self::Node) -> Self::Predecessors<'_>{
 (**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,WithSuccessors};
+usecrate::graph::{DirectedGraph,Successors,WithNumEdges};
 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> + WithSuccessors)) -> Self{
+pubfnnew(graph:&(implDirectedGraph<Node = N> + Successors)) -> Self{
 SccsConstruction::construct(graph)
 }
 
@@ -103,14 +103,10 @@ impl<N: Idx, S: Idx + Ord> WithNumEdges for Sccs<N, S> {
 }
 }
 
-impl<'graph,N:Idx,S:Idx>GraphSuccessors<'graph>forSccs<N,S>{
-typeItem = S;
+impl<N:Idx,S:Idx + Ord>SuccessorsforSccs<N,S>{
+typeSuccessors<'g> = std::iter::Cloned<std::slice::Iter<'g,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{
+fnsuccessors(&self,node:S) -> Self::Successors<'_>{
 self.successors(node).iter().cloned()
 }
 }
@@ -156,7 +152,7 @@ impl<S: Idx> SccData<S> {
 }
 }
 
-structSccsConstruction<'c,G:DirectedGraph + WithSuccessors,S:Idx>{
+structSccsConstruction<'c,G:DirectedGraph + Successors,S:Idx>{
 graph:&'cG,
 
 /// The state of each node; used during walk to record the stack
@@ -216,7 +212,7 @@ enum WalkReturn<S> {
 
 impl<'c,G,S>SccsConstruction<'c,G,S>
 where
-G:DirectedGraph + WithSuccessors,
+G:DirectedGraph + Successors,
 S:Idx,
 {
 /// Identifies SCCs in the graph `G` and computes the resulting

compiler/rustc_data_structures/src/graph/tests.rs

@@ -48,24 +48,18 @@ impl WithStartNode for TestGraph {
 }
 }
 
-implWithPredecessorsforTestGraph{
-fnpredecessors(&self,node:usize) -> <SelfasGraphPredecessors<'_>>::Iter{
+implPredecessorsforTestGraph{
+typePredecessors<'g> = iter::Cloned<slice::Iter<'g,usize>>;
+
+fnpredecessors(&self,node:usize) -> Self::Predecessors<'_>{
 self.predecessors[&node].iter().cloned()
 }
 }
 
-implWithSuccessorsforTestGraph{
-fnsuccessors(&self,node:usize) -> <SelfasGraphSuccessors<'_>>::Iter{
+implSuccessorsforTestGraph{
+typeSuccessors<'g> = iter::Cloned<slice::Iter<'g,usize>>;
+
+fnsuccessors(&self,node:usize) -> Self::Successors<'_>{
 self.successors[&node].iter().cloned()
 }
 }
-
-impl<'graph>GraphPredecessors<'graph>forTestGraph{
-typeItem = usize;
-typeIter = iter::Cloned<slice::Iter<'graph,usize>>;
-}
-
-impl<'graph>GraphSuccessors<'graph>forTestGraph{
-typeItem = usize;
-typeIter = iter::Cloned<slice::Iter<'graph,usize>>;
-}

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

@@ -1,4 +1,4 @@
-usecrate::graph::{DirectedGraph,GraphSuccessors,WithNumEdges,WithSuccessors};
+usecrate::graph::{DirectedGraph,Successors,WithNumEdges};
 use rustc_index::{Idx,IndexVec};
 
 #[cfg(test)]
@@ -92,14 +92,10 @@ impl<N: Idx> WithNumEdges for VecGraph<N> {
 }
 }
 
-impl<'graph,N:Idx>GraphSuccessors<'graph>forVecGraph<N>{
-typeItem = N;
+impl<N:Idx + Ord>SuccessorsforVecGraph<N>{
+typeSuccessors<'g> = std::iter::Cloned<std::slice::Iter<'g,N>>;
 
-typeIter = std::iter::Cloned<std::slice::Iter<'graph,N>>;
-}
-
-impl<N:Idx + Ord>WithSuccessorsforVecGraph<N>{
-fnsuccessors(&self,node:N) -> <SelfasGraphSuccessors<'_>>::Iter{
+fnsuccessors(&self,node:N) -> Self::Successors<'_>{
 self.successors(node).iter().cloned()
 }
 }