rustc_metadata: Cleanup generation of crate dependency lists

src/librustc_metadata/creader.rs

@@ -807,7 +807,7 @@ impl<'a> CrateLoader<'a> {
         // Before we inject any dependencies, make sure we don't inject a
         // circular dependency by validating that this crate doesn't
         // transitively depend on any crates satisfying `needs_dep`.
-        for dep in self.cstore.crate_dependencies_in_rpo(krate) {
+        for dep in self.cstore.crate_dependencies_in_reverse_postorder(krate) {
             let data = self.cstore.get_crate_data(dep);
             if needs_dep(&data) {
                 self.sess.err(&format!("the crate `{}` cannot depend \

src/librustc_metadata/cstore.rs

@@ -5,7 +5,7 @@ use crate::rmeta::CrateMetadata;
 
 use rustc_data_structures::sync::Lrc;
 use rustc_index::vec::IndexVec;
-use rustc::hir::def_id::CrateNum;
+use rustc::hir::def_id::{LOCAL_CRATE, CrateNum};
 use syntax::ast;
 use syntax::edition::Edition;
 use syntax::expand::allocator::AllocatorKind;
@@ -55,45 +55,40 @@ impl CStore {
         self.metas[cnum] = Some(Lrc::new(data));
     }
 
-    crate fn iter_crate_data<I>(&self, mut i: I)
+    crate fn iter_crate_data(&self, mut f: impl FnMut(CrateNum, &CrateMetadata)) {
-        where I: FnMut(CrateNum, &CrateMetadata)
+        for (cnum, data) in self.metas.iter_enumerated() {
-    {
+            if let Some(data) = data {
-        for (k, v) in self.metas.iter_enumerated() {
+                f(cnum, data);
-            if let &Some(ref v) = v {
-                i(k, v);
             }
         }
     }
 
-    crate fn crate_dependencies_in_rpo(&self, krate: CrateNum) -> Vec<CrateNum> {
+    fn push_dependencies_in_postorder(&self, deps: &mut Vec<CrateNum>, cnum: CrateNum) {
-        let mut ordering = Vec::new();
+        if !deps.contains(&cnum) {
-        self.push_dependencies_in_postorder(&mut ordering, krate);
+            let data = self.get_crate_data(cnum);
-        ordering.reverse();
+            for &dep in data.dependencies.borrow().iter() {
-        ordering
+                if dep != cnum {
+                    self.push_dependencies_in_postorder(deps, dep);
+                }
+            }
+
+            deps.push(cnum);
+        }
     }
 
-    crate fn push_dependencies_in_postorder(&self, ordering: &mut Vec<CrateNum>, krate: CrateNum) {
+    crate fn crate_dependencies_in_postorder(&self, cnum: CrateNum) -> Vec<CrateNum> {
-        if ordering.contains(&krate) {
+        let mut deps = Vec::new();
-            return;
+        if cnum == LOCAL_CRATE {
+            self.iter_crate_data(|cnum, _| self.push_dependencies_in_postorder(&mut deps, cnum));
+        } else {
+            self.push_dependencies_in_postorder(&mut deps, cnum);
         }
-
+        deps
-        let data = self.get_crate_data(krate);
-        for &dep in data.dependencies.borrow().iter() {
-            if dep != krate {
-                self.push_dependencies_in_postorder(ordering, dep);
-            }
-        }
-
-        ordering.push(krate);
     }
 
-    crate fn do_postorder_cnums_untracked(&self) -> Vec<CrateNum> {
+    crate fn crate_dependencies_in_reverse_postorder(&self, cnum: CrateNum) -> Vec<CrateNum> {
-        let mut ordering = Vec::new();
+        let mut deps = self.crate_dependencies_in_postorder(cnum);
-        for (num, v) in self.metas.iter_enumerated() {
+        deps.reverse();
-            if let &Some(_) = v {
+        deps
-                self.push_dependencies_in_postorder(&mut ordering, num);
-            }
-        }
-        return ordering
     }
 }

src/librustc_metadata/rmeta/decoder/cstore_impl.rs

@@ -517,7 +517,7 @@ impl CrateStore for cstore::CStore {
     }
 
     fn postorder_cnums_untracked(&self) -> Vec<CrateNum> {
-        self.do_postorder_cnums_untracked()
+        self.crate_dependencies_in_postorder(LOCAL_CRATE)
     }
 
     fn encode_metadata(&self, tcx: TyCtxt<'_>) -> EncodedMetadata {