---

yaml
---
r: 158927
b: refs/heads/master
c: a2f303a
h: refs/heads/master
i:
  158925: 8e2bbc8
  158923: cd53ac6
  158919: b4253ab
  158911: 9348170
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: cf4e53eee7377b42524176f39b0b428175c74fb1
+refs/heads/master: a2f303ad098844351d08800038a4f99fa2ff0817
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f89e975685a3a9f258c996865cdd144a0f30f83c
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2

trunk/mk/docs.mk

@@ -28,13 +28,13 @@
 DOCS := index intro tutorial guide guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-plugin guide-crates complement-bugreport \
-	complement-lang-faq complement-design-faq complement-project-faq rust \
+	complement-lang-faq complement-design-faq complement-project-faq \
     rustdoc guide-unsafe guide-strings reference
 
 PDF_DOCS := guide reference
 
-RUSTDOC_DEPS_rust := doc/full-toc.inc
-RUSTDOC_FLAGS_rust := --html-in-header=doc/full-toc.inc
+RUSTDOC_DEPS_reference := doc/full-toc.inc
+RUSTDOC_FLAGS_reference := --html-in-header=doc/full-toc.inc
 
 L10N_LANGS := ja
 

trunk/src/etc/vim/syntax/rust.vim

@@ -93,7 +93,7 @@ syn keyword rustEnum Ordering
 syn keyword rustEnumVariant Less Equal Greater
 syn keyword rustTrait Collection Mutable Map MutableMap MutableSeq
 syn keyword rustTrait Set MutableSet
-syn keyword rustTrait FromIterator Extendable ExactSize
+syn keyword rustTrait FromIterator IntoIterator Extend ExactSize
 syn keyword rustTrait Iterator DoubleEndedIterator
 syn keyword rustTrait RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator

trunk/src/libcollections/binary_heap.rs

@@ -555,7 +555,7 @@ impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
     }
 }
 
-impl<T: Ord> Extendable<T> for BinaryHeap<T> {
+impl<T: Ord> Extend<T> for BinaryHeap<T> {
     fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
         let (lower, _) = iter.size_hint();
 

trunk/src/libcollections/bit.rs

@@ -835,7 +835,7 @@ impl FromIterator<bool> for Bitv {
     }
 }
 
-impl Extendable<bool> for Bitv {
+impl Extend<bool> for Bitv {
     #[inline]
     fn extend<I: Iterator<bool>>(&mut self, mut iterator: I) {
         let (min, _) = iterator.size_hint();
@@ -1014,7 +1014,7 @@ impl FromIterator<bool> for BitvSet {
     }
 }
 
-impl Extendable<bool> for BitvSet {
+impl Extend<bool> for BitvSet {
     #[inline]
     fn extend<I: Iterator<bool>>(&mut self, iterator: I) {
         let &BitvSet(ref mut self_bitv) = self;

trunk/src/libcollections/btree/map.rs

@@ -727,7 +727,7 @@ impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {
     }
 }
 
-impl<K: Ord, V> Extendable<(K, V)> for BTreeMap<K, V> {
+impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
     #[inline]
     fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
         for (k, v) in iter {

trunk/src/libcollections/btree/set.rs

@@ -316,7 +316,7 @@ impl<T: Ord> FromIterator<T> for BTreeSet<T> {
     }
 }
 
-impl<T: Ord> Extendable<T> for BTreeSet<T> {
+impl<T: Ord> Extend<T> for BTreeSet<T> {
     #[inline]
     fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
         for elem in iter {

trunk/src/libcollections/dlist.rs

@@ -720,7 +720,7 @@ impl<A> FromIterator<A> for DList<A> {
     }
 }
 
-impl<A> Extendable<A> for DList<A> {
+impl<A> Extend<A> for DList<A> {
     fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
         for elt in iterator { self.push_back(elt); }
     }

trunk/src/libcollections/enum_set.rs

@@ -18,7 +18,6 @@ use core::fmt;
 
 // FIXME(conventions): implement BitXor
 // FIXME(contentions): implement union family of methods? (general design may be wrong here)
-// FIXME(conventions): implement len
 
 #[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 /// A specialized `Set` implementation to use enum types.
@@ -92,6 +91,12 @@ impl<E:CLike> EnumSet<E> {
         EnumSet {bits: 0}
     }
 
+    /// Returns the number of elements in the given `EnumSet`.
+    #[unstable = "matches collection reform specification, waiting for dust to settle"]
+    pub fn len(&self) -> uint {
+        self.bits.count_ones()
+    }
+
     /// Returns true if the `EnumSet` is empty.
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn is_empty(&self) -> bool {
@@ -230,6 +235,22 @@ impl<E:CLike> Iterator<E> for Items<E> {
     }
 }
 
+impl<E:CLike> FromIterator<E> for EnumSet<E> {
+    fn from_iter<I:Iterator<E>>(iterator: I) -> EnumSet<E> {
+        let mut ret = EnumSet::new();
+        ret.extend(iterator);
+        ret
+    }
+}
+
+impl<E:CLike> Extend<E> for EnumSet<E> {
+    fn extend<I: Iterator<E>>(&mut self, mut iterator: I) {
+        for element in iterator {
+            self.insert(element);
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::prelude::*;
@@ -269,6 +290,20 @@ mod test {
         assert_eq!("{A, C}", e.to_string().as_slice());
     }
 
+    #[test]
+    fn test_len() {
+        let mut e = EnumSet::new();
+        assert_eq!(e.len(), 0);
+        e.insert(A);
+        e.insert(B);
+        e.insert(C);
+        assert_eq!(e.len(), 3);
+        e.remove(&A);
+        assert_eq!(e.len(), 2);
+        e.clear();
+        assert_eq!(e.len(), 0);
+    }
+
     ///////////////////////////////////////////////////////////////////////////
     // intersect
 

trunk/src/libcollections/ring_buf.rs

@@ -735,7 +735,7 @@ impl<A> FromIterator<A> for RingBuf<A> {
     }
 }
 
-impl<A> Extendable<A> for RingBuf<A> {
+impl<A> Extend<A> for RingBuf<A> {
     fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
         for elt in iterator {
             self.push_back(elt);

trunk/src/libcollections/string.rs

@@ -683,8 +683,8 @@ impl FromIterator<char> for String {
     }
 }
 
-#[experimental = "waiting on Extendable stabilization"]
-impl Extendable<char> for String {
+#[experimental = "waiting on Extend stabilization"]
+impl Extend<char> for String {
     fn extend<I:Iterator<char>>(&mut self, mut iterator: I) {
         for ch in iterator {
             self.push(ch)

trunk/src/libcollections/tree/map.rs

@@ -1260,7 +1260,7 @@ impl<K: Ord, V> FromIterator<(K, V)> for TreeMap<K, V> {
     }
 }
 
-impl<K: Ord, V> Extendable<(K, V)> for TreeMap<K, V> {
+impl<K: Ord, V> Extend<(K, V)> for TreeMap<K, V> {
     #[inline]
     fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
         for (k, v) in iter {

trunk/src/libcollections/tree/set.rs

@@ -659,7 +659,7 @@ impl<T: Ord> FromIterator<T> for TreeSet<T> {
     }
 }
 
-impl<T: Ord> Extendable<T> for TreeSet<T> {
+impl<T: Ord> Extend<T> for TreeSet<T> {
     #[inline]
     fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
         for elem in iter {

trunk/src/libcollections/trie/map.rs

@@ -628,7 +628,7 @@ impl<T> FromIterator<(uint, T)> for TrieMap<T> {
     }
 }
 
-impl<T> Extendable<(uint, T)> for TrieMap<T> {
+impl<T> Extend<(uint, T)> for TrieMap<T> {
     fn extend<Iter: Iterator<(uint, T)>>(&mut self, mut iter: Iter) {
         for (k, v) in iter {
             self.insert(k, v);

trunk/src/libcollections/trie/set.rs

@@ -355,7 +355,7 @@ impl FromIterator<uint> for TrieSet {
     }
 }
 
-impl Extendable<uint> for TrieSet {
+impl Extend<uint> for TrieSet {
     fn extend<Iter: Iterator<uint>>(&mut self, mut iter: Iter) {
         for elem in iter {
             self.insert(elem);

trunk/src/libcollections/vec.rs

@@ -484,8 +484,8 @@ impl<T> FromIterator<T> for Vec<T> {
     }
 }
 
-#[experimental = "waiting on Extendable stability"]
-impl<T> Extendable<T> for Vec<T> {
+#[experimental = "waiting on Extend stability"]
+impl<T> Extend<T> for Vec<T> {
     #[inline]
     fn extend<I: Iterator<T>>(&mut self, mut iterator: I) {
         let (lower, _) = iterator.size_hint();
@@ -801,14 +801,13 @@ impl<T> Vec<T> {
     ///
     /// # Example
     /// ```
-    /// let mut v = vec!["foo".to_string(), "bar".to_string(),
-    ///                  "baz".to_string(), "qux".to_string()];
+    /// let mut v = vec!["foo", "bar", "baz", "qux"];
     ///
-    /// assert_eq!(v.swap_remove(1), Some("bar".to_string()));
-    /// assert_eq!(v, vec!["foo".to_string(), "qux".to_string(), "baz".to_string()]);
+    /// assert_eq!(v.swap_remove(1), Some("bar"));
+    /// assert_eq!(v, vec!["foo", "qux", "baz"]);
     ///
-    /// assert_eq!(v.swap_remove(0), Some("foo".to_string()));
-    /// assert_eq!(v, vec!["baz".to_string(), "qux".to_string()]);
+    /// assert_eq!(v.swap_remove(0), Some("foo"));
+    /// assert_eq!(v, vec!["baz", "qux"]);
     ///
     /// assert_eq!(v.swap_remove(2), None);
     /// ```

trunk/src/libcollections/vec_map.rs

@@ -499,7 +499,7 @@ impl<V> FromIterator<(uint, V)> for VecMap<V> {
     }
 }
 
-impl<V> Extendable<(uint, V)> for VecMap<V> {
+impl<V> Extend<(uint, V)> for VecMap<V> {
     fn extend<Iter: Iterator<(uint, V)>>(&mut self, mut iter: Iter) {
         for (k, v) in iter {
             self.insert(k, v);

trunk/src/libcore/atomic.rs

@@ -717,15 +717,15 @@ unsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {
 /// A fence 'A' which has `Release` ordering semantics, synchronizes with a
 /// fence 'B' with (at least) `Acquire` semantics, if and only if there exists
 /// atomic operations X and Y, both operating on some atomic object 'M' such
-/// that A is sequenced before X, Y is synchronized before B and Y observers
+/// that A is sequenced before X, Y is synchronized before B and Y observes
 /// the change to M. This provides a happens-before dependence between A and B.
 ///
 /// Atomic operations with `Release` or `Acquire` semantics can also synchronize
 /// with a fence.
 ///
-/// A fence with has `SeqCst` ordering, in addition to having both `Acquire` and
-/// `Release` semantics, participates in the global program order of the other
-/// `SeqCst` operations and/or fences.
+/// A fence which has `SeqCst` ordering, in addition to having both `Acquire`
+/// and `Release` semantics, participates in the global program order of the
+/// other `SeqCst` operations and/or fences.
 ///
 /// Accepts `Acquire`, `Release`, `AcqRel` and `SeqCst` orderings.
 ///

trunk/src/libcore/intrinsics.rs

@@ -536,7 +536,7 @@ extern "rust-intrinsic" {
 /// `TypeId` represents a globally unique identifier for a type
 #[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and
                   // middle/lang_items.rs
-#[deriving(PartialEq, Eq, Show)]
+#[deriving(Clone, PartialEq, Eq, Show)]
 pub struct TypeId {
     t: u64,
 }

trunk/src/libcore/iter.rs

@@ -66,6 +66,7 @@ use num::{Zero, One, CheckedAdd, CheckedSub, Saturating, ToPrimitive, Int};
 use ops::{Add, Mul, Sub};
 use option::{Option, Some, None};
 use uint;
+#[deprecated = "renamed to Extend"] pub use self::Extend as Extendable;
 
 /// Conversion from an `Iterator`
 pub trait FromIterator<A> {
@@ -74,8 +75,8 @@ pub trait FromIterator<A> {
 }
 
 /// A type growable from an `Iterator` implementation
-pub trait Extendable<A>: FromIterator<A> {
-    /// Extend a container with the elements yielded by an iterator
+pub trait Extend<A> {
+    /// Extend a container with the elements yielded by an arbitrary iterator
     fn extend<T: Iterator<A>>(&mut self, iterator: T);
 }
 

trunk/src/libcore/prelude.rs

@@ -48,7 +48,7 @@ pub use char::Char;
 pub use clone::Clone;
 pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
-pub use iter::{FromIterator, Extendable};
+pub use iter::{FromIterator, Extend};
 pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator};
 pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize};
 pub use num::{Num, NumCast, CheckedAdd, CheckedSub, CheckedMul};

trunk/src/librustc/driver/driver.rs

@@ -212,11 +212,6 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         *ty == config::CrateTypeExecutable
     });
 
-    krate = time(time_passes, "crate injection", krate, |krate|
-                 syntax::std_inject::maybe_inject_crates_ref(krate,
-                                                             sess.opts.alt_std_name.clone(),
-                                                             any_exe));
-
     // strip before expansion to allow macros to depend on
     // configuration variables e.g/ in
     //
@@ -228,6 +223,11 @@ pub fn phase_2_configure_and_expand(sess: &Session,
     krate = time(time_passes, "configuration 1", krate, |krate|
                  syntax::config::strip_unconfigured_items(sess.diagnostic(), krate));
 
+    krate = time(time_passes, "crate injection", krate, |krate|
+                 syntax::std_inject::maybe_inject_crates_ref(krate,
+                                                             sess.opts.alt_std_name.clone(),
+                                                             any_exe));
+
     let mut addl_plugins = Some(addl_plugins);
     let Plugins { macros, registrars }
         = time(time_passes, "plugin loading", (), |_|

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

@@ -176,7 +176,7 @@ pub enum Vtable<N> {
     /// ID is the ID of the closure expression. This is a `VtableImpl`
     /// in spirit, but the impl is generated by the compiler and does
     /// not appear in the source.
-    VtableUnboxedClosure(ast::DefId),
+    VtableUnboxedClosure(ast::DefId, subst::Substs),
 
     /// Successful resolution to an obligation provided by the caller
     /// for some type parameter.
@@ -338,7 +338,7 @@ impl<N> Vtable<N> {
     pub fn iter_nested(&self) -> Items<N> {
         match *self {
             VtableImpl(ref i) => i.iter_nested(),
-            VtableUnboxedClosure(_) => (&[]).iter(),
+            VtableUnboxedClosure(..) => (&[]).iter(),
             VtableParam(_) => (&[]).iter(),
             VtableBuiltin(ref i) => i.iter_nested(),
         }
@@ -347,7 +347,7 @@ impl<N> Vtable<N> {
     pub fn map_nested<M>(&self, op: |&N| -> M) -> Vtable<M> {
         match *self {
             VtableImpl(ref i) => VtableImpl(i.map_nested(op)),
-            VtableUnboxedClosure(d) => VtableUnboxedClosure(d),
+            VtableUnboxedClosure(d, ref s) => VtableUnboxedClosure(d, s.clone()),
             VtableParam(ref p) => VtableParam((*p).clone()),
             VtableBuiltin(ref i) => VtableBuiltin(i.map_nested(op)),
         }
@@ -356,7 +356,7 @@ impl<N> Vtable<N> {
     pub fn map_move_nested<M>(self, op: |N| -> M) -> Vtable<M> {
         match self {
             VtableImpl(i) => VtableImpl(i.map_move_nested(op)),
-            VtableUnboxedClosure(d) => VtableUnboxedClosure(d),
+            VtableUnboxedClosure(d, s) => VtableUnboxedClosure(d, s),
             VtableParam(p) => VtableParam(p),
             VtableBuiltin(i) => VtableBuiltin(i.map_move_nested(op)),
         }

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

@@ -1582,9 +1582,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 Ok(VtableImpl(vtable_impl))
             }
 
-            UnboxedClosureCandidate(closure_def_id, ref substs) => {
-                try!(self.confirm_unboxed_closure_candidate(obligation, closure_def_id, substs));
-                Ok(VtableUnboxedClosure(closure_def_id))
+            UnboxedClosureCandidate(closure_def_id, substs) => {
+                try!(self.confirm_unboxed_closure_candidate(obligation, closure_def_id, &substs));
+                Ok(VtableUnboxedClosure(closure_def_id, substs))
             }
         }
     }

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

@@ -311,9 +311,10 @@ impl<N:Repr> Repr for super::Vtable<N> {
             super::VtableImpl(ref v) =>
                 v.repr(tcx),
 
-            super::VtableUnboxedClosure(ref d) =>
-                format!("VtableUnboxedClosure({})",
-                        d.repr(tcx)),
+            super::VtableUnboxedClosure(ref d, ref s) =>
+                format!("VtableUnboxedClosure({},{})",
+                        d.repr(tcx),
+                        s.repr(tcx)),
 
             super::VtableParam(ref v) =>
                 format!("VtableParam({})", v.repr(tcx)),