---

yaml
---
r: 159027
b: refs/heads/auto
c: a722f70
h: refs/heads/master
i:
  159025: ebf3619
  159023: e7e3923
v: v3

Author: vhbit

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: efc9a441b9f48912166b0ce375efe677edc0e93a
+refs/heads/auto: a722f70207cf8419150c52cbf79ef5b9eadb1639
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -76,24 +76,6 @@ putvar() {
     printf "%-20s := %s\n" $1 "$T" >>config.tmp
 }
 
-putpathvar() {
-    local T
-    eval T=\$$1
-    eval TLEN=\${#$1}
-    if [ $TLEN -gt 35 ]
-    then
-        printf "configure: %-20s := %.35s ...\n" $1 "$T"
-    else
-        printf "configure: %-20s := %s %s\n" $1 "$T" "$2"
-    fi
-    if [ -z "$T" ]
-    then
-        printf "%-20s := \n" $1 >>config.tmp
-    else
-        printf "%-20s := \"%s\"\n" $1 "$T" >>config.tmp
-    fi
-}
-
 probe() {
     local V=$1
     shift
@@ -119,7 +101,7 @@ probe() {
         fi
     done
     eval $V=\$T
-    putpathvar $V "$VER"
+    putvar $V "$VER"
 }
 
 probe_need() {
@@ -656,9 +638,9 @@ probe CFG_ADB        adb
 
 if [ ! -z "$CFG_PANDOC" ]
 then
-    PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc\(.exe\)\? ' |
+    PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc ' |
         # extract the first 2 version fields, ignore everything else
-        sed 's/pandoc\(.exe\)\? \([0-9]*\)\.\([0-9]*\).*/\2 \3/')
+        sed 's/pandoc \([0-9]*\)\.\([0-9]*\).*/\1 \2/')
 
     MIN_PV_MAJOR="1"
     MIN_PV_MINOR="9"
@@ -1348,7 +1330,8 @@ do
 done
 
 # Munge any paths that appear in config.mk back to posix-y
-perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' config.tmp
+perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' \
+               -e 's@\\@/@go;' config.tmp
 rm -f config.tmp.bak
 
 msg

branches/auto/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 \
+	complement-lang-faq complement-design-faq complement-project-faq rust \
     rustdoc guide-unsafe guide-strings reference
 
 PDF_DOCS := guide reference
 
-RUSTDOC_DEPS_reference := doc/full-toc.inc
-RUSTDOC_FLAGS_reference := --html-in-header=doc/full-toc.inc
+RUSTDOC_DEPS_rust := doc/full-toc.inc
+RUSTDOC_FLAGS_rust := --html-in-header=doc/full-toc.inc
 
 L10N_LANGS := ja
 

branches/auto/mk/reconfig.mk

@@ -19,7 +19,7 @@ ifndef CFG_DISABLE_MANAGE_SUBMODULES
 # (nothing checked out at all).  `./configure --{llvm,jemalloc}-root`
 # will explicitly deinitialize the corresponding submodules, and we don't
 # want to force constant rebuilds in that case.
-NEED_GIT_RECONFIG=$(shell cd "$(CFG_SRC_DIR)" && $(CFG_GIT) submodule status | grep -c '^+')
+NEED_GIT_RECONFIG=$(shell cd "$(CFG_SRC_DIR)" && "$(CFG_GIT)" submodule status | grep -c '^+')
 else
 NEED_GIT_RECONFIG=0
 endif

branches/auto/src/doc/guide.md

@@ -1481,7 +1481,7 @@ s.push_str(", world.");
 println!("{}", s);
 ```
 
-You can get a `&str` view into a `String` with the `as_slice()` method:
+You can coerce a `String` into a `&str` with the `as_slice()` method:
 
 ```{rust}
 fn takes_slice(slice: &str) {
@@ -1514,7 +1514,7 @@ fn compare(string: String) {
 }
 ```
 
-Viewing a `String` as a `&str` is cheap, but converting the `&str` to a
+Converting a `String` to a `&str` is cheap, but converting the `&str` to a
 `String` involves allocating memory. No reason to do that unless you have to!
 
 That's the basics of strings in Rust! They're probably a bit more complicated

branches/auto/src/doc/intro.md

@@ -217,7 +217,7 @@ including the right thing!) Even though we compiled with flags to give us as
 many warnings as possible, and to treat those warnings as errors, we got no
 errors. When we ran the program, it crashed.
 
-Why does this happen? When we append to an array, its length changes. Since
+Why does this happen? When we prepend to an array, its length changes. Since
 its length changes, we may need to allocate more memory. In Ruby, this happens
 as well, we just don't think about it very often. So why does the C++ version
 segfault when we allocate more memory?

branches/auto/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 IntoIterator Extend ExactSize
+syn keyword rustTrait FromIterator Extendable ExactSize
 syn keyword rustTrait Iterator DoubleEndedIterator
 syn keyword rustTrait RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator

branches/auto/src/libcollections/binary_heap.rs

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

branches/auto/src/libcollections/bit.rs

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

branches/auto/src/libcollections/btree/map.rs

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

branches/auto/src/libcollections/btree/set.rs

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

branches/auto/src/libcollections/dlist.rs

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

branches/auto/src/libcollections/enum_set.rs

@@ -16,7 +16,9 @@
 use core::prelude::*;
 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.
@@ -90,12 +92,6 @@ 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 {
@@ -200,12 +196,6 @@ impl<E:CLike> BitAnd<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
     }
 }
 
-impl<E:CLike> BitXor<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
-    fn bitxor(&self, e: &EnumSet<E>) -> EnumSet<E> {
-        EnumSet {bits: self.bits ^ e.bits}
-    }
-}
-
 /// An iterator over an EnumSet
 pub struct Items<E> {
     index: uint,
@@ -240,22 +230,6 @@ 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::*;
@@ -295,20 +269,6 @@ 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
 
@@ -438,29 +398,9 @@ mod test {
         let elems = e_intersection.iter().collect();
         assert_eq!(vec![C], elems)
 
-        // Another way to express intersection
-        let e_intersection = e1 - (e1 - e2);
-        let elems = e_intersection.iter().collect();
-        assert_eq!(vec![C], elems)
-
         let e_subtract = e1 - e2;
         let elems = e_subtract.iter().collect();
         assert_eq!(vec![A], elems)
-
-        // Bitwise XOR of two sets, aka symmetric difference
-        let e_symmetric_diff = e1 ^ e2;
-        let elems = e_symmetric_diff.iter().collect();
-        assert_eq!(vec![A,B], elems)
-
-        // Another way to express symmetric difference
-        let e_symmetric_diff = (e1 - e2) | (e2 - e1);
-        let elems = e_symmetric_diff.iter().collect();
-        assert_eq!(vec![A,B], elems)
-
-        // Yet another way to express symmetric difference
-        let e_symmetric_diff = (e1 | e2) - (e1 & e2);
-        let elems = e_symmetric_diff.iter().collect();
-        assert_eq!(vec![A,B], elems)
     }
 
     #[test]

branches/auto/src/libcollections/ring_buf.rs

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

branches/auto/src/libcollections/string.rs

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

branches/auto/src/libcollections/tree/map.rs

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

branches/auto/src/libcollections/tree/set.rs

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

branches/auto/src/libcollections/trie/map.rs

@@ -628,7 +628,7 @@ impl<T> FromIterator<(uint, T)> for TrieMap<T> {
     }
 }
 
-impl<T> Extend<(uint, T)> for TrieMap<T> {
+impl<T> Extendable<(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);

branches/auto/src/libcollections/trie/set.rs

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

branches/auto/src/libcollections/vec.rs

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

branches/auto/src/libcollections/vec_map.rs

@@ -499,7 +499,7 @@ impl<V> FromIterator<(uint, V)> for VecMap<V> {
     }
 }
 
-impl<V> Extend<(uint, V)> for VecMap<V> {
+impl<V> Extendable<(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);