---

yaml
---
r: 128463
b: refs/heads/auto
c: fb4201f
h: refs/heads/master
i:
  128461: 7062278
  128459: 0748407
  128455: 3e4bcbe
  128447: 90a7d4a
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: 46f27c9d965352497231490664ed37e6cdf7787e
+refs/heads/auto: fb4201ff34f445f6c4d16c01b38dea65bad8ada1
 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/doc/guide.md

@@ -3669,10 +3669,9 @@ manually free this allocation! If we write
 ```
 
 then Rust will automatically free `x` at the end of the block. This isn't
-because Rust has a garbage collector -- it doesn't. Instead, Rust uses static
-analysis to determine the *lifetime* of `x`, and then generates code to free it
-once it's sure the `x` won't be used again. This Rust code will do the same
-thing as the following C code:
+because Rust has a garbage collector -- it doesn't. Instead, when `x` goes out
+of scope, Rust `free`s `x`. This Rust code will do the same thing as the
+following C code:
 
 ```{c,ignore}
 {

branches/auto/src/doc/rust.md

@@ -1801,7 +1801,7 @@ module through the rules above. It essentially allows public access into the
 re-exported item. For example, this program is valid:
 
 ~~~~
-pub use api = self::implementation;
+pub use self::implementation as api;
 
 mod implementation {
     pub fn f() {}

branches/auto/src/doc/tutorial.md

@@ -3112,7 +3112,7 @@ use farm::*;
 However, that's not all. You can also rename an item while you're bringing it into scope:
 
 ~~~
-use egg_layer = farm::chicken;
+use farm::chicken as egg_layer;
 # mod farm { pub fn chicken() { println!("Laying eggs is fun!")  } }
 // ...
 
@@ -3335,7 +3335,7 @@ you just have to import it with an `use` statement.
 For example, it re-exports `range` which is defined in `std::iter::range`:
 
 ~~~
-use iter_range = std::iter::range;
+use std::iter::range as iter_range;
 
 fn main() {
     // `range` is imported by default

branches/auto/src/liballoc/lib.rs

@@ -86,7 +86,7 @@ extern crate libc;
 
 #[deprecated = "use boxed instead"]
 #[cfg(not(test))]
-pub use owned = boxed;
+pub use boxed as owned;
 
 // Heaps provided for low-level allocation strategies
 

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;
@@ -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/hash/mod.rs

@@ -73,7 +73,7 @@ use core::mem;
 use vec::Vec;
 
 /// Reexport the `sip::hash` function as our default hasher.
-pub use hash = self::sip::hash;
+pub use self::sip::hash as hash;
 
 pub mod sip;
 

branches/auto/src/libcollections/string.rs

@@ -19,13 +19,13 @@ use core::fmt;
 use core::mem;
 use core::ptr;
 // FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait
-use RawSlice = core::raw::Slice;
+use core::raw::Slice as RawSlice;
 
 use {Mutable, MutableSeq};
 use hash;
 use str;
 use str::{CharRange, StrAllocating, MaybeOwned, Owned};
-use MaybeOwnedSlice = str::Slice; // So many `Slice`s...
+use str::Slice as MaybeOwnedSlice; // So many `Slice`s...
 use vec::Vec;
 
 /// A growable string stored as a UTF-8 encoded buffer.

branches/auto/src/libcollections/vec.rs

@@ -13,13 +13,13 @@
 use core::prelude::*;
 
 use alloc::heap::{allocate, reallocate, deallocate};
-use RawSlice = core::raw::Slice;
 use core::cmp::max;
 use core::default::Default;
 use core::fmt;
 use core::mem;
 use core::num;
 use core::ptr;
+use core::raw::Slice as RawSlice;
 use core::uint;
 
 use {Mutable, MutableSeq};

branches/auto/src/libcore/kinds.rs

@@ -21,7 +21,7 @@ by the compiler automatically for the types to which they apply.
 */
 
 #[deprecated = "This has been renamed to Sync"]
-pub use Share = self::Sync;
+pub use self::Sync as Share;
 
 /// Types able to be transferred across task boundaries.
 #[lang="send"]

branches/auto/src/libcore/lib.rs

@@ -107,7 +107,7 @@ pub mod collections;
 /// Deprecated module in favor of `std::cell`
 pub mod ty {
     #[deprecated = "this type has been renamed to `UnsafeCell`"]
-    pub use Unsafe = cell::UnsafeCell;
+    pub use cell::UnsafeCell as Unsafe;
 }
 
 /* Core types and methods on primitives */

branches/auto/src/libcore/slice.rs

@@ -50,7 +50,7 @@ use mem::size_of;
 use kinds::marker;
 use raw::Repr;
 // Avoid conflicts with *both* the Slice trait (buggy) and the `slice::raw` module.
-use RawSlice = raw::Slice;
+use raw::Slice as RawSlice;
 
 
 //

branches/auto/src/libgraphviz/lib.rs

@@ -47,7 +47,7 @@ forming a diamond-shaped acyclic graph and then pointing to the fifth
 which is cyclic.
 
 ```rust
-use dot = graphviz;
+use graphviz as dot;
 use graphviz::maybe_owned_vec::IntoMaybeOwnedVector;
 
 type Nd = int;
@@ -147,7 +147,7 @@ labelled with the ⊆ character (specified using the HTML character
 entity `&sube`).
 
 ```rust
-use dot = graphviz;
+use graphviz as dot;
 use std::str;
 
 type Nd = uint;
@@ -203,7 +203,7 @@ The output from this example is the same as the second example: the
 Hasse-diagram for the subsets of the set `{x, y}`.
 
 ```rust
-use dot = graphviz;
+use graphviz as dot;
 use std::str;
 
 type Nd<'a> = (uint, &'a str);

branches/auto/src/libgreen/message_queue.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use alloc::arc::Arc;
-use mpsc = std::sync::mpsc_queue;
+use std::sync::mpsc_queue as mpsc;
 use std::kinds::marker;
 
 pub enum PopResult<T> {

branches/auto/src/libgreen/sched.rs

@@ -25,7 +25,7 @@ use coroutine::Coroutine;
 use sleeper_list::SleeperList;
 use stack::StackPool;
 use task::{TypeSched, GreenTask, HomeSched, AnySched};
-use msgq = message_queue;
+use message_queue as msgq;
 
 /// A scheduler is responsible for coordinating the execution of Tasks
 /// on a single thread. The scheduler runs inside a slightly modified

branches/auto/src/liblibc/lib.rs

@@ -1456,47 +1456,13 @@ pub mod types {
                     pub Data4: [BYTE, ..8],
                 }
 
-                // NOTE(pcwalton, stage0): Remove after snapshot (typeck bug
-                // workaround).
-                #[cfg(stage0)]
-                pub struct WSAPROTOCOLCHAIN {
-                    pub ChainLen: c_int,
-                    pub ChainEntries: [DWORD, ..MAX_PROTOCOL_CHAIN],
-                }
-                #[cfg(not(stage0))]
                 pub struct WSAPROTOCOLCHAIN {
                     pub ChainLen: c_int,
                     pub ChainEntries: [DWORD, ..MAX_PROTOCOL_CHAIN as uint],
                 }
 
                 pub type LPWSAPROTOCOLCHAIN = *mut WSAPROTOCOLCHAIN;
 
-                // NOTE(pcwalton, stage0): Remove after snapshot (typeck bug
-                // workaround).
-                #[cfg(stage0)]
-                pub struct WSAPROTOCOL_INFO {
-                    pub dwServiceFlags1: DWORD,
-                    pub dwServiceFlags2: DWORD,
-                    pub dwServiceFlags3: DWORD,
-                    pub dwServiceFlags4: DWORD,
-                    pub dwProviderFlags: DWORD,
-                    pub ProviderId: GUID,
-                    pub dwCatalogEntryId: DWORD,
-                    pub ProtocolChain: WSAPROTOCOLCHAIN,
-                    pub iVersion: c_int,
-                    pub iAddressFamily: c_int,
-                    pub iMaxSockAddr: c_int,
-                    pub iMinSockAddr: c_int,
-                    pub iSocketType: c_int,
-                    pub iProtocol: c_int,
-                    pub iProtocolMaxOffset: c_int,
-                    pub iNetworkByteOrder: c_int,
-                    pub iSecurityScheme: c_int,
-                    pub dwMessageSize: DWORD,
-                    pub dwProviderReserved: DWORD,
-                    pub szProtocol: [u8, ..WSAPROTOCOL_LEN+1],
-                }
-                #[cfg(not(stage0))]
                 pub struct WSAPROTOCOL_INFO {
                     pub dwServiceFlags1: DWORD,
                     pub dwServiceFlags2: DWORD,

branches/auto/src/libnative/io/mod.rs

@@ -79,8 +79,8 @@ mod tty;
 #[cfg(windows)] #[path = "c_win32.rs"] mod c;
 
 fn unimpl() -> IoError {
-    #[cfg(unix)] use ERROR = libc::ENOSYS;
-    #[cfg(windows)] use ERROR = libc::ERROR_CALL_NOT_IMPLEMENTED;
+    #[cfg(unix)] use libc::ENOSYS as ERROR;
+    #[cfg(windows)] use libc::ERROR_CALL_NOT_IMPLEMENTED as ERROR;
     IoError {
         code: ERROR as uint,
         extra: 0,