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;

src/librustc/middle/typeck/check/method.rs

@@ -83,6 +83,7 @@ obtained the type `Foo`, we would never match this method.
 use middle::resolve;
 use middle::ty::*;
 use middle::ty;
+use middle::typeck::astconv::AstConv;
 use middle::typeck::check::{FnCtxt, impl_self_ty};
 use middle::typeck::check::{structurally_resolved_type};
 use middle::typeck::check::vtable;

src/librustc/middle/typeck/check/mod.rs

@@ -107,8 +107,8 @@ use middle::typeck::no_params;
 use middle::typeck::{require_same_types, method_map, vtable_map};
 use middle::lang_items::TypeIdLangItem;
 use util::common::{block_query, indenter, loop_query};
-use util::ppaux::UserString;
 use util::ppaux;
+use util::ppaux::{UserString, Repr};
 
 use std::cell::{Cell, RefCell};
 use std::hashmap::HashMap;

src/librustc/middle/typeck/check/regionck.rs

@@ -31,13 +31,14 @@ this point a bit better.
 use middle::freevars::get_freevars;
 use middle::ty::{ReScope};
 use middle::ty;
+use middle::typeck::astconv::AstConv;
 use middle::typeck::check::FnCtxt;
 use middle::typeck::check::regionmanip::relate_nested_regions;
 use middle::typeck::infer::resolve_and_force_all_but_regions;
 use middle::typeck::infer::resolve_type;
 use middle::typeck::infer;
-use util::ppaux::{ty_to_str, region_to_str};
 use middle::pat_util;
+use util::ppaux::{ty_to_str, region_to_str, Repr};
 
 use syntax::ast::{ManagedSigil, OwnedSigil, BorrowedSigil};
 use syntax::ast::{DefArg, DefBinding, DefLocal, DefSelf, DefUpvar};
@@ -833,14 +834,14 @@ pub mod guarantor {
      * but more special purpose.
      */
 
-
+    use middle::typeck::astconv::AstConv;
     use middle::typeck::check::regionck::Rcx;
     use middle::typeck::check::regionck::mk_subregion_due_to_derefence;
     use middle::typeck::infer;
     use middle::ty;
     use syntax::ast;
     use syntax::codemap::Span;
-    use util::ppaux::{ty_to_str};
+    use util::ppaux::{ty_to_str, Repr};
 
     pub fn for_addr_of(rcx: &mut Rcx, expr: &ast::Expr, base: &ast::Expr) {
         /*!

src/librustc/middle/typeck/check/vtable.rs

@@ -12,6 +12,7 @@
 use middle::ty;
 use middle::ty::{AutoAddEnv, AutoDerefRef, AutoObject, param_ty};
 use middle::ty_fold::TypeFolder;
+use middle::typeck::astconv::AstConv;
 use middle::typeck::check::{FnCtxt, impl_self_ty};
 use middle::typeck::check::{structurally_resolved_type};
 use middle::typeck::infer::fixup_err_to_str;
@@ -23,6 +24,7 @@ use middle::typeck::{param_numbered, param_self, param_index};
 use middle::subst::Subst;
 use util::common::indenter;
 use util::ppaux;
+use util::ppaux::Repr;
 
 use std::cell::RefCell;
 use std::hashmap::HashSet;

src/librustc/middle/typeck/check/writeback.rs

@@ -15,6 +15,7 @@
 
 use middle::pat_util;
 use middle::ty;
+use middle::typeck::astconv::AstConv;
 use middle::typeck::check::{FnCtxt, SelfInfo};
 use middle::typeck::infer::{force_all, resolve_all, resolve_region};
 use middle::typeck::infer::resolve_type;
@@ -25,6 +26,7 @@ use middle::typeck::method_map_entry;
 use middle::typeck::write_substs_to_tcx;
 use middle::typeck::write_ty_to_tcx;
 use util::ppaux;
+use util::ppaux::Repr;
 
 use syntax::ast;
 use syntax::codemap::Span;

src/librustc/middle/typeck/coherence.rs

@@ -34,6 +34,7 @@ use middle::typeck::infer::combine::Combine;
 use middle::typeck::infer::InferCtxt;
 use middle::typeck::infer::{new_infer_ctxt, resolve_ivar, resolve_type};
 use middle::typeck::infer;
+use util::ppaux::Repr;
 use syntax::ast::{Crate, DefId, DefStruct, DefTy};
 use syntax::ast::{item, item_enum, item_impl, item_mod, item_struct};
 use syntax::ast::{LOCAL_CRATE, trait_ref, ty_path};

src/librustc/middle/typeck/collect.rs

@@ -42,6 +42,7 @@ use middle::typeck::astconv;
 use middle::typeck::rscope::*;
 use middle::typeck::{CrateCtxt, lookup_def_tcx, no_params, write_ty_to_tcx};
 use util::ppaux;
+use util::ppaux::Repr;
 
 use std::vec;
 use syntax::abi::AbiSet;

src/librustc/middle/typeck/infer/coercion.rs

@@ -71,7 +71,7 @@ use middle::ty::{vstore_slice, vstore_box, vstore_uniq};
 use middle::ty::{mt};
 use middle::ty;
 use middle::typeck::infer::{CoerceResult, resolve_type, Coercion};
-use middle::typeck::infer::combine::CombineFields;
+use middle::typeck::infer::combine::{CombineFields, Combine};
 use middle::typeck::infer::sub::Sub;
 use middle::typeck::infer::to_str::InferStr;
 use middle::typeck::infer::resolve::try_resolve_tvar_shallow;