---

yaml
---
r: 102517
b: refs/heads/auto
c: 5afc63a
h: refs/heads/master
i:
  102515: 86224c0
v: v3

Author: dotdash

[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: df044ea4ac8fb7f99622948f4f8c40fbd24eda13
+refs/heads/auto: 5afc63a2aef113d49944b6ee5f7a743198a6aff1
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libarena/lib.rs

@@ -36,6 +36,7 @@ use std::ptr;
 use std::kinds::marker;
 use std::mem;
 use std::rt::global_heap;
+use std::uint;
 use std::unstable::intrinsics::{TyDesc, get_tydesc};
 use std::unstable::intrinsics;
 use std::util;
@@ -179,7 +180,7 @@ impl Arena {
         let new_min_chunk_size = num::max(n_bytes, chunk_size);
         self.chunks.set(@Cons(self.pod_head.clone(), self.chunks.get()));
         self.pod_head =
-            chunk(num::next_power_of_two(new_min_chunk_size + 1u), true);
+            chunk(uint::next_power_of_two(new_min_chunk_size + 1u), true);
 
         return self.alloc_pod_inner(n_bytes, align);
     }
@@ -221,7 +222,7 @@ impl Arena {
         let new_min_chunk_size = num::max(n_bytes, chunk_size);
         self.chunks.set(@Cons(self.head.clone(), self.chunks.get()));
         self.head =
-            chunk(num::next_power_of_two(new_min_chunk_size + 1u), false);
+            chunk(uint::next_power_of_two(new_min_chunk_size + 1u), false);
 
         return self.alloc_nonpod_inner(n_bytes, align);
     }

branches/auto/src/libextra/ringbuf.rs

@@ -303,7 +303,7 @@ impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> {
             &mut self.remaining2
         };
         self.nelts -= 1;
-        Some(r.mut_shift_ref().unwrap().get_mut_ref())
+        Some(r.mut_shift_ref().get_mut_ref())
     }
 
     #[inline]
@@ -325,7 +325,7 @@ impl<'a, T> DoubleEndedIterator<&'a mut T> for MutItems<'a, T> {
             &mut self.remaining1
         };
         self.nelts -= 1;
-        Some(r.mut_pop_ref().unwrap().get_mut_ref())
+        Some(r.mut_pop_ref().get_mut_ref())
     }
 }
 

branches/auto/src/librustc/metadata/common.rs

@@ -35,8 +35,6 @@ pub static tag_items_data_item_variant: uint = 0x0eu;
 
 pub static tag_items_data_parent_item: uint = 0x0fu;
 
-pub static tag_items_data_item_is_tuple_struct_ctor: uint = 0x10u;
-
 pub static tag_index: uint = 0x11u;
 
 pub static tag_index_buckets: uint = 0x12u;

branches/auto/src/librustc/metadata/decoder.rs

@@ -980,26 +980,9 @@ pub fn get_static_methods_if_impl(intr: @IdentInterner,
     return Some(static_impl_methods);
 }
 
-/// If node_id is the constructor of a tuple struct, retrieve the NodeId of
-/// the actual type definition, otherwise, return None
-pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd,
-                                           node_id: ast::NodeId) -> Option<ast::NodeId> {
-    let item = lookup_item(node_id, cdata.data());
-    let mut ret = None;
-    reader::tagged_docs(item, tag_items_data_item_is_tuple_struct_ctor, |_| {
-        ret = Some(item_reqd_and_translated_parent_item(cdata.cnum, item));
-        false
-    });
-    ret.map(|x| x.node)
-}
-
 pub fn get_item_attrs(cdata: Cmd,
                       node_id: ast::NodeId,
                       f: |~[@ast::MetaItem]|) {
-    // The attributes for a tuple struct are attached to the definition, not the ctor;
-    // we assume that someone passing in a tuple struct ctor is actually wanting to
-    // look at the definition
-    let node_id = get_tuple_struct_definition_if_ctor(cdata, node_id).unwrap_or(node_id);
     let item = lookup_item(node_id, cdata.data());
     reader::tagged_docs(item, tag_attributes, |attributes| {
         reader::tagged_docs(attributes, tag_attribute, |attribute| {

branches/auto/src/librustc/metadata/encoder.rs

@@ -778,12 +778,6 @@ fn encode_info_for_struct_ctor(ecx: &EncodeContext,
         encode_symbol(ecx, ebml_w, ctor_id);
     }
 
-    // indicate that this is a tuple struct ctor, because downstream users will normally want
-    // the tuple struct definition, but without this there is no way for them to tell that
-    // they actually have a ctor rather than a normal function
-    ebml_w.start_tag(tag_items_data_item_is_tuple_struct_ctor);
-    ebml_w.end_tag();
-
     ebml_w.end_tag();
 }
 

branches/auto/src/librustc/middle/trans/cleanup.rs

@@ -662,7 +662,7 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> {
         // Check if a landing pad block exists; if not, create one.
         {
             let mut scopes = self.scopes.borrow_mut();
-            let last_scope = scopes.get().mut_last().unwrap();
+            let last_scope = scopes.get().mut_last();
             match last_scope.cached_landing_pad {
                 Some(llbb) => { return llbb; }
                 None => {

branches/auto/src/libstd/at_vec.rs

@@ -177,9 +177,9 @@ pub mod raw {
     use cast::{transmute, transmute_copy};
     use container::Container;
     use option::None;
-    use mem;
-    use num::next_power_of_two;
     use ptr;
+    use mem;
+    use uint;
     use unstable::intrinsics::{move_val_init, TyDesc};
     use unstable::intrinsics;
     use unstable::raw::{Box, Vec};
@@ -293,7 +293,7 @@ pub mod raw {
      */
     #[inline]
     pub unsafe fn reserve_at_least<T>(v: &mut @[T], n: uint) {
-        reserve(v, next_power_of_two(n));
+        reserve(v, uint::next_power_of_two(n));
     }
 }
 

branches/auto/src/libstd/hashmap.rs

@@ -64,6 +64,7 @@ use num;
 use option::{None, Option, Some};
 use rand::Rng;
 use rand;
+use uint;
 use util::replace;
 use vec::{ImmutableVector, MutableVector, OwnedVector, Items, MutItems};
 use vec_ng;
@@ -387,7 +388,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     pub fn reserve_at_least(&mut self, n: uint) {
         if n > self.buckets.len() {
             let buckets = n * 4 / 3 + 1;
-            self.resize(num::next_power_of_two(buckets));
+            self.resize(uint::next_power_of_two(buckets));
         }
     }
 

branches/auto/src/libstd/io/extensions.rs

@@ -51,23 +51,16 @@ impl<'r, R: Reader> Iterator<u8> for Bytes<'r, R> {
 }
 
 pub fn u64_to_le_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
+    use unstable::intrinsics::{to_le16, to_le32, to_le64};
+    use cast::transmute;
+
+    // LLVM fails to properly optimize this when using shifts instead of the to_le* intrinsics
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
-      2u => f(&[n as u8,
-              (n >> 8) as u8]),
-      4u => f(&[n as u8,
-              (n >> 8) as u8,
-              (n >> 16) as u8,
-              (n >> 24) as u8]),
-      8u => f(&[n as u8,
-              (n >> 8) as u8,
-              (n >> 16) as u8,
-              (n >> 24) as u8,
-              (n >> 32) as u8,
-              (n >> 40) as u8,
-              (n >> 48) as u8,
-              (n >> 56) as u8]),
+      2u => f(unsafe { transmute::<i16, [u8, ..2]>(to_le16(n as i16)) }),
+      4u => f(unsafe { transmute::<i32, [u8, ..4]>(to_le32(n as i32)) }),
+      8u => f(unsafe { transmute::<i64, [u8, ..8]>(to_le64(n as i64)) }),
       _ => {
 
         let mut bytes: ~[u8] = ~[];
@@ -84,23 +77,16 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
 }
 
 pub fn u64_to_be_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
+    use unstable::intrinsics::{to_be16, to_be32, to_be64};
+    use cast::transmute;
+
+    // LLVM fails to properly optimize this when using shifts instead of the to_be* intrinsics
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
-      2u => f(&[(n >> 8) as u8,
-              n as u8]),
-      4u => f(&[(n >> 24) as u8,
-              (n >> 16) as u8,
-              (n >> 8) as u8,
-              n as u8]),
-      8u => f(&[(n >> 56) as u8,
-              (n >> 48) as u8,
-              (n >> 40) as u8,
-              (n >> 32) as u8,
-              (n >> 24) as u8,
-              (n >> 16) as u8,
-              (n >> 8) as u8,
-              n as u8]),
+      2u => f(unsafe { transmute::<i16, [u8, ..2]>(to_be16(n as i16)) }),
+      4u => f(unsafe { transmute::<i32, [u8, ..4]>(to_be32(n as i32)) }),
+      8u => f(unsafe { transmute::<i64, [u8, ..8]>(to_be64(n as i64)) }),
       _ => {
         let mut bytes: ~[u8] = ~[];
         let mut i = size;

branches/auto/src/libstd/num/int.rs

@@ -120,3 +120,10 @@ impl CheckedMul for int {
         }
     }
 }
+
+#[test]
+fn test_overflows() {
+    assert!((::int::MAX > 0));
+    assert!((::int::MIN <= 0));
+    assert!((::int::MIN + ::int::MAX + 1 == 0));
+}

branches/auto/src/libstd/num/int_macros.rs

@@ -445,13 +445,6 @@ mod tests {
     use num::CheckedDiv;
     use num::Bitwise;
 
-    #[test]
-    fn test_overflows() {
-        assert!(MAX > 0);
-        assert!(MIN <= 0);
-        assert_eq!(MIN + MAX + 1, 0);
-    }
-
     #[test]
     fn test_num() {
         num::test_num(10 as $T, 2 as $T);

branches/auto/src/libstd/num/mod.rs

@@ -440,39 +440,7 @@ pub trait Primitive: Clone
 /// A collection of traits relevant to primitive signed and unsigned integers
 pub trait Int: Integer
              + Primitive
-             + Bitwise
-             + CheckedAdd
-             + CheckedSub
-             // + CheckedMul // FIXME #8849: currently not impled on 32-bit
-             + CheckedDiv {}
-
-/// Returns the smallest power of 2 greater than or equal to `n`.
-#[inline]
-pub fn next_power_of_two<T: Unsigned + Int>(n: T) -> T {
-    let halfbits: T = cast(size_of::<T>() * 4).unwrap();
-    let mut tmp: T = n - one();
-    let mut shift: T = one();
-    while shift <= halfbits {
-        tmp = tmp | (tmp >> shift);
-        shift = shift << one();
-    }
-    tmp + one()
-}
-
-/// Returns the smallest power of 2 greater than or equal to `n`. If the next
-/// power of two is greater than the type's maximum value, `None` is returned,
-/// otherwise the power of 2 is wrapped in `Some`.
-#[inline]
-pub fn checked_next_power_of_two<T: Unsigned + Int>(n: T) -> Option<T> {
-    let halfbits: T = cast(size_of::<T>() * 4).unwrap();
-    let mut tmp: T = n - one();
-    let mut shift: T = one();
-    while shift <= halfbits {
-        tmp = tmp | (tmp >> shift);
-        shift = shift << one();
-    }
-    tmp.checked_add(&one())
-}
+             + Bitwise {}
 
 /// Used for representing the classification of floating point numbers
 #[deriving(Eq)]
@@ -1621,48 +1589,6 @@ mod tests {
         assert_eq!(third.checked_mul(&4), None);
     }
 
-    macro_rules! test_next_power_of_two(
-        ($test_name:ident, $T:ident) => (
-            fn $test_name() {
-                #[test];
-                assert_eq!(next_power_of_two::<$T>(0), 0);
-                let mut next_power = 1;
-                for i in range::<$T>(1, 40) {
-                     assert_eq!(next_power_of_two(i), next_power);
-                     if i == next_power { next_power *= 2 }
-                }
-            }
-        )
-    )
-
-    test_next_power_of_two!(test_next_power_of_two_u8, u8)
-    test_next_power_of_two!(test_next_power_of_two_u16, u16)
-    test_next_power_of_two!(test_next_power_of_two_u32, u32)
-    test_next_power_of_two!(test_next_power_of_two_u64, u64)
-    test_next_power_of_two!(test_next_power_of_two_uint, uint)
-
-    macro_rules! test_checked_next_power_of_two(
-        ($test_name:ident, $T:ident) => (
-            fn $test_name() {
-                #[test];
-                assert_eq!(checked_next_power_of_two::<$T>(0), None);
-                let mut next_power = 1;
-                for i in range::<$T>(1, 40) {
-                     assert_eq!(checked_next_power_of_two(i), Some(next_power));
-                     if i == next_power { next_power *= 2 }
-                }
-                assert!(checked_next_power_of_two::<$T>($T::MAX / 2).is_some());
-                assert_eq!(checked_next_power_of_two::<$T>($T::MAX - 1), None);
-                assert_eq!(checked_next_power_of_two::<$T>($T::MAX), None);
-            }
-        )
-    )
-
-    test_checked_next_power_of_two!(test_checked_next_power_of_two_u8, u8)
-    test_checked_next_power_of_two!(test_checked_next_power_of_two_u16, u16)
-    test_checked_next_power_of_two!(test_checked_next_power_of_two_u32, u32)
-    test_checked_next_power_of_two!(test_checked_next_power_of_two_u64, u64)
-    test_checked_next_power_of_two!(test_checked_next_power_of_two_uint, uint)
 
     #[deriving(Eq)]
     struct Value { x: int }