---

yaml
---
r: 128487
b: refs/heads/auto
c: 51b901e
h: refs/heads/master
i:
  128485: 4a6baab
  128483: cd27b93
  128479: d15f566
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: f2aa88ca0676249d9c44bb6a2e59cd2b1cdd9c9a
+refs/heads/auto: 51b901e16048c5adbe1f12428fe5a79603478f83
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide.md

@@ -1888,8 +1888,16 @@ 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. Let's try to compile
-this using `cargo build`:
+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`:
 
 ```{notrust,no_run}
 $ cargo build

branches/auto/src/doc/rust.md

@@ -169,6 +169,10 @@ 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::Take;
+use core::iter::{Chain, Enumerate, Repeat, Skip, Take};
 use core::iter;
 use core::slice;
 use core::uint;
@@ -75,25 +75,22 @@ 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
-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)))
-        }
-    })
-)
+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)))
+    }
+}
 
 static TRUE: bool = true;
 static FALSE: bool = false;
@@ -1017,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)
     }
 }
@@ -1194,10 +1191,10 @@ impl BitvSet {
         self_bitv.reserve(other_bitv.capacity());
 
         // 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));
+        let mut other_words = {
+            let (_, result) = match_words(self_bitv, other_bitv);
+            result
+        };
 
         // Apply values found in other
         for (i, w) in other_words {
@@ -1529,7 +1526,7 @@ impl Set<uint> for BitvSet {
 
     #[inline]
     fn is_disjoint(&self, other: &BitvSet) -> bool {
-        self.intersection(other).count() > 0
+        self.intersection(other).next().is_none()
     }
 
     #[inline]
@@ -2271,6 +2268,24 @@ 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/libcore/num/mod.rs

@@ -1345,17 +1345,19 @@ 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 wrapping around on underflow or overflow.
+/// Performs division that returns `None` instead of failing on division by zero and instead of
+/// wrapping around on underflow and overflow.
 pub trait CheckedDiv: Div<Self, Self> {
-    /// Divides two numbers, checking for underflow or overflow. If underflow or overflow happens,
-    /// `None` is returned.
+    /// Divides two numbers, checking for underflow, overflow and division by zero. If any of that
+    /// 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/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/libcoretest/lib.rs

@@ -29,4 +29,5 @@ mod ptr;
 mod raw;
 mod result;
 mod slice;
+mod str;
 mod tuple;

branches/auto/src/libcoretest/str.rs

@@ -0,0 +1,14 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[test]
+fn strslice_issue_16589() {
+    assert!("bananas".contains("nana"));
+}

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};
+use syntax::abi::{RustIntrinsic, Abi, OsWindows};
 use syntax::ast_util::{local_def, is_local};
 use syntax::attr::AttrMetaMethods;
 use syntax::attr;
@@ -2446,6 +2446,13 @@ 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/libtime/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -90,6 +90,30 @@ 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.
@@ -1489,6 +1513,46 @@ 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() {
@@ -1505,6 +1569,8 @@ mod tests {
         test_ctime();
         test_strftime();
         test_timespec_eq_ord();
+        test_timespec_add();
+        test_timespec_sub();
     }
 
     #[bench]