---

yaml
---
r: 128446
b: refs/heads/auto
c: 1824973
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: d283574558b98b659997fd7bc97028158297388c
+refs/heads/auto: 1824973a139443b15e2c093b3e316169f2792cb3
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/README.md

@@ -19,7 +19,7 @@ for the 'std' and 'extra' libraries.
 To generate HTML documentation from one source file/crate, do something like:
 
 ~~~~
-rustdoc --output-dir html-doc/ --output-format html ../src/libstd/path.rs
+rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
 ~~~~
 
 (This, of course, requires a working build of the `rustdoc` tool.)

branches/auto/src/etc/emacs/rust-mode.el

@@ -170,7 +170,7 @@
 (defconst rust-mode-keywords
   '("as"
     "box" "break"
-    "continue" "crate"
+    "const" "continue" "crate"
     "do"
     "else" "enum" "extern"
     "false" "fn" "for"
@@ -182,7 +182,8 @@
     "self" "static" "struct" "super"
     "true" "trait" "type"
     "unsafe" "use"
-    "while"))
+    "virtual"
+    "where" "while"))
 
 (defconst rust-special-types
   '("u8" "i8"

branches/auto/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -71,6 +71,8 @@
 		<keyword>trait</keyword>
 		<keyword>unsafe</keyword>
 		<keyword>use</keyword>
+		<keyword>virtual</keyword>
+		<keyword>where</keyword>
 		<keyword>while</keyword>
     </context>
 

branches/auto/src/etc/kate/rust.xml

@@ -19,6 +19,7 @@
 		<item> as </item>
 		<item> break </item>
 		<item> box </item>
+		<item> const </item>
 		<item> continue </item>
 		<item> crate </item>
 		<item> do </item>
@@ -44,6 +45,8 @@
 		<item> trait </item>
 		<item> unsafe </item>
 		<item> use </item>
+		<item> virtual </item>
+		<item> where </item>
 		<item> while </item>
 	</list>
 	<list name="traits">

branches/auto/src/etc/vim/syntax/rust.vim

@@ -26,7 +26,7 @@ syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite skipempty
 syn keyword   rustKeyword     for in if impl let
 syn keyword   rustKeyword     loop once proc pub
 syn keyword   rustKeyword     return super
-syn keyword   rustKeyword     unsafe virtual while
+syn keyword   rustKeyword     unsafe virtual where while
 syn keyword   rustKeyword     use nextgroup=rustModPath,rustModPathInUse skipwhite skipempty
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty

branches/auto/src/libcollections/bitv.rs

@@ -75,6 +75,25 @@ use std::hash;
 use {Mutable, Set, MutableSet, MutableSeq};
 use vec::Vec;
 
+// Take two BitV's, and return iterators of their words, where the shorter one
+// has been padded with 0's
+macro_rules! match_words(
+    ($a_expr:expr, $b_expr:expr) => ({
+        let a = $a_expr;
+        let b = $b_expr;
+        let a_len = a.storage.len();
+        let b_len = b.storage.len();
+
+        // have to uselessly pretend to pad the longer one for type matching
+        if a_len < b_len {
+            (a.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(b_len).skip(a_len)),
+             b.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(0).skip(0)))
+        } else {
+            (a.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(0).skip(0)),
+             b.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(a_len).skip(b_len)))
+        }
+    })
+)
 
 static TRUE: bool = true;
 static FALSE: bool = false;
@@ -969,7 +988,7 @@ impl<'a> RandomAccessIterator<bool> for Bits<'a> {
 /// assert!(bv.eq_vec([true, true, false, true,
 ///                    false, false, false, false]));
 /// ```
-#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[deriving(Clone)]
 pub struct BitvSet(Bitv);
 
 impl Default for BitvSet {
@@ -992,6 +1011,32 @@ impl Extendable<bool> for BitvSet {
     }
 }
 
+impl PartialOrd for BitvSet {
+    #[inline]
+    fn partial_cmp(&self, other: &BitvSet) -> Option<Ordering> {
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
+        iter::order::partial_cmp(a_iter, b_iter)
+    }
+}
+
+impl Ord for BitvSet {
+    #[inline]
+    fn cmp(&self, other: &BitvSet) -> Ordering {
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
+        iter::order::cmp(a_iter, b_iter)
+    }
+}
+
+impl cmp::PartialEq for BitvSet {
+    #[inline]
+    fn eq(&self, other: &BitvSet) -> bool {
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
+        iter::order::eq(a_iter, b_iter)
+    }
+}
+
+impl cmp::Eq for BitvSet {}
+
 impl BitvSet {
     /// Create a new bit vector set with initially no contents.
     ///
@@ -1141,10 +1186,18 @@ impl BitvSet {
         // Unwrap Bitvs
         let &BitvSet(ref mut self_bitv) = self;
         let &BitvSet(ref other_bitv) = other;
+
         // Expand the vector if necessary
         self_bitv.reserve(other_bitv.capacity());
-        // Apply values
-        for (i, w) in other_bitv.mask_words(0) {
+
+        // virtually pad other with 0's for equal lengths
+        let self_len = self_bitv.storage.len();
+        let other_len =  other_bitv.storage.len();
+        let mut other_words = other_bitv.mask_words(0)
+         .chain(iter::Repeat::new(0u).enumerate().take(self_len).skip(other_len));
+
+        // Apply values found in other
+        for (i, w) in other_words {
             let old = self_bitv.storage[i];
             let new = f(old, w);
             *self_bitv.storage.get_mut(i) = new;
@@ -1271,7 +1324,7 @@ impl BitvSet {
     /// let a = BitvSet::from_bitv(bitv::from_bytes([0b01101000]));
     /// let b = BitvSet::from_bitv(bitv::from_bytes([0b10100000]));
     ///
-    /// // Print 2, 4 in arbitrary order
+    /// // Print 1, 4 in arbitrary order
     /// for x in a.difference(&b) {
     ///     println!("{}", x);
     /// }
@@ -2213,6 +2266,64 @@ mod tests {
         assert!(set1.is_subset(&set2)); // { 2 }  { 2, 4 }
     }
 
+    #[test]
+    fn test_bitv_set_intersect_with() {
+        // Explicitly 0'ed bits
+        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let mut b = BitvSet::from_bitv(from_bytes([0b00000000]));
+        let c = a.clone();
+        a.intersect_with(&b);
+        b.intersect_with(&c);
+        assert!(a.is_empty());
+        assert!(b.is_empty());
+
+        // Uninitialized bits should behave like 0's
+        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let mut b = BitvSet::new();
+        let c = a.clone();
+        a.intersect_with(&b);
+        b.intersect_with(&c);
+        assert!(a.is_empty());
+        assert!(b.is_empty());
+
+        // Standard
+        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let mut b = BitvSet::from_bitv(from_bytes([0b01100010]));
+        let c = a.clone();
+        a.intersect_with(&b);
+        b.intersect_with(&c);
+        assert_eq!(a.len(), 2);
+        assert_eq!(b.len(), 2);
+    }
+
+    #[test]
+    fn test_bitv_set_eq() {
+        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let b = BitvSet::from_bitv(from_bytes([0b00000000]));
+        let c = BitvSet::new();
+
+        assert!(a == a);
+        assert!(a != b);
+        assert!(a != c);
+        assert!(b == b);
+        assert!(b == c);
+        assert!(c == c);
+    }
+
+    #[test]
+    fn test_bitv_set_cmp() {
+        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let b = BitvSet::from_bitv(from_bytes([0b00000000]));
+        let c = BitvSet::new();
+
+        assert_eq!(a.cmp(&b), Greater);
+        assert_eq!(a.cmp(&c), Greater);
+        assert_eq!(b.cmp(&a), Less);
+        assert_eq!(b.cmp(&c), Equal);
+        assert_eq!(c.cmp(&a), Less);
+        assert_eq!(c.cmp(&b), Equal);
+    }
+
     #[test]
     fn test_bitv_remove() {
         let mut a = BitvSet::new();

branches/auto/src/libcollections/btree.rs

@@ -11,6 +11,13 @@
 // btree.rs
 //
 
+// NB. this is not deprecated for removal, just deprecating the
+// current implementation. If the major pain-points are addressed
+// (overuse of by-value self and .clone), this can be removed.
+#![deprecated = "the current implementation is extremely inefficient, \
+                 prefer a HashMap, TreeMap or TrieMap"]
+#![allow(deprecated)]
+
 //! Starting implementation of a btree for rust.
 //! Structure inspired by github user davidhalperin's gist.
 

branches/auto/src/libnum/bigint.rs

@@ -59,7 +59,7 @@
 use Integer;
 use rand::Rng;
 
-use std::{cmp, fmt};
+use std::{cmp, fmt, hash};
 use std::default::Default;
 use std::from_str::FromStr;
 use std::num::CheckedDiv;
@@ -150,6 +150,22 @@ impl Default for BigUint {
     fn default() -> BigUint { Zero::zero() }
 }
 
+impl<S: hash::Writer> hash::Hash<S> for BigUint {
+    fn hash(&self, state: &mut S) {
+        // hash 0 in case it's all 0's
+        0u32.hash(state);
+
+        let mut found_first_value = false;
+        for elem in self.data.iter().rev() {
+            // don't hash any leading 0's, they shouldn't affect the hash
+            if found_first_value || *elem != 0 {
+                found_first_value = true;
+                elem.hash(state);
+            }
+        }
+    }
+}
+
 impl fmt::Show for BigUint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.to_str_radix(10))
@@ -881,6 +897,13 @@ impl fmt::Show for BigInt {
     }
 }
 
+impl<S: hash::Writer> hash::Hash<S> for BigInt {
+    fn hash(&self, state: &mut S) {
+        (self.sign == Plus).hash(state);
+        self.data.hash(state);
+    }
+}
+
 impl FromStr for BigInt {
     #[inline]
     fn from_str(s: &str) -> Option<BigInt> {
@@ -1409,6 +1432,7 @@ mod biguint_tests {
     use std::num::CheckedDiv;
     use std::rand::task_rng;
     use std::u64;
+    use std::hash::hash;
 
     #[test]
     fn test_from_slice() {
@@ -1460,6 +1484,19 @@ mod biguint_tests {
         }
     }
 
+    #[test]
+    fn test_hash() {
+        let a = BigUint::new(vec!());
+        let b = BigUint::new(vec!(0));
+        let c = BigUint::new(vec!(1));
+        let d = BigUint::new(vec!(1,0,0,0,0,0));
+        let e = BigUint::new(vec!(0,0,0,0,0,1));
+        assert!(hash(&a) == hash(&b));
+        assert!(hash(&b) != hash(&c));
+        assert!(hash(&c) == hash(&d));
+        assert!(hash(&d) != hash(&e));
+    }
+
     #[test]
     fn test_bitand() {
         fn check(left: &[BigDigit],
@@ -2257,6 +2294,7 @@ mod bigint_tests {
     use std::num::{ToPrimitive, FromPrimitive};
     use std::rand::task_rng;
     use std::u64;
+    use std::hash::hash;
 
     #[test]
     fn test_from_biguint() {
@@ -2314,6 +2352,21 @@ mod bigint_tests {
         }
     }
 
+    #[test]
+    fn test_hash() {
+        let a = BigInt::new(Zero, vec!());
+        let b = BigInt::new(Zero, vec!(0));
+        let c = BigInt::new(Plus, vec!(1));
+        let d = BigInt::new(Plus, vec!(1,0,0,0,0,0));
+        let e = BigInt::new(Plus, vec!(0,0,0,0,0,1));
+        let f = BigInt::new(Minus, vec!(1));
+        assert!(hash(&a) == hash(&b));
+        assert!(hash(&b) != hash(&c));
+        assert!(hash(&c) == hash(&d));
+        assert!(hash(&d) != hash(&e));
+        assert!(hash(&c) != hash(&f));
+    }
+
     #[test]
     fn test_convert_i64() {
         fn check(b1: BigInt, i: i64) {

branches/auto/src/libnum/lib.rs

@@ -43,6 +43,7 @@
 //! [newt]: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
 
 #![feature(macro_rules)]
+#![feature(default_type_params)]
 
 #![crate_name = "num"]
 #![experimental]

branches/auto/src/librustc/back/link.rs

@@ -1475,6 +1475,9 @@ fn link_args(cmd: &mut Command,
 
         // Always enable DEP (NX bit) when it is available
         cmd.arg("-Wl,--nxcompat");
+
+        // Mark all dynamic libraries and executables as compatible with ASLR
+        cmd.arg("-Wl,--dynamicbase");
     }
 
     if sess.targ_cfg.os == abi::OsAndroid {