---

yaml
---
r: 128483
b: refs/heads/auto
c: a4bbb5b
h: refs/heads/master
i:
  128481: c698486
  128479: d15f566
v: v3

Author: nham

[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: c8835104797335818bc1d5b0df61ce9f5907cd16
+refs/heads/auto: a4bbb5bab4ea49bc0f4cb9638f27a7eb68e1bdb6
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide.md

@@ -517,7 +517,7 @@ note: in expansion of format_args!
 <std macros>:1:1: 3:2 note: in expansion of println!
 src/hello_world.rs:4:5: 4:42 note: expansion site
 error: aborting due to previous error
-Could not compile `hello_world`.
+Could not execute process `rustc src/hello_world.rs --crate-type bin --out-dir /home/you/projects/hello_world/target -L /home/you/projects/hello_world/target -L /home/you/projects/hello_world/target/deps` (status=101)
 ```
 
 Rust will not let us use a value that has not been initialized. So why let us
@@ -532,7 +532,7 @@ in the middle of a string." We add a comma, and then `x`, to indicate that we
 want `x` to be the value we're interpolating. The comma is used to separate
 arguments we pass to functions and macros, if you're passing more than one.
 
-When you just use the curly braces, Rust will attempt to display the
+When you just use the double curly braces, Rust will attempt to display the
 value in a meaningful way by checking out its type. If you want to specify the
 format in a more detailed manner, there are a [wide number of options
 available](/std/fmt/index.html). For now, we'll just stick to the default:
@@ -1888,16 +1888,8 @@ fn main() {
 
 The first thing we changed was to `use std::rand`, as the docs
 explained.  We then added in a `let` expression to create a variable binding
-named `secret_number`, and we printed out its result.
-
-Also, you may wonder why we are using `%` on the result of `rand::random()`.
-This operator is called 'modulo', and it returns the remainder of a division.
-By taking the modulo of the result of `rand::random()`, we're limiting the
-values to be between 0 and 99. Then, we add one to the result, making it from 1
-to 100. Using modulo can give you a very, very small bias in the result, but
-for this example, it is not important.
-
-Let's try to compile this using `cargo build`:
+named `secret_number`, and we printed out its result. Let's try to compile
+this using `cargo build`:
 
 ```{notrust,no_run}
 $ cargo build

branches/auto/src/doc/rust.md

@@ -169,10 +169,6 @@ sequence (`/**`), are interpreted as a special syntax for `doc`
 `#[doc="..."]` around the body of the comment (this includes the comment
 characters themselves, ie `/// Foo` turns into `#[doc="/// Foo"]`).
 
-`//!` comments apply to the parent of the comment, rather than the item that
-follows. `//!` comments are usually used to display information on the crate
-index page.
-
 Non-doc comments are interpreted as a form of whitespace.
 
 ## Whitespace

branches/auto/src/libcollections/bitv.rs

@@ -66,7 +66,7 @@ use core::prelude::*;
 use core::cmp;
 use core::default::Default;
 use core::fmt;
-use core::iter::{Chain, Enumerate, Repeat, Skip, Take};
+use core::iter::Take;
 use core::iter;
 use core::slice;
 use core::uint;
@@ -75,22 +75,25 @@ use std::hash;
 use {Mutable, Set, MutableSet, MutableSeq};
 use vec::Vec;
 
-type MatchWords<'a> = Chain<MaskWords<'a>, Skip<Take<Enumerate<Repeat<uint>>>>>;
 // Take two BitV's, and return iterators of their words, where the shorter one
 // has been padded with 0's
-fn match_words <'a,'b>(a: &'a Bitv, b: &'b Bitv) -> (MatchWords<'a>, MatchWords<'b>) {
-    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(Repeat::new(0u).enumerate().take(b_len).skip(a_len)),
-         b.mask_words(0).chain(Repeat::new(0u).enumerate().take(0).skip(0)))
-    } else {
-        (a.mask_words(0).chain(Repeat::new(0u).enumerate().take(0).skip(0)),
-         b.mask_words(0).chain(Repeat::new(0u).enumerate().take(a_len).skip(b_len)))
-    }
-}
+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;
@@ -1011,23 +1014,23 @@ 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());
+        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());
+        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());
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
         iter::order::eq(a_iter, b_iter)
     }
 }
@@ -1188,10 +1191,10 @@ impl BitvSet {
         self_bitv.reserve(other_bitv.capacity());
 
         // virtually pad other with 0's for equal lengths
-        let mut other_words = {
-            let (_, result) = match_words(self_bitv, other_bitv);
-            result
-        };
+        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 {
@@ -1521,7 +1524,7 @@ impl Set<uint> for BitvSet {
 
     #[inline]
     fn is_disjoint(&self, other: &BitvSet) -> bool {
-        self.intersection(other).next().is_none()
+        self.intersection(other).count() > 0
     }
 
     #[inline]
@@ -2263,24 +2266,6 @@ mod tests {
         assert!(set1.is_subset(&set2)); // { 2 }  { 2, 4 }
     }
 
-    #[test]
-    fn test_bitv_set_is_disjoint() {
-        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let b = BitvSet::from_bitv(from_bytes([0b01000000]));
-        let c = BitvSet::new();
-        let d = BitvSet::from_bitv(from_bytes([0b00110000]));
-
-        assert!(!a.is_disjoint(&d));
-        assert!(!d.is_disjoint(&a));
-
-        assert!(a.is_disjoint(&b))
-        assert!(a.is_disjoint(&c))
-        assert!(b.is_disjoint(&a))
-        assert!(b.is_disjoint(&c))
-        assert!(c.is_disjoint(&a))
-        assert!(c.is_disjoint(&b))
-    }
-
     #[test]
     fn test_bitv_set_intersect_with() {
         // Explicitly 0'ed bits

branches/auto/src/libcollections/str.rs

@@ -44,6 +44,17 @@ the string is valid for the `'static` lifetime, otherwise known as the
 lifetime of the entire program. As can be inferred from the type, these static
 strings are not mutable.
 
+# Mutability
+
+Many languages have immutable strings by default, and Rust has a particular
+flavor on this idea. As with the rest of Rust types, strings are immutable by
+default. If a string is declared as `mut`, however, it may be mutated. This
+works the same way as the rest of Rust's type system in the sense that if
+there's a mutable reference to a string, there may only be one mutable reference
+to that string. With these guarantees, strings can easily transition between
+being mutable/immutable with the same benefits of having mutable strings in
+other languages.
+
 # Representation
 
 Rust's string type, `str`, is a sequence of unicode scalar values encoded as a

branches/auto/src/libcore/num/mod.rs

@@ -1345,19 +1345,17 @@ checked_impl!(CheckedMul, checked_mul, i16, intrinsics::i16_mul_with_overflow)
 checked_impl!(CheckedMul, checked_mul, i32, intrinsics::i32_mul_with_overflow)
 checked_impl!(CheckedMul, checked_mul, i64, intrinsics::i64_mul_with_overflow)
 
-/// Performs division that returns `None` instead of failing on division by zero and instead of
-/// wrapping around on underflow and overflow.
+/// Performs division that returns `None` instead of wrapping around on underflow or overflow.
 pub trait CheckedDiv: Div<Self, Self> {
-    /// Divides two numbers, checking for underflow, overflow and division by zero. If any of that
-    /// happens, / `None` is returned.
+    /// Divides two numbers, checking for underflow or overflow. If underflow or overflow happens,
+    /// `None` is returned.
     ///
     /// # Example
     ///
     /// ```rust
     /// use std::num::CheckedDiv;
     /// assert_eq!((-127i8).checked_div(&-1), Some(127));
     /// assert_eq!((-128i8).checked_div(&-1), None);
-    /// assert_eq!((1i8).checked_div(&0), None);
     /// ```
     fn checked_div(&self, v: &Self) -> Option<Self>;
 }

branches/auto/src/libcore/option.rs

@@ -244,7 +244,7 @@ impl<T> Option<T> {
         }
     }
 
-    /// Returns the inner `T` of a `Some(T)`.
+    /// Moves a value out of an option type and returns it, consuming the `Option`.
     ///
     /// # Failure
     ///

branches/auto/src/libcore/str.rs

@@ -562,7 +562,7 @@ enum Searcher {
 impl Searcher {
     fn new(haystack: &[u8], needle: &[u8]) -> Searcher {
         // FIXME: Tune this.
-        if needle.len() > haystack.len() - 20 {
+        if needle.len() + 20 > haystack.len() {
             Naive(NaiveSearcher::new())
         } else {
             let searcher = TwoWaySearcher::new(needle);

branches/auto/src/librustc/middle/trans/base.rs

@@ -87,7 +87,7 @@ use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use std::{i8, i16, i32, i64};
 use syntax::abi::{X86, X86_64, Arm, Mips, Mipsel, Rust, RustCall};
-use syntax::abi::{RustIntrinsic, Abi, OsWindows};
+use syntax::abi::{RustIntrinsic, Abi};
 use syntax::ast_util::{local_def, is_local};
 use syntax::attr::AttrMetaMethods;
 use syntax::attr;
@@ -2446,13 +2446,6 @@ pub fn create_entry_wrapper(ccx: &CrateContext,
                                &ccx.int_type);
 
         let llfn = decl_cdecl_fn(ccx, "main", llfty, ty::mk_nil());
-
-        // FIXME: #16581: Marking a symbol in the executable with `dllexport`
-        // linkage forces MinGW's linker to output a `.reloc` section for ASLR
-        if ccx.sess().targ_cfg.os == OsWindows {
-            unsafe { llvm::LLVMRustSetDLLExportStorageClass(llfn) }
-        }
-
         let llbb = "top".with_c_str(|buf| {
             unsafe {
                 llvm::LLVMAppendBasicBlockInContext(ccx.llcx, llfn, buf)

branches/auto/src/libstd/io/fs.rs

@@ -236,15 +236,10 @@ impl File {
         })
     }
 
-    /// Returns true if the stream has reached the end of the file.
+    /// Tests whether this stream has reached EOF.
     ///
     /// If true, then this file will no longer continue to return data via
     /// `read`.
-    ///
-    /// Note that the operating system will not return an `EOF` indicator
-    /// until you have attempted to read past the end of the file, so if
-    /// you've read _exactly_ the number of bytes in the file, this will
-    /// return `false`, not `true`.
     pub fn eof(&self) -> bool {
         self.last_nread == 0
     }

branches/auto/src/libtime/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -90,30 +90,6 @@ impl Timespec {
     }
 }
 
-impl Add<Timespec, Timespec> for Timespec {
-    fn add(&self, other: &Timespec) -> Timespec {
-        let mut sec = self.sec + other.sec;
-        let mut nsec = self.nsec + other.nsec;
-        if nsec >= NSEC_PER_SEC {
-            nsec -= NSEC_PER_SEC;
-            sec += 1;
-        }
-        Timespec::new(sec, nsec)
-    }
-}
-
-impl Sub<Timespec, Timespec> for Timespec {
-    fn sub(&self, other: &Timespec) -> Timespec {
-        let mut sec = self.sec - other.sec;
-        let mut nsec = self.nsec - other.nsec;
-        if nsec < 0 {
-            nsec += NSEC_PER_SEC;
-            sec -= 1;
-        }
-        Timespec::new(sec, nsec)
-    }
-}
-
 /**
  * Returns the current time as a `timespec` containing the seconds and
  * nanoseconds since 1970-01-01T00:00:00Z.
@@ -1513,46 +1489,6 @@ mod tests {
         assert!(d.gt(c));
     }
 
-    fn test_timespec_add() {
-        let a = Timespec::new(1, 2);
-        let b = Timespec::new(2, 3);
-        let c = a + b;
-        assert_eq!(c.sec, 3);
-        assert_eq!(c.nsec, 5);
-
-        let p = Timespec::new(1, super::NSEC_PER_SEC - 2);
-        let q = Timespec::new(2, 2);
-        let r = p + q;
-        assert_eq!(r.sec, 4);
-        assert_eq!(r.nsec, 0);
-
-        let u = Timespec::new(1, super::NSEC_PER_SEC - 2);
-        let v = Timespec::new(2, 3);
-        let w = u + v;
-        assert_eq!(w.sec, 4);
-        assert_eq!(w.nsec, 1);
-    }
-
-    fn test_timespec_sub() {
-        let a = Timespec::new(2, 3);
-        let b = Timespec::new(1, 2);
-        let c = a - b;
-        assert_eq!(c.sec, 1);
-        assert_eq!(c.nsec, 1);
-
-        let p = Timespec::new(2, 0);
-        let q = Timespec::new(1, 2);
-        let r = p - q;
-        assert_eq!(r.sec, 0);
-        assert_eq!(r.nsec, super::NSEC_PER_SEC - 2);
-
-        let u = Timespec::new(1, 2);
-        let v = Timespec::new(2, 3);
-        let w = u - v;
-        assert_eq!(w.sec, -2);
-        assert_eq!(w.nsec, super::NSEC_PER_SEC - 1);
-    }
-
     #[test]
     #[ignore(cfg(target_os = "android"))] // FIXME #10958
     fn run_tests() {
@@ -1569,8 +1505,6 @@ mod tests {
         test_ctime();
         test_strftime();
         test_timespec_eq_ord();
-        test_timespec_add();
-        test_timespec_sub();
     }
 
     #[bench]