---

yaml
---
r: 218347
b: refs/heads/tmp
c: 74f4298
h: refs/heads/master
i:
  218345: dedd6c2
  218343: 56d79f4
v: v3

Author: jespino

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: ebf0c83cb9c6508e9564cb58337df2ad52b56430
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 92a95fe5507a41bdfb055913bec1be24509a5146
+refs/heads/tmp: 74f42980e19dd74a55d95cc0cd6428477797b6cf
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: d0fdfbfb0d34f196f52b9d15215723c4785c4afa
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/src/libcollections/bit.rs

@@ -283,7 +283,7 @@ impl BitVec {
     pub fn from_elem(nbits: usize, bit: bool) -> BitVec {
         let nblocks = blocks_for_bits(nbits);
         let mut bit_vec = BitVec {
-            storage: vec![if bit { !0 } else { 0 }; nblocks],
+            storage: repeat(if bit { !0 } else { 0 }).take(nblocks).collect(),
             nbits: nbits
         };
         bit_vec.fix_last_block();

branches/tmp/src/libcollectionstest/slice.rs

@@ -1318,7 +1318,7 @@ mod bench {
 
     #[bench]
     fn mut_iterator(b: &mut Bencher) {
-        let mut v = vec![0; 100];
+        let mut v: Vec<_> = repeat(0).take(100).collect();
 
         b.iter(|| {
             let mut i = 0;
@@ -1419,7 +1419,7 @@ mod bench {
     #[bench]
     fn zero_1kb_from_elem(b: &mut Bencher) {
         b.iter(|| {
-            vec![0u8; 1024]
+            repeat(0u8).take(1024).collect::<Vec<_>>()
         });
     }
 
@@ -1467,7 +1467,7 @@ mod bench {
     fn random_inserts(b: &mut Bencher) {
         let mut rng = thread_rng();
         b.iter(|| {
-            let mut v = vec![(0, 0); 30];
+            let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
             for _ in 0..100 {
                 let l = v.len();
                 v.insert(rng.gen::<usize>() % (l + 1),
@@ -1479,7 +1479,7 @@ mod bench {
     fn random_removes(b: &mut Bencher) {
         let mut rng = thread_rng();
         b.iter(|| {
-            let mut v = vec![(0, 0); 130];
+            let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
             for _ in 0..100 {
                 let l = v.len();
                 v.remove(rng.gen::<usize>() % l);

branches/tmp/src/libcore/intrinsics.rs

@@ -586,18 +586,18 @@ extern "rust-intrinsic" {
     pub fn overflowing_mul<T>(a: T, b: T) -> T;
 
     /// Performs an unchecked signed division, which results in undefined behavior,
-    /// in cases where y == 0, or x == isize::MIN and y == -1
+    /// in cases where y == 0, or x == int::MIN and y == -1
     pub fn unchecked_sdiv<T>(x: T, y: T) -> T;
     /// Performs an unchecked unsigned division, which results in undefined behavior,
     /// in cases where y == 0
     pub fn unchecked_udiv<T>(x: T, y: T) -> T;
 
     /// Returns the remainder of an unchecked signed division, which results in
-    /// undefined behavior, in cases where y == 0, or x == isize::MIN and y == -1
-    pub fn unchecked_srem<T>(x: T, y: T) -> T;
-    /// Returns the remainder of an unchecked unsigned division, which results in
-    /// undefined behavior, in cases where y == 0
+    /// undefined behavior, in cases where y == 0, or x == int::MIN and y == -1
     pub fn unchecked_urem<T>(x: T, y: T) -> T;
+    /// Returns the remainder of an unchecked signed division, which results in
+    /// undefined behavior, in cases where y == 0
+    pub fn unchecked_srem<T>(x: T, y: T) -> T;
 
     /// Returns the value of the discriminant for the variant in 'v',
     /// cast to a `u64`; if `T` has no discriminant, returns 0.

branches/tmp/src/libcore/num/wrapping.rs

@@ -119,16 +119,6 @@ macro_rules! wrapping_impl {
             }
         }
 
-        #[stable(feature = "wrapping_div", since = "1.3.0")]
-        impl Div for Wrapping<$t> {
-            type Output = Wrapping<$t>;
-
-            #[inline(always)]
-            fn div(self, other: Wrapping<$t>) -> Wrapping<$t> {
-                Wrapping(self.0.wrapping_div(other.0))
-            }
-        }
-
         #[stable(feature = "rust1", since = "1.0.0")]
         impl Not for Wrapping<$t> {
             type Output = Wrapping<$t>;

branches/tmp/src/libcore/slice.rs

@@ -1463,30 +1463,12 @@ pub mod bytes {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A, B> PartialEq<[B]> for [A] where A: PartialEq<B> {
     fn eq(&self, other: &[B]) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-
-        for i in 0..self.len() {
-            if !self[i].eq(&other[i]) {
-                return false;
-            }
-        }
-
-        true
+        self.len() == other.len() &&
+            order::eq(self.iter(), other.iter())
     }
     fn ne(&self, other: &[B]) -> bool {
-        if self.len() != other.len() {
-            return true;
-        }
-
-        for i in 0..self.len() {
-            if self[i].ne(&other[i]) {
-                return true;
-            }
-        }
-
-        false
+        self.len() != other.len() ||
+            order::ne(self.iter(), other.iter())
     }
 }
 

branches/tmp/src/libcoretest/ptr.rs

@@ -10,6 +10,7 @@
 
 use core::ptr::*;
 use core::mem;
+use std::iter::repeat;
 
 #[test]
 fn test() {
@@ -109,7 +110,7 @@ fn test_as_mut() {
 #[test]
 fn test_ptr_addition() {
     unsafe {
-        let xs = vec![5; 16];
+        let xs = repeat(5).take(16).collect::<Vec<_>>();
         let mut ptr = xs.as_ptr();
         let end = ptr.offset(16);
 
@@ -127,7 +128,7 @@ fn test_ptr_addition() {
             m_ptr = m_ptr.offset(1);
         }
 
-        assert!(xs_mut == vec![10; 16]);
+        assert!(xs_mut == repeat(10).take(16).collect::<Vec<_>>());
     }
 }
 

branches/tmp/src/libgraphviz/lib.rs

@@ -599,6 +599,7 @@ mod tests {
     use std::io;
     use std::io::prelude::*;
     use std::borrow::IntoCow;
+    use std::iter::repeat;
 
     /// each node is an index in a vector in the graph.
     type Node = usize;
@@ -646,7 +647,7 @@ mod tests {
         fn to_opt_strs(self) -> Vec<Option<&'static str>> {
             match self {
                 UnlabelledNodes(len)
-                    => vec![None; len],
+                    => repeat(None).take(len).collect(),
                 AllNodesLabelled(lbls)
                     => lbls.into_iter().map(
                         |l|Some(l)).collect(),

branches/tmp/src/liblibc/lib.rs

@@ -2522,6 +2522,7 @@ pub mod consts {
             pub const S_IFDIR : c_int = 16384;
             pub const S_IFREG : c_int = 32768;
             pub const S_IFLNK : c_int = 40960;
+            pub const S_IFSOCK : mode_t = 49152;
             pub const S_IFMT : c_int = 61440;
             pub const S_IEXEC : c_int = 64;
             pub const S_IWRITE : c_int = 128;
@@ -2881,6 +2882,7 @@ pub mod consts {
             pub const S_IFDIR : mode_t = 16384;
             pub const S_IFREG : mode_t = 32768;
             pub const S_IFLNK : mode_t = 40960;
+            pub const S_IFSOCK : mode_t = 49152;
             pub const S_IFMT : mode_t = 61440;
             pub const S_IEXEC : mode_t = 64;
             pub const S_IWRITE : mode_t = 128;
@@ -3103,6 +3105,7 @@ pub mod consts {
             pub const S_IFDIR : mode_t = 16384;
             pub const S_IFREG : mode_t = 32768;
             pub const S_IFLNK : mode_t = 40960;
+            pub const S_IFSOCK : mode_t = 49152;
             pub const S_IFMT : mode_t = 61440;
             pub const S_IEXEC : mode_t = 64;
             pub const S_IWRITE : mode_t = 128;
@@ -3905,6 +3908,7 @@ pub mod consts {
             pub const S_IFDIR : mode_t = 16384;
             pub const S_IFREG : mode_t = 32768;
             pub const S_IFLNK : mode_t = 40960;
+            pub const S_IFSOCK : mode_t = 49152;
             pub const S_IFMT : mode_t = 61440;
             pub const S_IEXEC : mode_t = 64;
             pub const S_IWRITE : mode_t = 128;
@@ -4365,6 +4369,7 @@ pub mod consts {
             pub const S_IFDIR : mode_t = 16384;
             pub const S_IFREG : mode_t = 32768;
             pub const S_IFLNK : mode_t = 40960;
+            pub const S_IFSOCK : mode_t = 49152;
             pub const S_IFMT : mode_t = 61440;
             pub const S_IEXEC : mode_t = 64;
             pub const S_IWRITE : mode_t = 128;
@@ -4791,6 +4796,7 @@ pub mod consts {
             pub const S_IFDIR : mode_t = 16384;
             pub const S_IFREG : mode_t = 32768;
             pub const S_IFLNK : mode_t = 40960;
+            pub const S_IFSOCK : mode_t = 49152;
             pub const S_IFMT : mode_t = 61440;
             pub const S_IEXEC : mode_t = 64;
             pub const S_IWRITE : mode_t = 128;

branches/tmp/src/librand/reseeding.rs

@@ -186,7 +186,7 @@ mod tests {
     const FILL_BYTES_V_LEN: usize = 13579;
     #[test]
     fn test_rng_fill_bytes() {
-        let mut v = vec![0; FILL_BYTES_V_LEN];
+        let mut v = repeat(0).take(FILL_BYTES_V_LEN).collect::<Vec<_>>();
         ::test::rng().fill_bytes(&mut v);
 
         // Sanity test: if we've gotten here, `fill_bytes` has not infinitely

branches/tmp/src/librustc/middle/check_match.rs

@@ -704,7 +704,7 @@ fn is_useful(cx: &MatchCheckCtxt,
                 match is_useful(cx, &matrix, v.tail(), witness) {
                     UsefulWithWitness(pats) => {
                         let arity = constructor_arity(cx, &constructor, left_ty);
-                        let wild_pats = vec![DUMMY_WILD_PAT; arity];
+                        let wild_pats: Vec<_> = repeat(DUMMY_WILD_PAT).take(arity).collect();
                         let enum_pat = construct_witness(cx, &constructor, wild_pats, left_ty);
                         let mut new_pats = vec![enum_pat];
                         new_pats.extend(pats);
@@ -862,7 +862,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
     } = raw_pat(r[col]);
     let head: Option<Vec<&Pat>> = match *node {
         ast::PatWild(_) =>
-            Some(vec![DUMMY_WILD_PAT; arity]),
+            Some(repeat(DUMMY_WILD_PAT).take(arity).collect()),
 
         ast::PatIdent(_, _, _) => {
             let opt_def = cx.tcx.def_map.borrow().get(&pat_id).map(|d| d.full_def());
@@ -875,7 +875,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
                 } else {
                     None
                 },
-                _ => Some(vec![DUMMY_WILD_PAT; arity])
+                _ => Some(repeat(DUMMY_WILD_PAT).take(arity).collect())
             }
         }
 
@@ -889,7 +889,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
                 DefVariant(..) | DefStruct(..) => {
                     Some(match args {
                         &Some(ref args) => args.iter().map(|p| &**p).collect(),
-                        &None => vec![DUMMY_WILD_PAT; arity],
+                        &None => repeat(DUMMY_WILD_PAT).take(arity).collect(),
                     })
                 }
                 _ => None

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

@@ -21,6 +21,7 @@ use middle::cfg::CFGIndex;
 use middle::ty;
 use std::io;
 use std::usize;
+use std::iter::repeat;
 use syntax::ast;
 use syntax::ast_util::IdRange;
 use syntax::visit;
@@ -238,11 +239,11 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
 
         let entry = if oper.initial_value() { usize::MAX } else {0};
 
-        let zeroes = vec![0; num_nodes * words_per_id];
-        let gens = zeroes.clone();
-        let kills1 = zeroes.clone();
-        let kills2 = zeroes;
-        let on_entry = vec![entry; num_nodes * words_per_id];
+        let zeroes: Vec<_> = repeat(0).take(num_nodes * words_per_id).collect();
+        let gens: Vec<_> = zeroes.clone();
+        let kills1: Vec<_> = zeroes.clone();
+        let kills2: Vec<_> = zeroes;
+        let on_entry: Vec<_> = repeat(entry).take(num_nodes * words_per_id).collect();
 
         let nodeid_to_index = build_nodeid_to_index(decl, cfg);
 
@@ -510,7 +511,7 @@ impl<'a, 'tcx, O:DataFlowOperator+Clone+'static> DataFlowContext<'a, 'tcx, O> {
                 changed: true
             };
 
-            let mut temp = vec![0; words_per_id];
+            let mut temp: Vec<_> = repeat(0).take(words_per_id).collect();
             while propcx.changed {
                 propcx.changed = false;
                 propcx.reset(&mut temp);

branches/tmp/src/librustc/middle/infer/region_inference/mod.rs

@@ -34,6 +34,7 @@ use util::nodemap::{FnvHashMap, FnvHashSet};
 use std::cell::{Cell, RefCell};
 use std::cmp::Ordering::{self, Less, Greater, Equal};
 use std::fmt;
+use std::iter::repeat;
 use std::u32;
 use syntax::ast;
 
@@ -1303,7 +1304,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
         // idea is to report errors that derive from independent
         // regions of the graph, but not those that derive from
         // overlapping locations.
-        let mut dup_vec = vec![u32::MAX; self.num_vars() as usize];
+        let mut dup_vec: Vec<_> = repeat(u32::MAX).take(self.num_vars() as usize).collect();
 
         for idx in 0..self.num_vars() as usize {
             match var_data[idx].value {

branches/tmp/src/librustc/middle/liveness.rs

@@ -119,6 +119,7 @@ use util::nodemap::NodeMap;
 use std::{fmt, usize};
 use std::io::prelude::*;
 use std::io;
+use std::iter::repeat;
 use std::rc::Rc;
 use syntax::ast::{self, NodeId, Expr};
 use syntax::codemap::{BytePos, original_sp, Span};
@@ -565,8 +566,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
         Liveness {
             ir: ir,
             s: specials,
-            successors: vec![invalid_node(); num_live_nodes],
-            users: vec![invalid_users(); num_live_nodes * num_vars],
+            successors: repeat(invalid_node()).take(num_live_nodes).collect(),
+            users: repeat(invalid_users()).take(num_live_nodes * num_vars).collect(),
             loop_scope: Vec::new(),
             break_ln: NodeMap(),
             cont_ln: NodeMap(),

branches/tmp/src/librustc_back/sha2.rs

@@ -12,6 +12,7 @@
 //! use. This implementation is not intended for external use or for any use where security is
 //! important.
 
+use std::iter::repeat;
 use std::slice::bytes::{MutableByteVector, copy_memory};
 use serialize::hex::ToHex;
 
@@ -254,7 +255,7 @@ pub trait Digest {
     /// Convenience function that retrieves the result of a digest as a
     /// newly allocated vec of bytes.
     fn result_bytes(&mut self) -> Vec<u8> {
-        let mut buf = vec![0; (self.output_bits()+7)/8];
+        let mut buf: Vec<u8> = repeat(0).take((self.output_bits()+7)/8).collect();
         self.result(&mut buf);
         buf
     }
@@ -533,6 +534,7 @@ mod tests {
     use self::rand::Rng;
     use self::rand::isaac::IsaacRng;
     use serialize::hex::FromHex;
+    use std::iter::repeat;
     use std::u64;
     use super::{Digest, Sha256, FixedBuffer};
 
@@ -611,7 +613,7 @@ mod tests {
     /// correct.
     fn test_digest_1million_random<D: Digest>(digest: &mut D, blocksize: usize, expected: &str) {
         let total_size = 1000000;
-        let buffer = vec![b'a'; blocksize * 2];
+        let buffer: Vec<u8> = repeat('a' as u8).take(blocksize * 2).collect();
         let mut rng = IsaacRng::new_unseeded();
         let mut count = 0;
 

branches/tmp/src/librustc_data_structures/bitvec.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::iter;
+
 /// A very simple BitVector type.
 pub struct BitVector {
     data: Vec<u64>
@@ -16,7 +18,7 @@ pub struct BitVector {
 impl BitVector {
     pub fn new(num_bits: usize) -> BitVector {
         let num_words = (num_bits + 63) / 64;
-        BitVector { data: vec![0; num_words] }
+        BitVector { data: iter::repeat(0).take(num_words).collect() }
     }
 
     fn word_mask(&self, bit: usize) -> (usize, u64) {