---

yaml
---
r: 275267
b: refs/heads/stable
c: 77c1e11
h: refs/heads/master
i:
  275265: 0546109
  275263: 6d672f6

Author: Amanieu

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 9c01031c728625c4eef078598d04b8376e4210e4
+refs/heads/stable: 77c1e11249703904adccdf7d5b52435a45e7f2db
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/RELEASES.md

@@ -75,8 +75,8 @@ Libraries
   improved by using `memchr` to search for newlines][1.7m].
 * [`f32::to_degrees` and `f32::to_radians` are stable][1.7f]. The
   `f64` variants were stabilized previously.
-* [`BTreeMap` was rewritten to use less memory improve performance of
-  insertion and iteration, the latter by as much as 5x`][1.7bm].
+* [`BTreeMap` was rewritten to use less memory and improve the performance
+  of insertion and iteration, the latter by as much as 5x`][1.7bm].
 * [`BTreeSet` and its iterators, `Iter`, `IntoIter`, and `Range` are
   covariant over their contained type][1.7bt].
 * [`LinkedList` and its iterators, `Iter` and `IntoIter` are covariant

branches/stable/src/doc/reference.md

@@ -3040,7 +3040,7 @@ the case of a `while` loop, the head is the conditional expression controlling
 the loop. In the case of a `for` loop, the head is the call-expression
 controlling the loop. If the label is present, then `continue 'foo` returns
 control to the head of the loop with label `'foo`, which need not be the
-innermost label enclosing the `continue` expression, but must enclose it.
+innermost label enclosing the `break` expression, but must enclose it.
 
 A `continue` expression is only permitted in the body of a loop.
 

branches/stable/src/libcore/num/flt2dec/mod.rs

@@ -210,7 +210,7 @@ impl<'a> Part<'a> {
                     }
                 }
                 Part::Copy(buf) => {
-                    out[..buf.len()].copy_from_slice(buf);
+                    out[..buf.len()].clone_from_slice(buf);
                 }
             }
             Some(len)
@@ -245,7 +245,7 @@ impl<'a> Formatted<'a> {
     /// (It may still leave partially written bytes in the buffer; do not rely on that.)
     pub fn write(&self, out: &mut [u8]) -> Option<usize> {
         if out.len() < self.sign.len() { return None; }
-        out[..self.sign.len()].copy_from_slice(self.sign);
+        out[..self.sign.len()].clone_from_slice(self.sign);
 
         let mut written = self.sign.len();
         for part in self.parts {

branches/stable/src/libcoretest/lib.rs

@@ -15,7 +15,6 @@
 #![feature(box_syntax)]
 #![feature(cell_extras)]
 #![feature(const_fn)]
-#![feature(copy_from_slice)]
 #![feature(core_float)]
 #![feature(core_private_bignum)]
 #![feature(core_private_diy_float)]

branches/stable/src/libcoretest/num/flt2dec/mod.rs

@@ -100,7 +100,7 @@ fn check_exact<F, T>(mut f: F, v: T, vstr: &str, expected: &[u8], expectedk: i16
 
     // check significant digits
     for i in 1..cut.unwrap_or(expected.len() - 1) {
-        expected_[..i].copy_from_slice(&expected[..i]);
+        expected_[..i].clone_from_slice(&expected[..i]);
         let mut expectedk_ = expectedk;
         if expected[i] >= b'5' {
             // check if this is a rounding-to-even case.
@@ -147,7 +147,7 @@ fn check_exact<F, T>(mut f: F, v: T, vstr: &str, expected: &[u8], expectedk: i16
     // check infinite zero digits
     if let Some(cut) = cut {
         for i in cut..expected.len()-1 {
-            expected_[..cut].copy_from_slice(&expected[..cut]);
+            expected_[..cut].clone_from_slice(&expected[..cut]);
             for c in &mut expected_[cut..i] { *c = b'0'; }
 
             try_exact!(f(&decoded) => &mut buf, &expected_[..i], expectedk;

branches/stable/src/librbml/lib.rs

@@ -122,7 +122,6 @@
        test(attr(deny(warnings))))]
 #![cfg_attr(not(stage0), deny(warnings))]
 
-#![feature(copy_from_slice)]
 #![feature(rustc_private)]
 #![feature(staged_api)]
 
@@ -520,7 +519,7 @@ pub mod reader {
             // of the page and segfault.
 
             let mut b = [0; 8];
-            b.copy_from_slice(&d.data[d.end - 8..d.end]);
+            b.clone_from_slice(&d.data[d.end - 8..d.end]);
             let data = unsafe { (*(b.as_ptr() as *const u64)).to_be() };
             let len = d.end - d.start;
             if len < 8 {
@@ -1044,7 +1043,7 @@ pub mod writer {
                 {
                     let last_size_pos = last_size_pos as usize;
                     let data = &self.writer.get_ref()[last_size_pos + 4..cur_pos as usize];
-                    buf[..size].copy_from_slice(data);
+                    buf[..size].clone_from_slice(data);
                 }
 
                 // overwrite the size and data and continue

branches/stable/src/librustc/lib.rs

@@ -29,7 +29,6 @@
 #![feature(cell_extras)]
 #![feature(collections)]
 #![feature(const_fn)]
-#![feature(copy_from_slice)]
 #![feature(enumset)]
 #![feature(iter_arith)]
 #![feature(libc)]

branches/stable/src/librustc/middle/dataflow.rs

@@ -489,7 +489,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
                 let bits = &mut self.scope_kills[start.. end];
                 debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [before]",
                        self.analysis_name, flow_exit, mut_bits_to_string(bits));
-                bits.copy_from_slice(&orig_kills[..]);
+                bits.clone_from_slice(&orig_kills[..]);
                 debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [after]",
                        self.analysis_name, flow_exit, mut_bits_to_string(bits));
             }
@@ -556,7 +556,7 @@ impl<'a, 'b, 'tcx, O:DataFlowOperator> PropagationContext<'a, 'b, 'tcx, O> {
             let (start, end) = self.dfcx.compute_id_range(node_index);
 
             // Initialize local bitvector with state on-entry.
-            in_out.copy_from_slice(&self.dfcx.on_entry[start.. end]);
+            in_out.clone_from_slice(&self.dfcx.on_entry[start.. end]);
 
             // Compute state on-exit by applying transfer function to
             // state on-entry.

branches/stable/src/librustc_back/lib.rs

@@ -31,7 +31,6 @@
 #![cfg_attr(not(stage0), deny(warnings))]
 
 #![feature(box_syntax)]
-#![feature(copy_from_slice)]
 #![feature(libc)]
 #![feature(rand)]
 #![feature(rustc_private)]

branches/stable/src/librustc_back/sha2.rs

@@ -134,13 +134,13 @@ impl FixedBuffer for FixedBuffer64 {
             let buffer_remaining = size - self.buffer_idx;
             if input.len() >= buffer_remaining {
                 self.buffer[self.buffer_idx..size]
-                    .copy_from_slice(&input[..buffer_remaining]);
+                    .clone_from_slice(&input[..buffer_remaining]);
                 self.buffer_idx = 0;
                 func(&self.buffer);
                 i += buffer_remaining;
             } else {
                 self.buffer[self.buffer_idx..self.buffer_idx + input.len()]
-                    .copy_from_slice(input);
+                    .clone_from_slice(input);
                 self.buffer_idx += input.len();
                 return;
             }
@@ -157,7 +157,7 @@ impl FixedBuffer for FixedBuffer64 {
         // data left in the input vector will be less than the buffer size and the buffer will
         // be empty.
         let input_remaining = input.len() - i;
-        self.buffer[..input_remaining].copy_from_slice(&input[i..]);
+        self.buffer[..input_remaining].clone_from_slice(&input[i..]);
         self.buffer_idx += input_remaining;
     }
 

branches/stable/src/librustdoc/clean/inline.rs

@@ -260,11 +260,6 @@ pub fn build_impls(cx: &DocContext, tcx: &ty::ctxt,
             match def {
                 cstore::DlImpl(did) => build_impl(cx, tcx, did, impls),
                 cstore::DlDef(Def::Mod(did)) => {
-                    // Don't recurse if this is a #[doc(hidden)] module
-                    if load_attrs(cx, tcx, did).iter().any(|a| is_doc_hidden(a)) {
-                        return;
-                    }
-
                     for item in tcx.sess.cstore.item_children(did) {
                         populate_impls(cx, tcx, item.def, impls)
                     }
@@ -428,19 +423,19 @@ pub fn build_impl(cx: &DocContext,
         deprecation: stability::lookup_deprecation(tcx, did).clean(cx),
         def_id: did,
     });
-}
 
-fn is_doc_hidden(a: &clean::Attribute) -> bool {
-    match *a {
-        clean::List(ref name, ref inner) if *name == "doc" => {
-            inner.iter().any(|a| {
-                match *a {
-                    clean::Word(ref s) => *s == "hidden",
-                    _ => false,
-                }
-            })
+    fn is_doc_hidden(a: &clean::Attribute) -> bool {
+        match *a {
+            clean::List(ref name, ref inner) if *name == "doc" => {
+                inner.iter().any(|a| {
+                    match *a {
+                        clean::Word(ref s) => *s == "hidden",
+                        _ => false,
+                    }
+                })
+            }
+            _ => false
         }
-        _ => false
     }
 }
 

branches/stable/src/libstd/io/cursor.rs

@@ -256,7 +256,7 @@ impl Write for Cursor<Vec<u8>> {
             let pos = pos as usize;
             let space = self.inner.len() - pos;
             let (left, right) = buf.split_at(cmp::min(space, buf.len()));
-            self.inner[pos..pos + left.len()].copy_from_slice(left);
+            self.inner[pos..pos + left.len()].clone_from_slice(left);
             self.inner.extend_from_slice(right);
         }
 

branches/stable/src/libstd/io/impls.rs

@@ -156,7 +156,7 @@ impl<'a> Read for &'a [u8] {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let amt = cmp::min(buf.len(), self.len());
         let (a, b) = self.split_at(amt);
-        buf[..amt].copy_from_slice(a);
+        buf[..amt].clone_from_slice(a);
         *self = b;
         Ok(amt)
     }
@@ -168,7 +168,7 @@ impl<'a> Read for &'a [u8] {
                                   "failed to fill whole buffer"));
         }
         let (a, b) = self.split_at(buf.len());
-        buf.copy_from_slice(a);
+        buf.clone_from_slice(a);
         *self = b;
         Ok(())
     }
@@ -189,7 +189,7 @@ impl<'a> Write for &'a mut [u8] {
     fn write(&mut self, data: &[u8]) -> io::Result<usize> {
         let amt = cmp::min(data.len(), self.len());
         let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
-        a.copy_from_slice(&data[..amt]);
+        a.clone_from_slice(&data[..amt]);
         *self = b;
         Ok(amt)
     }

branches/stable/src/libstd/lib.rs

@@ -222,7 +222,6 @@
 #![feature(collections)]
 #![feature(collections_bound)]
 #![feature(const_fn)]
-#![feature(copy_from_slice)]
 #![feature(core_float)]
 #![feature(core_intrinsics)]
 #![feature(decode_utf16)]

branches/stable/src/libstd/net/parser.rs

@@ -191,8 +191,8 @@ impl<'a> Parser<'a> {
         fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> Ipv6Addr {
             assert!(head.len() + tail.len() <= 8);
             let mut gs = [0; 8];
-            gs[..head.len()].copy_from_slice(head);
-            gs[(8 - tail.len()) .. 8].copy_from_slice(tail);
+            gs[..head.len()].clone_from_slice(head);
+            gs[(8 - tail.len()) .. 8].clone_from_slice(tail);
             Ipv6Addr::new(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
         }
 

branches/stable/src/libstd/primitive_docs.rs

@@ -488,9 +488,6 @@ mod prim_tuple { }
 ///
 /// *[See also the `std::f32` module](f32/index.html).*
 ///
-/// However, please note that examples are shared between the `f64` and `f32`
-/// primitive types. So it's normal if you see usage of `f64` in there.
-///
 mod prim_f32 { }
 
 #[doc(primitive = "f64")]
@@ -499,9 +496,6 @@ mod prim_f32 { }
 ///
 /// *[See also the `std::f64` module](f64/index.html).*
 ///
-/// However, please note that examples are shared between the `f64` and `f32`
-/// primitive types. So it's normal if you see usage of `f32` in there.
-///
 mod prim_f64 { }
 
 #[doc(primitive = "i8")]

branches/stable/src/libstd/sys/common/wtf8.rs

@@ -341,7 +341,7 @@ impl Wtf8Buf {
                 Some((surrogate_pos, _)) => {
                     pos = surrogate_pos + 3;
                     self.bytes[surrogate_pos..pos]
-                        .copy_from_slice(UTF8_REPLACEMENT_CHARACTER);
+                        .clone_from_slice(UTF8_REPLACEMENT_CHARACTER);
                 },
                 None => return unsafe { String::from_utf8_unchecked(self.bytes) }
             }

branches/stable/src/libstd/sys/windows/rand.rs

@@ -48,17 +48,13 @@ impl Rng for OsRng {
         unsafe { mem::transmute(v) }
     }
     fn fill_bytes(&mut self, v: &mut [u8]) {
-        // CryptGenRandom takes a DWORD (u32) for the length so we need to
-        // split up the buffer.
-        for slice in v.chunks_mut(<c::DWORD>::max_value() as usize) {
-            let ret = unsafe {
-                c::CryptGenRandom(self.hcryptprov, slice.len() as c::DWORD,
-                                  slice.as_mut_ptr())
-            };
-            if ret == 0 {
-                panic!("couldn't generate random bytes: {}",
-                       io::Error::last_os_error());
-            }
+        let ret = unsafe {
+            c::CryptGenRandom(self.hcryptprov, v.len() as c::DWORD,
+                              v.as_mut_ptr())
+        };
+        if ret == 0 {
+            panic!("couldn't generate random bytes: {}",
+                   io::Error::last_os_error());
         }
     }
 }