---

yaml
---
r: 185599
b: refs/heads/master
c: 9e28cae
h: refs/heads/master
i:
  185597: 0035991
  185595: 52c896f
  185591: 8e4e791
  185583: c4f04b9
  185567: d76032e
  185535: a7b8e16
  185471: 9b60322
  185343: 0a7bc07
v: v3

Author: GuillaumeGomez

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 157614249594f187f421cd97f928e64c5ab5c1fa
+refs/heads/master: 9e28caef31de0b36262273be13d29cec80876f77
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 3a96d6a9818fe2affc98a187fb1065120458cee9
 refs/heads/try: ccf8fedf1cffcb8f6f3581d53d220039e192fe77

trunk/configure

@@ -875,7 +875,7 @@ then
             | cut -d ' ' -f 2)
 
         case $CFG_CLANG_VERSION in
-            (3.2* | 3.3* | 3.4* | 3.5* | 3.6*)
+            (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* | 3.6*)
             step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
             if [ -z "$CC" ]
             then

trunk/src/libcollections/str.rs

@@ -1455,9 +1455,9 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     ///
     /// `is_cjk` determines behavior for characters in the Ambiguous category: if `is_cjk` is
     /// `true`, these are 2 columns wide; otherwise, they are 1. In CJK locales, `is_cjk` should be
-    /// `true`, else it should be `false`.
-    /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) recommends that these
-    /// characters be treated as 1 column (i.e., `is_cjk = false`) if the locale is unknown.
+    /// `true`, else it should be `false`. [Unicode Standard Annex
+    /// #11](http://www.unicode.org/reports/tr11/) recommends that these characters be treated as 1
+    /// column (i.e., `is_cjk` = `false`) if the locale is unknown.
     #[unstable(feature = "collections",
                reason = "this functionality may only be provided by libunicode")]
     fn width(&self, is_cjk: bool) -> usize {

trunk/src/libcore/fmt/mod.rs

@@ -700,7 +700,7 @@ impl Display for char {
 impl<T> Pointer for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         f.flags |= 1 << (FlagV1::Alternate as u32);
-        let ret = LowerHex::fmt(&(*self as usize), f);
+        let ret = LowerHex::fmt(&(*self as u32), f);
         f.flags &= !(1 << (FlagV1::Alternate as u32));
         ret
     }

trunk/src/libcore/iter.rs

@@ -68,7 +68,7 @@ use num::{ToPrimitive, Int};
 use ops::{Add, Deref, FnMut};
 use option::Option;
 use option::Option::{Some, None};
-use marker::Sized;
+use marker::{Send, Sized, Sync};
 use usize;
 
 /// An interface for dealing with "external iterators". These types of iterators
@@ -1783,6 +1783,10 @@ pub struct Peekable<I: Iterator> {
     peeked: Option<I::Item>,
 }
 
+// FIXME: after #22828 being fixed, the following unsafe impl should be removed
+unsafe impl<I: Iterator> Sync for Peekable<I> where I: Sync, I::Item: Sync {}
+unsafe impl<I: Iterator> Send for Peekable<I> where I: Send, I::Item: Send {}
+
 impl<I: Iterator + Clone> Clone for Peekable<I> where I::Item: Clone {
     fn clone(&self) -> Peekable<I> {
         Peekable {

trunk/src/libcore/lib.rs

@@ -39,7 +39,7 @@
 //!   distribution.
 //!
 //! * `rust_begin_unwind` - This function takes three arguments, a
-//!   `fmt::Arguments`, a `&str`, and a `uint`. These three arguments dictate
+//!   `fmt::Arguments`, a `&str`, and a `usize`. These three arguments dictate
 //!   the panic message, the file at which panic was invoked, and the line.
 //!   It is up to consumers of this core library to define this panic
 //!   function; it is only required to never return.
@@ -88,14 +88,12 @@ mod int_macros;
 #[macro_use]
 mod uint_macros;
 
-#[path = "num/int.rs"]  pub mod int;
 #[path = "num/isize.rs"]  pub mod isize;
 #[path = "num/i8.rs"]   pub mod i8;
 #[path = "num/i16.rs"]  pub mod i16;
 #[path = "num/i32.rs"]  pub mod i32;
 #[path = "num/i64.rs"]  pub mod i64;
 
-#[path = "num/uint.rs"] pub mod uint;
 #[path = "num/usize.rs"] pub mod usize;
 #[path = "num/u8.rs"]   pub mod u8;
 #[path = "num/u16.rs"]  pub mod u16;

trunk/src/libcore/num/mod.rs

@@ -372,10 +372,9 @@ pub trait Int
     #[unstable(feature = "core",
                reason = "pending integer conventions")]
     #[inline]
-    fn pow(self, mut exp: u32) -> Self {
+    fn pow(self, mut exp: uint) -> Self {
         let mut base = self;
         let mut acc: Self = Int::one();
-
         while exp > 0 {
             if (exp & 1) == 1 {
                 acc = acc * base;

trunk/src/libcoretest/num/int_macros.rs

@@ -201,17 +201,6 @@ mod tests {
         assert_eq!(FromStrRadix::from_str_radix("Z", 35).ok(), None::<$T>);
         assert_eq!(FromStrRadix::from_str_radix("-9", 2).ok(), None::<$T>);
     }
-
-    #[test]
-    fn test_pow() {
-        let mut r = 2 as $T;
-
-        assert_eq!(r.pow(2u32), 4 as $T);
-        assert_eq!(r.pow(0u32), 1 as $T);
-        r = -2 as $T;
-        assert_eq!(r.pow(2u32), 4 as $T);
-        assert_eq!(r.pow(3u32), -8 as $T);
-    }
 }
 
 )}

trunk/src/librbml/lib.rs

@@ -132,9 +132,11 @@ pub mod reader {
     use std::char;
 
     use std::isize;
+    use std::old_io::extensions::u64_from_be_bytes;
     use std::mem::transmute;
     use std::num::Int;
-    use std::slice::bytes;
+    use std::option::Option;
+    use std::option::Option::{None, Some};
 
     use serialize;
 
@@ -197,24 +199,20 @@ pub mod reader {
             return vuint_at_slow(data, start);
         }
 
-        // Lookup table for parsing EBML Element IDs as per
-        // http://ebml.sourceforge.net/specs/ The Element IDs are parsed by
-        // reading a big endian u32 positioned at data[start].  Using the four
-        // most significant bits of the u32 we lookup in the table below how
-        // the element ID should be derived from it.
+        // Lookup table for parsing EBML Element IDs as per http://ebml.sourceforge.net/specs/
+        // The Element IDs are parsed by reading a big endian u32 positioned at data[start].
+        // Using the four most significant bits of the u32 we lookup in the table below how the
+        // element ID should be derived from it.
         //
-        // The table stores tuples (shift, mask) where shift is the number the
-        // u32 should be right shifted with and mask is the value the right
-        // shifted value should be masked with.  If for example the most
-        // significant bit is set this means it's a class A ID and the u32
-        // should be right shifted with 24 and masked with 0x7f. Therefore we
-        // store (24, 0x7f) at index 0x8 - 0xF (four bit numbers where the most
-        // significant bit is set).
+        // The table stores tuples (shift, mask) where shift is the number the u32 should be right
+        // shifted with and mask is the value the right shifted value should be masked with.
+        // If for example the most significant bit is set this means it's a class A ID and the u32
+        // should be right shifted with 24 and masked with 0x7f. Therefore we store (24, 0x7f) at
+        // index 0x8 - 0xF (four bit numbers where the most significant bit is set).
         //
-        // By storing the number of shifts and masks in a table instead of
-        // checking in order if the most significant bit is set, the second
-        // most significant bit is set etc. we can replace up to three
-        // "and+branch" with a single table lookup which gives us a measured
+        // By storing the number of shifts and masks in a table instead of checking in order if
+        // the most significant bit is set, the second most significant bit is set etc. we can
+        // replace up to three "and+branch" with a single table lookup which gives us a measured
         // speedup of around 2x on x86_64.
         static SHIFT_MASK_TABLE: [(uint, u32); 16] = [
             (0, 0x0), (0, 0x0fffffff),
@@ -320,23 +318,17 @@ pub mod reader {
 
     pub fn doc_as_u16(d: Doc) -> u16 {
         assert_eq!(d.end, d.start + 2);
-        let mut b = [0; 2];
-        bytes::copy_memory(&mut b, &d.data[d.start..d.end]);
-        unsafe { (*(b.as_ptr() as *const u16)).to_be() }
+        u64_from_be_bytes(d.data, d.start, 2) as u16
     }
 
     pub fn doc_as_u32(d: Doc) -> u32 {
         assert_eq!(d.end, d.start + 4);
-        let mut b = [0; 4];
-        bytes::copy_memory(&mut b, &d.data[d.start..d.end]);
-        unsafe { (*(b.as_ptr() as *const u32)).to_be() }
+        u64_from_be_bytes(d.data, d.start, 4) as u32
     }
 
     pub fn doc_as_u64(d: Doc) -> u64 {
         assert_eq!(d.end, d.start + 8);
-        let mut b = [0; 8];
-        bytes::copy_memory(&mut b, &d.data[d.start..d.end]);
-        unsafe { (*(b.as_ptr() as *const u64)).to_be() }
+        u64_from_be_bytes(d.data, d.start, 8)
     }
 
     pub fn doc_as_i8(d: Doc) -> i8 { doc_as_u8(d) as i8 }
@@ -697,10 +689,11 @@ pub mod reader {
 }
 
 pub mod writer {
-    use std::mem;
-    use std::num::Int;
+    use std::clone::Clone;
+    use std::old_io::extensions::u64_to_be_bytes;
     use std::old_io::{Writer, Seek};
     use std::old_io;
+    use std::mem;
 
     use super::{ EsVec, EsMap, EsEnum, EsVecLen, EsVecElt, EsMapLen, EsMapKey,
         EsEnumVid, EsU64, EsU32, EsU16, EsU8, EsInt, EsI64, EsI32, EsI16, EsI8,
@@ -801,34 +794,43 @@ pub mod writer {
         }
 
         pub fn wr_tagged_u64(&mut self, tag_id: uint, v: u64) -> EncodeResult {
-            let bytes: [u8; 8] = unsafe { mem::transmute(v.to_be()) };
-            self.wr_tagged_bytes(tag_id, &bytes)
+            u64_to_be_bytes(v, 8, |v| {
+                self.wr_tagged_bytes(tag_id, v)
+            })
         }
 
         pub fn wr_tagged_u32(&mut self, tag_id: uint, v: u32)  -> EncodeResult{
-            let bytes: [u8; 4] = unsafe { mem::transmute(v.to_be()) };
-            self.wr_tagged_bytes(tag_id, &bytes)
+            u64_to_be_bytes(v as u64, 4, |v| {
+                self.wr_tagged_bytes(tag_id, v)
+            })
         }
 
         pub fn wr_tagged_u16(&mut self, tag_id: uint, v: u16) -> EncodeResult {
-            let bytes: [u8; 2] = unsafe { mem::transmute(v.to_be()) };
-            self.wr_tagged_bytes(tag_id, &bytes)
+            u64_to_be_bytes(v as u64, 2, |v| {
+                self.wr_tagged_bytes(tag_id, v)
+            })
         }
 
         pub fn wr_tagged_u8(&mut self, tag_id: uint, v: u8) -> EncodeResult {
             self.wr_tagged_bytes(tag_id, &[v])
         }
 
         pub fn wr_tagged_i64(&mut self, tag_id: uint, v: i64) -> EncodeResult {
-            self.wr_tagged_u64(tag_id, v as u64)
+            u64_to_be_bytes(v as u64, 8, |v| {
+                self.wr_tagged_bytes(tag_id, v)
+            })
         }
 
         pub fn wr_tagged_i32(&mut self, tag_id: uint, v: i32) -> EncodeResult {
-            self.wr_tagged_u32(tag_id, v as u32)
+            u64_to_be_bytes(v as u64, 4, |v| {
+                self.wr_tagged_bytes(tag_id, v)
+            })
         }
 
         pub fn wr_tagged_i16(&mut self, tag_id: uint, v: i16) -> EncodeResult {
-            self.wr_tagged_u16(tag_id, v as u16)
+            u64_to_be_bytes(v as u64, 2, |v| {
+                self.wr_tagged_bytes(tag_id, v)
+            })
         }
 
         pub fn wr_tagged_i8(&mut self, tag_id: uint, v: i8) -> EncodeResult {

trunk/src/librustc/metadata/decoder.rs

@@ -34,11 +34,10 @@ use middle::astencode::vtable_decoder_helpers;
 
 use std::collections::HashMap;
 use std::hash::{self, Hash, SipHasher};
-use std::num::FromPrimitive;
-use std::num::Int;
+use std::old_io::extensions::u64_from_be_bytes;
 use std::old_io;
+use std::num::FromPrimitive;
 use std::rc::Rc;
-use std::slice::bytes;
 use std::str;
 
 use rbml::reader;
@@ -61,26 +60,20 @@ pub type Cmd<'a> = &'a crate_metadata;
 // what crate that's in and give us a def_id that makes sense for the current
 // build.
 
-fn u32_from_be_bytes(bytes: &[u8]) -> u32 {
-    let mut b = [0; 4];
-    bytes::copy_memory(&mut b, &bytes[..4]);
-    unsafe { (*(b.as_ptr() as *const u32)).to_be() }
-}
-
 fn lookup_hash<'a, F>(d: rbml::Doc<'a>, mut eq_fn: F, hash: u64) -> Option<rbml::Doc<'a>> where
     F: FnMut(&[u8]) -> bool,
 {
     let index = reader::get_doc(d, tag_index);
     let table = reader::get_doc(index, tag_index_table);
     let hash_pos = table.start + (hash % 256 * 4) as uint;
-    let pos = u32_from_be_bytes(&d.data[hash_pos..]) as uint;
+    let pos = u64_from_be_bytes(d.data, hash_pos, 4) as uint;
     let tagged_doc = reader::doc_at(d.data, pos).unwrap();
 
     let belt = tag_index_buckets_bucket_elt;
 
     let mut ret = None;
     reader::tagged_docs(tagged_doc.doc, belt, |elt| {
-        let pos = u32_from_be_bytes(&elt.data[elt.start..]) as uint;
+        let pos = u64_from_be_bytes(elt.data, elt.start, 4) as uint;
         if eq_fn(&elt.data[elt.start + 4 .. elt.end]) {
             ret = Some(reader::doc_at(d.data, pos).unwrap().doc);
             false
@@ -94,7 +87,9 @@ fn lookup_hash<'a, F>(d: rbml::Doc<'a>, mut eq_fn: F, hash: u64) -> Option<rbml:
 pub fn maybe_find_item<'a>(item_id: ast::NodeId,
                            items: rbml::Doc<'a>) -> Option<rbml::Doc<'a>> {
     fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool {
-        u32_from_be_bytes(bytes) == item_id
+        return u64_from_be_bytes(
+            &bytes[0..4], 0, 4) as ast::NodeId
+            == item_id;
     }
     lookup_hash(items,
                 |a| eq_item(a, item_id),

trunk/src/librustc_trans/back/write.rs

@@ -851,9 +851,7 @@ pub fn run_passes(sess: &Session,
 
     // FIXME: time_llvm_passes support - does this use a global context or
     // something?
-    if sess.opts.cg.codegen_units == 1 && sess.time_llvm_passes() {
-        unsafe { llvm::LLVMRustPrintPassTimings(); }
-    }
+    //if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); }
 }
 
 struct WorkItem {

trunk/src/librustc_trans/trans/base.rs

@@ -433,13 +433,13 @@ pub fn set_inline_hint(f: ValueRef) {
 }
 
 pub fn set_llvm_fn_attrs(ccx: &CrateContext, attrs: &[ast::Attribute], llfn: ValueRef) {
-    use syntax::attr::{find_inline_attr, InlineAttr};
+    use syntax::attr::*;
     // Set the inline hint if there is one
     match find_inline_attr(Some(ccx.sess().diagnostic()), attrs) {
-        InlineAttr::Hint   => set_inline_hint(llfn),
-        InlineAttr::Always => set_always_inline(llfn),
-        InlineAttr::Never  => set_no_inline(llfn),
-        InlineAttr::None   => { /* fallthrough */ }
+        InlineHint   => set_inline_hint(llfn),
+        InlineAlways => set_always_inline(llfn),
+        InlineNever  => set_no_inline(llfn),
+        InlineNone   => { /* fallthrough */ }
     }
 
     for attr in attrs {
@@ -2332,11 +2332,6 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
           // Do static_assert checking. It can't really be done much earlier
           // because we need to get the value of the bool out of LLVM
           if attr::contains_name(&item.attrs, "static_assert") {
-              if !ty::type_is_bool(ty::expr_ty(ccx.tcx(), expr)) {
-                  ccx.sess().span_fatal(expr.span,
-                                        "can only have static_assert on a static \
-                                         with type `bool`");
-              }
               if m == ast::MutMutable {
                   ccx.sess().span_fatal(expr.span,
                                         "cannot have static_assert on a mutable \

trunk/src/libstd/num/mod.rs

@@ -1830,6 +1830,6 @@ mod bench {
     #[bench]
     fn bench_pow_function(b: &mut Bencher) {
         let v = (0..1024).collect::<Vec<_>>();
-        b.iter(|| {v.iter().fold(0, |old, new| old.pow(*new as u32));});
+        b.iter(|| {v.iter().fold(0, |old, new| old.pow(*new));});
     }
 }

trunk/src/libstd/old_io/extensions.rs

@@ -11,10 +11,6 @@
 //! Utility mixins that apply to all Readers and Writers
 
 #![allow(missing_docs)]
-#![unstable(feature = "old_io")]
-#![deprecated(since = "1.0.0",
-              reason = "functionality will be removed with no immediate \
-                        replacement")]
 
 // FIXME: Not sure how this should be structured
 // FIXME: Iteration should probably be considered separately

trunk/src/libstd/sys/unix/thread.rs

@@ -164,7 +164,7 @@ pub mod guard {
 
         if pthread_main_np() == 1 {
             // main thread
-            current_stack.ss_sp as uint - current_stack.ss_size as uint + PAGE_SIZE as uint
+            current_stack.ss_sp as uint - current_stack.ss_size as uint + 3 * PAGE_SIZE as uint
 
         } else {
             // new thread