---

yaml
---
r: 98129
b: refs/heads/master
c: 1dd6906
h: refs/heads/master
i:
  98127: b22ebb6
v: v3

Author: brendanzab

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: bf2ab22cd0eda8e019cb243916e6c127708739cf
+refs/heads/master: 1dd6906db2e6749bc3f113068e7493070b276feb
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/src/etc/vim/syntax/rust.vim

@@ -83,8 +83,7 @@ syn keyword rustTrait OrdIterator MutableDoubleEndedIterator ExactSize
 syn keyword rustTrait Times
 
 syn keyword rustTrait Algebraic Trigonometric Exponential Hyperbolic
-syn keyword rustTrait Bitwise BitCount Bounded
-syn keyword rustTrait Integer Fractional Real RealExt
+syn keyword rustTrait Bitwise Bounded Integer Fractional Real RealExt
 syn keyword rustTrait Num NumCast CheckedAdd CheckedSub CheckedMul
 syn keyword rustTrait Orderable Signed Unsigned Round
 syn keyword rustTrait Primitive Int Float ToStrRadix ToPrimitive FromPrimitive

trunk/src/libextra/enum_set.rs

@@ -13,6 +13,8 @@
 //! This module defines a container which uses an efficient bit mask
 //! representation to hold C-like enum variants.
 
+use std::num::Bitwise;
+
 #[deriving(Clone, Eq, IterBytes, ToStr, Encodable, Decodable)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {

trunk/src/libextra/num/bigint.rs

@@ -22,7 +22,7 @@ A `BigInt` is a combination of `BigUint` and `Sign`.
 use std::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 use std::num;
 use std::num::{Zero, One, ToStrRadix, FromStrRadix, Orderable};
-use std::num::{ToPrimitive, FromPrimitive};
+use std::num::{Bitwise, ToPrimitive, FromPrimitive};
 use std::rand::Rng;
 use std::str;
 use std::uint;

trunk/src/libnative/lib.rs

@@ -39,6 +39,30 @@ static OS_DEFAULT_STACK_ESTIMATE: uint = 1 << 20;
 #[cfg(unix, not(android))]
 static OS_DEFAULT_STACK_ESTIMATE: uint = 2 * (1 << 20);
 
+
+// XXX: this should not exist here
+#[cfg(stage0, nativestart)]
+#[lang = "start"]
+pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
+    use std::cast;
+    use std::task;
+
+    do start(argc, argv) {
+        // Instead of invoking main directly on this thread, invoke it on
+        // another spawned thread that we are guaranteed to know the size of the
+        // stack of. Currently, we do not have a method of figuring out the size
+        // of the main thread's stack, so for stack overflow detection to work
+        // we must spawn the task in a subtask which we know the stack size of.
+        let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
+        let mut task = task::task();
+        task.name("<main>");
+        match do task.try { main() } {
+            Ok(()) => { os::set_exit_status(0); }
+            Err(..) => { os::set_exit_status(rt::DEFAULT_ERROR_CODE); }
+        }
+    }
+}
+
 /// Executes the given procedure after initializing the runtime with the given
 /// argc/argv.
 ///

trunk/src/librustc/driver/driver.rs

@@ -1011,7 +1011,7 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                           for details)", "FEATURE"),
   optopt("", "android-cross-path",
          "The path to the Android NDK", "PATH"),
-  optmulti("W", "warn",
+  optflagopt("W", "warn",
                         "Set lint warnings", "OPT"),
   optmulti("A", "allow",
                         "Set lint allowed", "OPT"),

trunk/src/librustc/lib.rs

@@ -227,9 +227,14 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) {
         return;
     }
 
+    // Display the available lint options if "-W help" or only "-W" is given.
     let lint_flags = vec::append(matches.opt_strs("W"),
                                  matches.opt_strs("warn"));
-    if lint_flags.iter().any(|x| x == &~"help") {
+
+    let show_lint_options = lint_flags.iter().any(|x| x == &~"help") ||
+        (matches.opt_present("W") && lint_flags.is_empty());
+
+    if show_lint_options {
         describe_warnings();
         return;
     }

trunk/src/librustc/util/sha2.rs

@@ -523,6 +523,7 @@ static H256: [u32, ..8] = [
 #[cfg(test)]
 mod tests {
     use super::{Digest, Sha256, FixedBuffer};
+    use std::num::Bounded;
     use std::vec;
     use std::rand::isaac::IsaacRng;
     use std::rand::Rng;

trunk/src/librustpkg/sha1.rs

@@ -445,6 +445,7 @@ impl Digest for Sha1 {
 
 #[cfg(test)]
 mod tests {
+    use std::num::Bounded;
     use std::rand::{IsaacRng, Rng};
     use std::vec;
     use extra::hex::FromHex;

trunk/src/libstd/cleanup.rs

@@ -17,8 +17,6 @@ use unstable::raw;
 
 type DropGlue<'a> = 'a |**TyDesc, *c_void|;
 
-static RC_IMMORTAL : uint = 0x77777777;
-
 /*
  * Box annihilation
  *
@@ -27,21 +25,24 @@ static RC_IMMORTAL : uint = 0x77777777;
 
 struct AnnihilateStats {
     n_total_boxes: uint,
+    n_unique_boxes: uint,
     n_bytes_freed: uint
 }
 
 unsafe fn each_live_alloc(read_next_before: bool,
-                          f: |alloc: *mut raw::Box<()>| -> bool)
+                          f: |alloc: *mut raw::Box<()>, uniq: bool| -> bool)
                           -> bool {
     //! Walks the internal list of allocations
 
+    use managed;
     use rt::local_heap;
 
     let mut alloc = local_heap::live_allocs();
     while alloc != ptr::mut_null() {
         let next_before = (*alloc).next;
+        let uniq = (*alloc).ref_count == managed::RC_MANAGED_UNIQUE;
 
-        if !f(alloc) {
+        if !f(alloc, uniq) {
             return false;
         }
 
@@ -69,19 +70,25 @@ fn debug_mem() -> bool {
 pub unsafe fn annihilate() {
     use rt::local_heap::local_free;
     use mem;
+    use managed;
 
     let mut stats = AnnihilateStats {
         n_total_boxes: 0,
+        n_unique_boxes: 0,
         n_bytes_freed: 0
     };
 
     // Pass 1: Make all boxes immortal.
     //
     // In this pass, nothing gets freed, so it does not matter whether
     // we read the next field before or after the callback.
-    each_live_alloc(true, |alloc| {
+    each_live_alloc(true, |alloc, uniq| {
         stats.n_total_boxes += 1;
-        (*alloc).ref_count = RC_IMMORTAL;
+        if uniq {
+            stats.n_unique_boxes += 1;
+        } else {
+            (*alloc).ref_count = managed::RC_IMMORTAL;
+        }
         true
     });
 
@@ -90,10 +97,12 @@ pub unsafe fn annihilate() {
     // In this pass, unique-managed boxes may get freed, but not
     // managed boxes, so we must read the `next` field *after* the
     // callback, as the original value may have been freed.
-    each_live_alloc(false, |alloc| {
-        let tydesc = (*alloc).type_desc;
-        let data = &(*alloc).data as *();
-        ((*tydesc).drop_glue)(data as *i8);
+    each_live_alloc(false, |alloc, uniq| {
+        if !uniq {
+            let tydesc = (*alloc).type_desc;
+            let data = &(*alloc).data as *();
+            ((*tydesc).drop_glue)(data as *i8);
+        }
         true
     });
 
@@ -103,19 +112,22 @@ pub unsafe fn annihilate() {
     // unique-managed boxes, though I think that none of those are
     // left), so we must read the `next` field before, since it will
     // not be valid after.
-    each_live_alloc(true, |alloc| {
-        stats.n_bytes_freed +=
-            (*((*alloc).type_desc)).size
-            + mem::size_of::<raw::Box<()>>();
-        local_free(alloc as *i8);
+    each_live_alloc(true, |alloc, uniq| {
+        if !uniq {
+            stats.n_bytes_freed +=
+                (*((*alloc).type_desc)).size
+                + mem::size_of::<raw::Box<()>>();
+            local_free(alloc as *i8);
+        }
         true
     });
 
     if debug_mem() {
         // We do logging here w/o allocation.
         debug!("annihilator stats:\n  \
                        total boxes: {}\n  \
+                      unique boxes: {}\n  \
                        bytes freed: {}",
-                stats.n_total_boxes, stats.n_bytes_freed);
+                stats.n_total_boxes, stats.n_unique_boxes, stats.n_bytes_freed);
     }
 }

trunk/src/libstd/managed.rs

@@ -14,6 +14,9 @@ use ptr::to_unsafe_ptr;
 
 #[cfg(not(test))] use cmp::*;
 
+pub static RC_MANAGED_UNIQUE : uint = (-2) as uint;
+pub static RC_IMMORTAL : uint = 0x77777777;
+
 /// Returns the refcount of a shared box (as just before calling this)
 #[inline]
 pub fn refcount<T>(t: @T) -> uint {

trunk/src/libstd/num/f32.rs

@@ -17,7 +17,7 @@ use cmath;
 use default::Default;
 use libc::{c_float, c_int};
 use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal};
-use num::{Zero, One, strconv};
+use num::{Zero, One, Bounded, strconv};
 use num;
 use to_str;
 use unstable::intrinsics;

trunk/src/libstd/num/f64.rs

@@ -18,7 +18,7 @@ use cmath;
 use default::Default;
 use libc::{c_double, c_int};
 use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal};
-use num::{Zero, One, strconv};
+use num::{Zero, One, Bounded, strconv};
 use num;
 use to_str;
 use unstable::intrinsics;

trunk/src/libstd/num/i16.rs

@@ -15,7 +15,7 @@
 use prelude::*;
 
 use default::Default;
-use num::{BitCount, CheckedAdd, CheckedSub, CheckedMul};
+use num::{Bitwise, Bounded, CheckedAdd, CheckedSub, CheckedMul};
 use num::{CheckedDiv, Zero, One, strconv};
 use num::{ToStrRadix, FromStrRadix};
 use option::{Option, Some, None};
@@ -24,7 +24,7 @@ use unstable::intrinsics;
 
 int_module!(i16, 16)
 
-impl BitCount for i16 {
+impl Bitwise for i16 {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]
     fn population_count(&self) -> i16 { unsafe { intrinsics::ctpop16(*self) } }

trunk/src/libstd/num/i32.rs

@@ -15,7 +15,7 @@
 use prelude::*;
 
 use default::Default;
-use num::{BitCount, CheckedAdd, CheckedSub, CheckedMul};
+use num::{Bitwise, Bounded, CheckedAdd, CheckedSub, CheckedMul};
 use num::{CheckedDiv, Zero, One, strconv};
 use num::{ToStrRadix, FromStrRadix};
 use option::{Option, Some, None};
@@ -24,7 +24,7 @@ use unstable::intrinsics;
 
 int_module!(i32, 32)
 
-impl BitCount for i32 {
+impl Bitwise for i32 {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]
     fn population_count(&self) -> i32 { unsafe { intrinsics::ctpop32(*self) } }

trunk/src/libstd/num/i64.rs

@@ -17,7 +17,7 @@ use prelude::*;
 use default::Default;
 #[cfg(target_word_size = "64")]
 use num::CheckedMul;
-use num::{BitCount, CheckedAdd, CheckedSub};
+use num::{Bitwise, Bounded, CheckedAdd, CheckedSub};
 use num::{CheckedDiv, Zero, One, strconv};
 use num::{ToStrRadix, FromStrRadix};
 use option::{Option, Some, None};
@@ -26,7 +26,7 @@ use unstable::intrinsics;
 
 int_module!(i64, 64)
 
-impl BitCount for i64 {
+impl Bitwise for i64 {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]
     fn population_count(&self) -> i64 { unsafe { intrinsics::ctpop64(*self) } }

trunk/src/libstd/num/i8.rs

@@ -15,7 +15,7 @@
 use prelude::*;
 
 use default::Default;
-use num::{BitCount, CheckedAdd, CheckedSub, CheckedMul};
+use num::{Bitwise, Bounded, CheckedAdd, CheckedSub, CheckedMul};
 use num::{CheckedDiv, Zero, One, strconv};
 use num::{ToStrRadix, FromStrRadix};
 use option::{Option, Some, None};
@@ -24,7 +24,7 @@ use unstable::intrinsics;
 
 int_module!(i8, 8)
 
-impl BitCount for i8 {
+impl Bitwise for i8 {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]
     fn population_count(&self) -> i8 { unsafe { intrinsics::ctpop8(*self) } }

trunk/src/libstd/num/int.rs

@@ -15,7 +15,7 @@
 use prelude::*;
 
 use default::Default;
-use num::{BitCount, CheckedAdd, CheckedSub, CheckedMul};
+use num::{Bitwise, Bounded, CheckedAdd, CheckedSub, CheckedMul};
 use num::{CheckedDiv, Zero, One, strconv};
 use num::{ToStrRadix, FromStrRadix};
 use option::{Option, Some, None};
@@ -26,7 +26,7 @@ use unstable::intrinsics;
 #[cfg(target_word_size = "64")] int_module!(int, 64)
 
 #[cfg(target_word_size = "32")]
-impl BitCount for int {
+impl Bitwise for int {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]
     fn population_count(&self) -> int { (*self as i32).population_count() as int }
@@ -41,7 +41,7 @@ impl BitCount for int {
 }
 
 #[cfg(target_word_size = "64")]
-impl BitCount for int {
+impl Bitwise for int {
     /// Counts the number of bits set. Wraps LLVM's `ctpop` intrinsic.
     #[inline]
     fn population_count(&self) -> int { (*self as i64).population_count() as int }

trunk/src/libstd/num/int_macros.rs

@@ -308,15 +308,13 @@ impl Integer for $T {
 
     /// Returns `true` if the number is divisible by `2`
     #[inline]
-    fn is_even(&self) -> bool { self & 1 == 0 }
+    fn is_even(&self) -> bool { self.is_multiple_of(&2) }
 
     /// Returns `true` if the number is not divisible by `2`
     #[inline]
     fn is_odd(&self) -> bool { !self.is_even() }
 }
 
-impl Bitwise for $T {}
-
 #[cfg(not(test))]
 impl BitOr<$T,$T> for $T {
     #[inline]
@@ -446,6 +444,7 @@ mod tests {
     use i32;
     use num;
     use num::CheckedDiv;
+    use num::Bitwise;
     use mem;
 
     #[test]