---

yaml
---
r: 236393
b: refs/heads/master
c: e1acf87
h: refs/heads/master
i:
  236391: b53ee7c
v: v3

Author: marti1125

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a305b0624b164fd0b0b5558b837288429247cdaf
+refs/heads/master: e1acf87fe0fe3b64be0750dc7d1244558a626a91
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
 refs/heads/try: ea3892f76a2180dd4ce724f1dafd9186959702d9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/src/doc/trpl/iterators.md

@@ -281,8 +281,7 @@ If you are trying to execute a closure on an iterator for its side effects,
 just use `for` instead.
 
 There are tons of interesting iterator adapters. `take(n)` will return an
-iterator over the next `n` elements of the original iterator. Note that this
-has no side effect on the original iterator. Let's try it out with our infinite
+iterator over the next `n` elements of the original iterator. Let's try it out with our infinite
 iterator from before:
 
 ```rust

trunk/src/libcollections/enum_set.rs

@@ -49,7 +49,16 @@ impl<E> Clone for EnumSet<E> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<E:CLike + fmt::Debug> fmt::Debug for EnumSet<E> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_set().entries(self).finish()
+        try!(write!(fmt, "{{"));
+        let mut first = true;
+        for e in self {
+            if !first {
+                try!(write!(fmt, ", "));
+            }
+            try!(write!(fmt, "{:?}", e));
+            first = false;
+        }
+        write!(fmt, "}}")
     }
 }
 

trunk/src/libcollections/str.rs

@@ -506,6 +506,8 @@ impl str {
     ///
     /// # Examples
     /// ```
+    /// #![feature(str_split_at)]
+    ///
     /// let s = "Löwe 老虎 Léopard";
     /// let first_space = s.find(' ').unwrap_or(s.len());
     /// let (a, b) = s.split_at(first_space);

trunk/src/libcollections/vec.rs

@@ -753,6 +753,8 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
+    /// #![feature(split_off)]
+    ///
     /// let mut vec = vec![1,2,3];
     /// let vec2 = vec.split_off(1);
     /// assert_eq!(vec, [1]);

trunk/src/libcollections/vec_deque.rs

@@ -1319,6 +1319,8 @@ impl<T> VecDeque<T> {
     /// # Examples
     ///
     /// ```
+    /// #![feature(split_off)]
+    ///
     /// use std::collections::VecDeque;
     ///
     /// let mut buf: VecDeque<_> = vec![1,2,3].into_iter().collect();
@@ -1404,6 +1406,8 @@ impl<T> VecDeque<T> {
     /// # Examples
     ///
     /// ```
+    /// #![feature(vec_deque_retain)]
+    ///
     /// use std::collections::VecDeque;
     ///
     /// let mut buf = VecDeque::new();
@@ -1783,7 +1787,14 @@ impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: fmt::Debug> fmt::Debug for VecDeque<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self).finish()
+        try!(write!(f, "["));
+
+        for (i, e) in self.iter().enumerate() {
+            if i != 0 { try!(write!(f, ", ")); }
+            try!(write!(f, "{:?}", *e));
+        }
+
+        write!(f, "]")
     }
 }
 

trunk/src/libcollectionstest/lib.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(ascii)]
+#![feature(append)]
 #![feature(binary_heap_extras)]
 #![feature(box_syntax)]
 #![feature(btree_range)]
@@ -28,14 +29,18 @@
 #![feature(set_recovery)]
 #![feature(slice_bytes)]
 #![feature(slice_splits)]
+#![feature(split_off)]
 #![feature(step_by)]
 #![feature(str_char)]
 #![feature(str_escape)]
 #![feature(str_match_indices)]
+#![feature(str_split_at)]
 #![feature(str_utf16)]
+#![feature(box_str)]
 #![feature(test)]
 #![feature(unboxed_closures)]
 #![feature(unicode)]
+#![feature(vec_deque_retain)]
 #![feature(vec_push_all)]
 
 #[macro_use] extern crate log;

trunk/src/liblibc/lib.rs

@@ -3901,8 +3901,6 @@ pub mod consts {
             pub const MAP_POPULATE : c_int = 0x08000;
             pub const MAP_NONBLOCK : c_int = 0x010000;
             pub const MAP_STACK : c_int = 0x020000;
-
-            pub const PATH_MAX: c_int = 4096;
         }
         #[cfg(any(target_arch = "mips",
                   target_arch = "mipsel"))]
@@ -3930,8 +3928,6 @@ pub mod consts {
             pub const MAP_POPULATE : c_int = 0x010000;
             pub const MAP_NONBLOCK : c_int = 0x020000;
             pub const MAP_STACK : c_int = 0x040000;
-
-            pub const PATH_MAX: c_int = 4096;
         }
         #[cfg(target_os = "linux")]
         pub mod sysconf {

trunk/src/librustc/middle/infer/mod.rs

@@ -43,7 +43,7 @@ use std::rc::Rc;
 use syntax::ast;
 use syntax::codemap;
 use syntax::codemap::{Span, DUMMY_SP};
-use util::nodemap::{FnvHashMap, FnvHashSet, NodeMap};
+use util::nodemap::{FnvHashMap, NodeMap};
 
 use self::combine::CombineFields;
 use self::region_inference::{RegionVarBindings, RegionSnapshot};
@@ -92,10 +92,6 @@ pub struct InferCtxt<'a, 'tcx: 'a> {
 
     pub fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
 
-    // the set of predicates on which errors have been reported, to
-    // avoid reporting the same error twice.
-    pub reported_trait_errors: RefCell<FnvHashSet<traits::TraitErrorKey<'tcx>>>,
-
     // This is a temporary field used for toggling on normalization in the inference context,
     // as we move towards the approach described here:
     // https://internals.rust-lang.org/t/flattening-the-contexts-for-fun-and-profit/2293
@@ -378,7 +374,6 @@ pub fn new_infer_ctxt<'a, 'tcx>(tcx: &'a ty::ctxt<'tcx>,
         region_vars: RegionVarBindings::new(tcx),
         parameter_environment: param_env.unwrap_or(tcx.empty_parameter_environment()),
         fulfillment_cx: RefCell::new(traits::FulfillmentContext::new(errors_will_be_reported)),
-        reported_trait_errors: RefCell::new(FnvHashSet()),
         normalize: false,
         err_count_on_creation: tcx.sess.err_count()
     }

trunk/src/librustc/middle/reachable.rs

@@ -348,17 +348,13 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
     // this properly would result in the necessity of computing *type*
     // reachability, which might result in a compile time loss.
     fn mark_destructors_reachable(&mut self) {
-        let drop_trait = match self.tcx.lang_items.drop_trait() {
-            Some(id) => self.tcx.lookup_trait_def(id), None => { return }
-        };
-        drop_trait.for_each_impl(self.tcx, |drop_impl| {
-            for destructor in &self.tcx.impl_items.borrow()[&drop_impl] {
-                let destructor_did = destructor.def_id();
-                if destructor_did.is_local() {
-                    self.reachable_symbols.insert(destructor_did.node);
+        for adt in self.tcx.adt_defs() {
+            if let Some(destructor_def_id) = adt.destructor() {
+                if destructor_def_id.is_local() {
+                    self.reachable_symbols.insert(destructor_def_id.node);
                 }
             }
-        })
+        }
     }
 }
 

trunk/src/librustc/middle/traits/error_reporting.rs

@@ -28,32 +28,11 @@ use middle::def_id::DefId;
 use middle::infer::InferCtxt;
 use middle::ty::{self, ToPredicate, HasTypeFlags, ToPolyTraitRef, TraitRef, Ty};
 use middle::ty::fold::TypeFoldable;
-use util::nodemap::{FnvHashMap, FnvHashSet};
-
+use std::collections::HashMap;
 use std::fmt;
 use syntax::codemap::Span;
 use syntax::attr::{AttributeMethods, AttrMetaMethods};
 
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub struct TraitErrorKey<'tcx> {
-    is_warning: bool,
-    span: Span,
-    predicate: ty::Predicate<'tcx>
-}
-
-impl<'tcx> TraitErrorKey<'tcx> {
-    fn from_error<'a>(infcx: &InferCtxt<'a, 'tcx>,
-                      e: &FulfillmentError<'tcx>) -> Self {
-        let predicate =
-            infcx.resolve_type_vars_if_possible(&e.obligation.predicate);
-        TraitErrorKey {
-            is_warning: is_warning(&e.obligation),
-            span: e.obligation.cause.span,
-            predicate: infcx.tcx.erase_regions(&predicate)
-        }
-    }
-}
-
 pub fn report_fulfillment_errors<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                                            errors: &Vec<FulfillmentError<'tcx>>) {
     for error in errors {
@@ -63,13 +42,6 @@ pub fn report_fulfillment_errors<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
 
 fn report_fulfillment_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                                       error: &FulfillmentError<'tcx>) {
-    let error_key = TraitErrorKey::from_error(infcx, error);
-    debug!("report_fulfillment_errors({:?}) - key={:?}",
-           error, error_key);
-    if !infcx.reported_trait_errors.borrow_mut().insert(error_key) {
-        debug!("report_fulfillment_errors: skipping duplicate");
-        return;
-    }
     match error.code {
         FulfillmentErrorCode::CodeSelectionError(ref e) => {
             report_selection_error(infcx, &error.obligation, e);
@@ -125,7 +97,7 @@ fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                                                (gen.name.as_str().to_string(),
                                                 trait_ref.substs.types.get(param, i)
                                                          .to_string())
-                                              }).collect::<FnvHashMap<String, String>>();
+                                              }).collect::<HashMap<String, String>>();
                 generic_map.insert("Self".to_string(),
                                    trait_ref.self_ty().to_string());
                 let parser = Parser::new(&istring);
@@ -336,11 +308,7 @@ pub fn report_object_safety_error<'tcx>(tcx: &ty::ctxt<'tcx>,
         "the trait `{}` cannot be made into an object",
         tcx.item_path_str(trait_def_id));
 
-    let mut reported_violations = FnvHashSet();
     for violation in violations {
-        if !reported_violations.insert(violation.clone()) {
-            continue;
-        }
         match violation {
             ObjectSafetyViolation::SizedSelf => {
                 tcx.sess.fileline_note(

trunk/src/librustc/middle/traits/fulfill.rs

@@ -49,12 +49,6 @@ pub struct FulfillmentContext<'tcx> {
     // than the `SelectionCache`: it avoids duplicate errors and
     // permits recursive obligations, which are often generated from
     // traits like `Send` et al.
-    //
-    // Note that because of type inference, a predicate can still
-    // occur twice in the predicates list, for example when 2
-    // initially-distinct type variables are unified after being
-    // inserted. Deduplicating the predicate set on selection had a
-    // significant performance cost the last time I checked.
     duplicate_set: FulfilledPredicates<'tcx>,
 
     // A list of all obligations that have been registered with this

trunk/src/librustc/middle/traits/mod.rs

@@ -21,12 +21,10 @@ use middle::subst;
 use middle::ty::{self, HasTypeFlags, Ty};
 use middle::ty::fold::TypeFoldable;
 use middle::infer::{self, fixup_err_to_string, InferCtxt};
-
 use std::rc::Rc;
 use syntax::ast;
 use syntax::codemap::{Span, DUMMY_SP};
 
-pub use self::error_reporting::TraitErrorKey;
 pub use self::error_reporting::report_fulfillment_errors;
 pub use self::error_reporting::report_overflow_error;
 pub use self::error_reporting::report_selection_error;

trunk/src/librustc/middle/traits/object_safety.rs

@@ -27,7 +27,7 @@ use middle::ty::{self, ToPolyTraitRef, Ty};
 use std::rc::Rc;
 use syntax::ast;
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Debug)]
 pub enum ObjectSafetyViolation<'tcx> {
     /// Self : Sized declared on the trait
     SizedSelf,

trunk/src/librustc/middle/ty/context.rs

@@ -245,6 +245,9 @@ pub struct ctxt<'tcx> {
     /// True if the variance has been computed yet; false otherwise.
     pub variance_computed: Cell<bool>,
 
+    /// A method will be in this list if and only if it is a destructor.
+    pub destructors: RefCell<DefIdSet>,
+
     /// Maps a DefId of a type to a list of its inherent impls.
     /// Contains implementations of methods that are inherent to a type.
     /// Methods in these implementations don't need to be exported.
@@ -472,6 +475,7 @@ impl<'tcx> ctxt<'tcx> {
             normalized_cache: RefCell::new(FnvHashMap()),
             lang_items: lang_items,
             provided_method_sources: RefCell::new(DefIdMap()),
+            destructors: RefCell::new(DefIdSet()),
             inherent_impls: RefCell::new(DefIdMap()),
             impl_items: RefCell::new(DefIdMap()),
             used_unsafe: RefCell::new(NodeSet()),

trunk/src/librustc/middle/ty/mod.rs

@@ -272,20 +272,6 @@ impl<'tcx> Method<'tcx> {
     }
 }
 
-impl<'tcx> PartialEq for Method<'tcx> {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool { self.def_id == other.def_id }
-}
-
-impl<'tcx> Eq for Method<'tcx> {}
-
-impl<'tcx> Hash for Method<'tcx> {
-    #[inline]
-    fn hash<H: Hasher>(&self, s: &mut H) {
-        self.def_id.hash(s)
-    }
-}
-
 #[derive(Clone, Copy, Debug)]
 pub struct AssociatedConst<'tcx> {
     pub name: Name,
@@ -1695,6 +1681,7 @@ impl<'tcx, 'container> AdtDefData<'tcx, 'container> {
     }
 
     pub fn set_destructor(&self, dtor: DefId) {
+        assert!(self.destructor.get().is_none());
         self.destructor.set(Some(dtor));
     }
 
@@ -2328,6 +2315,11 @@ impl<'tcx> ctxt<'tcx> {
         self.lookup_adt_def_master(did)
     }
 
+    /// Return the list of all interned ADT definitions
+    pub fn adt_defs(&self) -> Vec<AdtDef<'tcx>> {
+        self.adt_defs.borrow().values().cloned().collect()
+    }
+
     /// Given the did of an item, returns its full set of predicates.
     pub fn lookup_predicates(&self, did: DefId) -> GenericPredicates<'tcx> {
         lookup_locally_or_in_crate_store(

trunk/src/librustc_back/target/apple_base.rs

@@ -24,7 +24,7 @@ pub fn opts() -> TargetOptions {
         dll_suffix: ".dylib".to_string(),
         archive_format: "bsd".to_string(),
         pre_link_args: Vec::new(),
-        exe_allocation_crate: super::maybe_jemalloc(),
+        exe_allocation_crate: super::best_allocator(),
         .. Default::default()
     }
 }

trunk/src/librustc_back/target/bitrig_base.rs

@@ -20,7 +20,7 @@ pub fn opts() -> TargetOptions {
         has_rpath: true,
         position_independent_executables: true,
         archive_format: "gnu".to_string(),
-        exe_allocation_crate: "alloc_system".to_string(),
+        exe_allocation_crate: super::best_allocator(),
 
         .. Default::default()
     }

trunk/src/librustc_back/target/dragonfly_base.rs

@@ -27,7 +27,7 @@ pub fn opts() -> TargetOptions {
         ),
         position_independent_executables: true,
         archive_format: "gnu".to_string(),
-        exe_allocation_crate: super::maybe_jemalloc(),
+        exe_allocation_crate: super::best_allocator(),
         .. Default::default()
     }
 }

trunk/src/librustc_back/target/freebsd_base.rs

@@ -18,7 +18,7 @@ pub fn opts() -> TargetOptions {
         executables: true,
         has_rpath: true,
         archive_format: "gnu".to_string(),
-        exe_allocation_crate: super::maybe_jemalloc(),
+        exe_allocation_crate: super::best_allocator(),
 
         .. Default::default()
     }

trunk/src/librustc_back/target/linux_base.rs

@@ -29,7 +29,7 @@ pub fn opts() -> TargetOptions {
         ],
         position_independent_executables: true,
         archive_format: "gnu".to_string(),
-        exe_allocation_crate: super::maybe_jemalloc(),
+        exe_allocation_crate: super::best_allocator(),
         .. Default::default()
     }
 }

trunk/src/librustc_back/target/mod.rs

@@ -458,7 +458,7 @@ impl Target {
     }
 }
 
-fn maybe_jemalloc() -> String {
+fn best_allocator() -> String {
     if cfg!(disable_jemalloc) {
         "alloc_system".to_string()
     } else {