---

yaml
---
r: 235486
b: refs/heads/stable
c: cfa8e48
h: refs/heads/master
v: v3

Author: vincentbernat

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 69e6dc0444bb62a474c8c5f7490c660f9d88c172
+refs/heads/stable: cfa8e48b21fad7748659b6a4d74754fab9020891
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/.travis.yml

@@ -1,38 +1,20 @@
-# ccache support is disabled unless your language is a C-derivative. However
-# `language: C` unconditionally sets `CC=compiler`. If we just set it in our
-# `env` it will be overwritten by the default (gcc 4.6).
+# Use something that's not 'ruby' so we don't set up things like
+# RVM/bundler/ruby and whatnot. Right now 'rust' as a language actually
+# downloads a rust/cargo snapshot, which we don't really want for building rust.
 language: c
-compiler: /usr/bin/gcc-4.7
-cache: ccache
 sudo: false
 
 # The test suite is in general way too stressful for travis, especially in
 # terms of time limit and reliability. In the past we've tried to scale things
 # back to only build the stage1 compiler and run a subset of tests, but this
 # didn't end up panning out very well.
 #
-# As a result, we're just using travis to run `make tidy` and *only* build
-# stage1 but *not* test it for now (a strict subset of the bootstrap). This will
-# catch "obvious" errors like style or not even compiling.
-#
-# We need gcc4.7 or higher to build LLVM, and travis (well, Ubuntu 12.04)
-# currently ships with 4.6. Gotta download our own.
+# As a result, we're just using travis to run `make tidy` now. It'll help
+# everyone find out about their trailing spaces early on!
 before_script:
-  - ./configure --enable-ccache
+  - ./configure --llvm-root=path/to/nowhere
 script:
   - make tidy
-  - make rustc-stage1 -j4
-
-env:
-  - CXX=/usr/bin/g++-4.7
-
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - gcc-4.7
-    - g++-4.7
 
 # Real testing happens on http://buildbot.rust-lang.org/
 #

branches/stable/CONTRIBUTING.md

@@ -133,8 +133,8 @@ Documentation improvements are very welcome. The source of `doc.rust-lang.org`
 is located in `src/doc` in the tree, and standard API documentation is generated
 from the source code itself.
 
-Documentation pull requests function in the same way as other pull requests,
-though you may see a slightly different form of `r+`:
+Documentation pull requests function in the same as other pull requests, though
+you may see a slightly different form of `r+`:
 
     @bors: r+ 38fe8d2 rollup
 

branches/stable/RELEASES.md

@@ -28,9 +28,6 @@ Breaking Changes
   in, and the same value reported by clang's
   `alignof`. [`mem::min_align_of`] is deprecated. This is not known to
   break real code.
-* [The `#[packed]` attribute is no longer silently accepted by the
-  compiler][packed]. This attribute did nothing and code that
-  mentioned it likely did not work as intended.
 
 Language
 --------
@@ -143,7 +140,7 @@ Misc
 [fat]: https://github.com/rust-lang/rust/pull/26411
 [dst]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
 [parcodegen]: https://github.com/rust-lang/rust/pull/26018
-[packed]: https://github.com/rust-lang/rust/pull/25541
+
 
 Version 1.1.0 (June 2015)
 =========================

branches/stable/configure

@@ -1031,12 +1031,15 @@ fi
 
 if [ ! -z "$CFG_ENABLE_CCACHE" ]
 then
-    if [ -z "$CFG_CCACHE" ]
+    if [ -z "$CC" ]
     then
-        err "ccache requested but not found"
-    fi
+        if [ -z "$CFG_CCACHE" ]
+        then
+            err "ccache requested but not found"
+        fi
 
-    CFG_CC="ccache $CFG_CC"
+        CFG_CC="ccache $CFG_CC"
+    fi
 fi
 
 if [ -z "$CC" -a -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
@@ -1525,26 +1528,11 @@ do
 
             (*)
             msg "inferring LLVM_CXX/CC from CXX/CC = $CXX/$CC"
-            if [ ! -z "$CFG_ENABLE_CCACHE" ]
-            then
-                if [ -z "$CFG_CCACHE" ]
-                then
-                    err "ccache requested but not found"
-                fi
-
-                LLVM_CXX_32="ccache $CXX"
-                LLVM_CC_32="ccache $CC"
-
-                LLVM_CXX_64="ccache $CXX"
-                LLVM_CC_64="ccache $CC"
-            else
-                LLVM_CXX_32="$CXX"
-                LLVM_CC_32="$CC"
-
-                LLVM_CXX_64="$CXX"
-                LLVM_CC_64="$CC"
-            fi
+            LLVM_CXX_32="$CXX"
+            LLVM_CC_32="$CC"
 
+            LLVM_CXX_64="$CXX"
+            LLVM_CC_64="$CC"
             ;;
         esac
 

branches/stable/src/doc/trpl/error-handling.md

@@ -50,8 +50,6 @@ is very wrong. Wrong enough that we can't continue with things in the current
 state. Another example is using the `unreachable!()` macro:
 
 ```rust,ignore
-use Event::NewRelease;
-
 enum Event {
     NewRelease,
 }
@@ -73,7 +71,7 @@ fn descriptive_probability(event: Event) -> &'static str {
 }
 
 fn main() {
-    println!("{}", descriptive_probability(NewRelease));
+    std::io::println(descriptive_probability(NewRelease));
 }
 ```
 

branches/stable/src/doc/trpl/the-stack-and-the-heap.md

@@ -176,7 +176,7 @@ After `bar()` is over, its frame is deallocated, leaving just `foo()` and
 | 1       | a    | 5     |
 | 0       | x    | 42    |
 
-And then `foo()` ends, leaving just `main()`:
+And then `foo()` ends, leaving just `main()`
 
 | Address | Name | Value |
 |---------|------|-------|
@@ -537,7 +537,7 @@ Generally, you should prefer stack allocation, and so, Rust stack-allocates by
 default. The LIFO model of the stack is simpler, at a fundamental level. This
 has two big impacts: runtime efficiency and semantic impact.
 
-## Runtime Efficiency
+## Runtime Efficiency.
 
 Managing the memory for the stack is trivial: The machine just
 increments or decrements a single value, the so-called “stack pointer”.

branches/stable/src/libcore/hash/sip.rs

@@ -10,6 +10,8 @@
 
 //! An implementation of SipHash 2-4.
 
+#![allow(deprecated)] // until the next snapshot for inherent wrapping ops
+
 use prelude::*;
 use super::Hasher;
 

branches/stable/src/libcoretest/hash/mod.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-mod sip;
-
 use std::mem;
 use std::hash::{Hash, Hasher};
 use std::default::Default;

branches/stable/src/libcoretest/hash/sip.rs

@@ -8,55 +8,28 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 use test::Bencher;
+use std::prelude::*;
+use std::fmt;
 
-use core::hash::{Hash, Hasher};
-use core::hash::SipHasher;
+use str::Str;
+use string::String;
+use slice::{AsSlice, SlicePrelude};
+use vec::Vec;
+
+use core::hash::{Hash, Writer};
+use core::hash::sip::{SipState, hash, hash_with_keys};
 
 // Hash just the bytes of the slice, without length prefix
 struct Bytes<'a>(&'a [u8]);
 
-impl<'a> Hash for Bytes<'a> {
+impl<'a, S: Writer> Hash<S> for Bytes<'a> {
     #[allow(unused_must_use)]
-    fn hash<H: Hasher>(&self, state: &mut H) {
+    fn hash(&self, state: &mut S) {
         let Bytes(v) = *self;
         state.write(v);
     }
 }
 
-macro_rules! u8to64_le {
-    ($buf:expr, $i:expr) =>
-    ($buf[0+$i] as u64 |
-     ($buf[1+$i] as u64) << 8 |
-     ($buf[2+$i] as u64) << 16 |
-     ($buf[3+$i] as u64) << 24 |
-     ($buf[4+$i] as u64) << 32 |
-     ($buf[5+$i] as u64) << 40 |
-     ($buf[6+$i] as u64) << 48 |
-     ($buf[7+$i] as u64) << 56);
-    ($buf:expr, $i:expr, $len:expr) =>
-    ({
-        let mut t = 0;
-        let mut out = 0;
-        while t < $len {
-            out |= ($buf[t+$i] as u64) << t*8;
-            t += 1;
-        }
-        out
-    });
-}
-
-fn hash<T: Hash>(x: &T) -> u64 {
-    let mut st = SipHasher::new();
-    x.hash(&mut st);
-    st.finish()
-}
-
-fn hash_with_keys<T: Hash>(k1: u64, k2: u64, x: &T) -> u64 {
-    let mut st = SipHasher::new_with_keys(k1, k2);
-    x.hash(&mut st);
-    st.finish()
-}
-
 #[test]
 #[allow(unused_must_use)]
 fn test_siphash() {
@@ -131,43 +104,79 @@ fn test_siphash() {
     let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
     let mut buf = Vec::new();
     let mut t = 0;
-    let mut state_inc = SipHasher::new_with_keys(k0, k1);
+    let mut state_inc = SipState::new_with_keys(k0, k1);
+    let mut state_full = SipState::new_with_keys(k0, k1);
+
+    fn to_hex_str(r: &[u8; 8]) -> String {
+        let mut s = String::new();
+        for b in r {
+            s.push_str(format!("{}", fmt::radix(*b, 16)));
+        }
+        s
+    }
+
+    fn result_bytes(h: u64) -> Vec<u8> {
+        vec![(h >> 0) as u8,
+          (h >> 8) as u8,
+          (h >> 16) as u8,
+          (h >> 24) as u8,
+          (h >> 32) as u8,
+          (h >> 40) as u8,
+          (h >> 48) as u8,
+          (h >> 56) as u8,
+        ]
+    }
+
+    fn result_str(h: u64) -> String {
+        let r = result_bytes(h);
+        let mut s = String::new();
+        for b in &r {
+            s.push_str(format!("{}", fmt::radix(*b, 16)));
+        }
+        s
+    }
 
     while t < 64 {
+        debug!("siphash test {}: {}", t, buf);
         let vec = u8to64_le!(vecs[t], 0);
-        let out = hash_with_keys(k0, k1, &Bytes(&buf));
+        let out = hash_with_keys(k0, k1, &Bytes(buf));
+        debug!("got {}, expected {}", out, vec);
         assert_eq!(vec, out);
 
-        let full = hash_with_keys(k0, k1, &Bytes(&buf));
-        let i = state_inc.finish();
+        state_full.reset();
+        state_full.write(buf);
+        let f = result_str(state_full.result());
+        let i = result_str(state_inc.result());
+        let v = to_hex_str(&vecs[t]);
+        debug!("{}: ({}) => inc={} full={}", t, v, i, f);
 
-        assert_eq!(full, i);
-        assert_eq!(full, vec);
+        assert_eq!(f, i);
+        assert_eq!(f, v);
 
         buf.push(t as u8);
-        Hasher::write(&mut state_inc, &[t as u8]);
+        state_inc.write(&[t as u8]);
 
         t += 1;
     }
 }
 
 #[test] #[cfg(target_arch = "arm")]
-fn test_hash_usize() {
+fn test_hash_uint() {
     let val = 0xdeadbeef_deadbeef_u64;
-    assert!(hash(&(val as u64)) != hash(&(val as usize)));
-    assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
+    assert!(hash(&(val as u64)) != hash(&(val as uint)));
+    assert_eq!(hash(&(val as u32)), hash(&(val as uint)));
 }
 #[test] #[cfg(target_arch = "x86_64")]
-fn test_hash_usize() {
+fn test_hash_uint() {
     let val = 0xdeadbeef_deadbeef_u64;
-    assert_eq!(hash(&(val as u64)), hash(&(val as usize)));
-    assert!(hash(&(val as u32)) != hash(&(val as usize)));
+    assert_eq!(hash(&(val as u64)), hash(&(val as uint)));
+    assert!(hash(&(val as u32)) != hash(&(val as uint)));
 }
 #[test] #[cfg(target_arch = "x86")]
-fn test_hash_usize() {
+fn test_hash_uint() {
     let val = 0xdeadbeef_deadbeef_u64;
-    assert!(hash(&(val as u64)) != hash(&(val as usize)));
-    assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
+    assert!(hash(&(val as u64)) != hash(&(val as uint)));
+    assert_eq!(hash(&(val as u32)), hash(&(val as uint)));
 }
 
 #[test]
@@ -191,7 +200,7 @@ fn test_hash_no_bytes_dropped_64() {
     assert!(hash(&val) != hash(&zero_byte(val, 6)));
     assert!(hash(&val) != hash(&zero_byte(val, 7)));
 
-    fn zero_byte(val: u64, byte: usize) -> u64 {
+    fn zero_byte(val: u64, byte: uint) -> u64 {
         assert!(byte < 8);
         val & !(0xff << (byte * 8))
     }
@@ -206,7 +215,7 @@ fn test_hash_no_bytes_dropped_32() {
     assert!(hash(&val) != hash(&zero_byte(val, 2)));
     assert!(hash(&val) != hash(&zero_byte(val, 3)));
 
-    fn zero_byte(val: u32, byte: usize) -> u32 {
+    fn zero_byte(val: u32, byte: uint) -> u32 {
         assert!(byte < 4);
         val & !(0xff << (byte * 8))
     }
@@ -221,9 +230,8 @@ fn test_hash_no_concat_alias() {
     assert!(s != t && t != u);
     assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
 
-    let u = [1, 0, 0, 0];
-    let v = (&u[..1], &u[1..3], &u[3..]);
-    let w = (&u[..], &u[4..4], &u[4..4]);
+    let v: (&[u8], &[u8], &[u8]) = (&[1], &[0, 0], &[0]);
+    let w: (&[u8], &[u8], &[u8]) = (&[1, 0, 0, 0], &[], &[]);
 
     assert!(v != w);
     assert!(hash(&v) != hash(&w));

branches/stable/src/librustc/ast_map/mod.rs

@@ -411,13 +411,6 @@ impl<'ast> Map<'ast> {
         }
     }
 
-    pub fn expect_trait_item(&self, id: NodeId) -> &'ast TraitItem {
-        match self.find(id) {
-            Some(NodeTraitItem(item)) => item,
-            _ => panic!("expected trait item, found {}", self.node_to_string(id))
-        }
-    }
-
     pub fn expect_struct(&self, id: NodeId) -> &'ast StructDef {
         match self.find(id) {
             Some(NodeItem(i)) => {