auto merge of #11370 : alexcrichton/rust/issue-10465, r=pwalton

Turned out to be a 2-line fix, but the compiler fallout was huge.

Author: bors

src/libextra/dlist.rs

@@ -625,43 +625,43 @@ impl<A: Clone> Clone for DList<A> {
 }
 
 #[cfg(test)]
-pub fn check_links<T>(list: &DList<T>) {
-    let mut len = 0u;
-    let mut last_ptr: Option<&Node<T>> = None;
-    let mut node_ptr: &Node<T>;
-    match list.list_head {
-        None => { assert_eq!(0u, list.length); return }
-        Some(ref node) => node_ptr = &**node,
-    }
-    loop {
-        match (last_ptr, node_ptr.prev.resolve_immut()) {
-            (None   , None      ) => {}
-            (None   , _         ) => fail!("prev link for list_head"),
-            (Some(p), Some(pptr)) => {
-                assert_eq!(p as *Node<T>, pptr as *Node<T>);
-            }
-            _ => fail!("prev link is none, not good"),
+mod tests {
+    use container::Deque;
+    use extra::test;
+    use std::rand;
+    use super::{DList, Node, ListInsertion};
+
+    pub fn check_links<T>(list: &DList<T>) {
+        let mut len = 0u;
+        let mut last_ptr: Option<&Node<T>> = None;
+        let mut node_ptr: &Node<T>;
+        match list.list_head {
+            None => { assert_eq!(0u, list.length); return }
+            Some(ref node) => node_ptr = &**node,
         }
-        match node_ptr.next {
-            Some(ref next) => {
-                last_ptr = Some(node_ptr);
-                node_ptr = &**next;
-                len += 1;
+        loop {
+            match (last_ptr, node_ptr.prev.resolve_immut()) {
+                (None   , None      ) => {}
+                (None   , _         ) => fail!("prev link for list_head"),
+                (Some(p), Some(pptr)) => {
+                    assert_eq!(p as *Node<T>, pptr as *Node<T>);
+                }
+                _ => fail!("prev link is none, not good"),
             }
-            None => {
-                len += 1;
-                break;
+            match node_ptr.next {
+                Some(ref next) => {
+                    last_ptr = Some(node_ptr);
+                    node_ptr = &**next;
+                    len += 1;
+                }
+                None => {
+                    len += 1;
+                    break;
+                }
             }
         }
+        assert_eq!(len, list.length);
     }
-    assert_eq!(len, list.length);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::rand;
-    use extra::test;
 
     #[test]
     fn test_basic() {

src/libextra/json.rs

@@ -1333,11 +1333,10 @@ impl to_str::ToStr for Error {
 
 #[cfg(test)]
 mod tests {
-
     use super::*;
 
     use std::io;
-    use serialize::Decodable;
+    use serialize::{Encodable, Decodable};
     use treemap::TreeMap;
 
     #[deriving(Eq, Encodable, Decodable)]

src/libextra/lib.rs

@@ -34,10 +34,6 @@ Rust extras are part of the standard Rust distribution.
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 
-use std::str::{StrSlice, OwnedStr};
-
-pub use std::os;
-
 // Utility modules
 
 pub mod c_vec;
@@ -108,12 +104,4 @@ pub mod serialize;
 pub mod extra {
     pub use serialize;
     pub use test;
-
-    // For bootstrapping.
-    pub use std::clone;
-    pub use std::condition;
-    pub use std::cmp;
-    pub use std::unstable;
-    pub use std::str;
-    pub use std::os;
 }

src/libextra/num/bigint.rs

@@ -1434,6 +1434,7 @@ impl BigInt {
 #[cfg(test)]
 mod biguint_tests {
     use super::*;
+    use super::RandBigInt;
 
     use std::cmp::{Less, Equal, Greater};
     use std::i64;
@@ -2090,6 +2091,7 @@ mod biguint_tests {
 #[cfg(test)]
 mod bigint_tests {
     use super::*;
+    use super::RandBigInt;
 
     use std::cmp::{Less, Equal, Greater};
     use std::i64;

src/libextra/ringbuf.rs

@@ -404,10 +404,11 @@ impl<A> Extendable<A> for RingBuf<A> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use container::Deque;
+    use extra::test;
     use std::clone::Clone;
     use std::cmp::Eq;
-    use extra::test;
+    use super::RingBuf;
 
     #[test]
     fn test_simple() {

src/libextra/stats.rs

@@ -432,7 +432,6 @@ pub fn freq_count<T: Iterator<U>, U: Eq+Hash>(mut iter: T) -> hashmap::HashMap<U
 
 #[cfg(test)]
 mod tests {
-
     use stats::Stats;
     use stats::Summary;
     use stats::write_5_number_summary;
@@ -1018,6 +1017,7 @@ mod tests {
 mod bench {
     use extra::test::BenchHarness;
     use std::vec;
+    use stats::Stats;
 
     #[bench]
     fn sum_three_items(bh: &mut BenchHarness) {

src/librustc/driver/driver.rs

@@ -1134,6 +1134,7 @@ mod test {
 
     use extra::getopts::groups::getopts;
     use syntax::attr;
+    use syntax::attr::AttrMetaMethods;
     use syntax::diagnostic;
 
     // When the user supplies --test we should implicitly supply --cfg test

src/librustc/middle/borrowck/gather_loans/lifetime.rs

@@ -16,6 +16,7 @@
 use middle::borrowck::*;
 use mc = middle::mem_categorization;
 use middle::ty;
+use util::ppaux::Repr;
 use syntax::ast;
 use syntax::codemap::Span;
 

src/librustc/middle/resolve.rs

@@ -5408,8 +5408,7 @@ impl Resolver {
         }
     }
 
-    fn search_for_traits_containing_method(&mut self, name: Ident)
-                                               -> ~[DefId] {
+    fn search_for_traits_containing_method(&mut self, name: Ident) -> ~[DefId] {
         debug!("(searching for traits containing method) looking for '{}'",
                self.session.str_of(name));
 
@@ -5438,71 +5437,41 @@ impl Resolver {
                 self.populate_module_if_necessary(search_module);
 
                 let children = search_module.children.borrow();
-                for (_, &child_name_bindings) in children.get().iter() {
-                    match child_name_bindings.def_for_namespace(TypeNS) {
-                        Some(def) => {
-                            match def {
-                                DefTrait(trait_def_id) => {
-                                    if candidate_traits.contains(&trait_def_id) {
-                                        self.add_trait_info(
-                                            &mut found_traits,
-                                            trait_def_id, name);
-                                    }
-                                }
-                                _ => {
-                                    // Continue.
-                                }
-                            }
-                        }
-                        None => {
-                            // Continue.
-                        }
+                for (_, &child_names) in children.get().iter() {
+                    let def = match child_names.def_for_namespace(TypeNS) {
+                        Some(def) => def,
+                        None => continue
+                    };
+                    let trait_def_id = match def {
+                        DefTrait(trait_def_id) => trait_def_id,
+                        _ => continue,
+                    };
+                    if candidate_traits.contains(&trait_def_id) {
+                        self.add_trait_info(&mut found_traits, trait_def_id,
+                                            name);
                     }
                 }
 
                 // Look for imports.
                 let import_resolutions = search_module.import_resolutions
                                                       .borrow();
-                for (_, &import_resolution) in import_resolutions.get()
-                                                                 .iter() {
-                    match import_resolution.target_for_namespace(TypeNS) {
-                        None => {
-                            // Continue.
-                        }
-                        Some(target) => {
-                            match target.bindings.def_for_namespace(TypeNS) {
-                                Some(def) => {
-                                    match def {
-                                        DefTrait(trait_def_id) => {
-                                            if candidate_traits.contains(&trait_def_id) {
-                                                self.add_trait_info(
-                                                    &mut found_traits,
-                                                    trait_def_id, name);
-                                                self.used_imports.insert(
-                                                    import_resolution.type_id
-                                                                     .get());
-                                            }
-                                        }
-                                        _ => {
-                                            // Continue.
-                                        }
-                                    }
-                                }
-                                None => {
-                                    // Continue.
-                                }
-                            }
-                        }
+                for (_, &import) in import_resolutions.get().iter() {
+                    let target = match import.target_for_namespace(TypeNS) {
+                        None => continue,
+                        Some(target) => target,
+                    };
+                    let did = match target.bindings.def_for_namespace(TypeNS) {
+                        Some(DefTrait(trait_def_id)) => trait_def_id,
+                        Some(..) | None => continue,
+                    };
+                    if candidate_traits.contains(&did) {
+                        self.add_trait_info(&mut found_traits, did, name);
+                        self.used_imports.insert(import.type_id.get());
                     }
                 }
 
-                // Move to the next parent.
                 match search_module.parent_link {
-                    NoParentLink => {
-                        // Done.
-                        break;
-                    }
-                    ModuleParentLink(parent_module, _) |
+                    NoParentLink | ModuleParentLink(..) => break,
                     BlockParentLink(parent_module, _) => {
                         search_module = parent_module;
                     }

src/librustc/middle/typeck/astconv.rs

@@ -57,6 +57,7 @@ use middle::ty;
 use middle::typeck::rscope;
 use middle::typeck::rscope::{RegionScope};
 use middle::typeck::lookup_def_tcx;
+use util::ppaux::Repr;
 
 use std::vec;
 use syntax::abi::AbiSet;