---

yaml
---
r: 98135
b: refs/heads/master
c: c626838
h: refs/heads/master
i:
  98133: e8a7939
  98131: 3eb538b
  98127: b22ebb6
v: v3

Author: am0d

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6361c1dee5df03ae5ef915423814c29ab56315d0
+refs/heads/master: c6268384a656f578ce60b53db7656ced88a9c5bd
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/Makefile.in

@@ -418,7 +418,6 @@ export CFG_PREFIX
 export CFG_LIBDIR
 export CFG_RUSTLIBDIR
 export CFG_LIBDIR_RELATIVE
-export CFG_DISABLE_INJECT_STD_VERSION
 
 ######################################################################
 # Subprograms

trunk/configure

@@ -381,7 +381,6 @@ opt clang 0 "prefer clang to gcc for building the runtime"
 opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
 opt pax-flags 0 "apply PaX flags to rustc binaries (required for GRSecurity/PaX-patched kernels)"
-opt inject-std-version 1 "inject the current compiler version of libstd into programs"
 valopt prefix "/usr/local" "set installation prefix"
 valopt local-rust-root "/usr/local" "set prefix for local rust binary"
 valopt llvm-root "" "set LLVM root"
@@ -1043,7 +1042,6 @@ putvar CFG_DISABLE_MANAGE_SUBMODULES
 putvar CFG_ANDROID_CROSS_PATH
 putvar CFG_MINGW32_CROSS_PATH
 putvar CFG_MANDIR
-putvar CFG_DISABLE_INJECT_STD_VERSION
 
 # Avoid spurious warnings from clang by feeding it original source on
 # ccache-miss rather than preprocessed input.

trunk/doc/index.md

@@ -4,52 +4,54 @@
 <style type="text/css">
 #TOC { display: none; }
 .header-section-number { display: none; }
+li {list-style-type: none; }
 </style>
 
-[The Rust tutorial](tutorial.html)  ([PDF](tutorial.pdf))  
-[The Rust reference manual](rust.html) ([PDF](rust.pdf))  
+* [The Rust tutorial](tutorial.html)  (* [PDF](tutorial.pdf))
+* [The Rust reference manual](rust.html) (* [PDF](rust.pdf))
 
 # Guides
 
-[Pointers](guide-pointers.html)  
-[References and Lifetimes](guide-lifetimes.html)  
-[Containers and Iterators](guide-container.html)  
-[Tasks and Communication](guide-tasks.html)  
-[Foreign Function Interface](guide-ffi.html)  
-[Macros](guide-macros.html)  
-[Packaging](guide-rustpkg.html)  
-[Testing](guide-testing.html)  
-[Conditions](guide-conditions.html)  
-[Rust's Runtime](guide-runtime.html)
+* [Pointers](guide-pointers.html)
+* [References and Lifetimes](guide-lifetimes.html)
+* [Containers and Iterators](guide-container.html)
+* [Tasks and Communication](guide-tasks.html)
+* [Foreign Function Interface](guide-ffi.html)
+* [Macros](guide-macros.html)
+* [Packaging](guide-rustpkg.html)
+* [Testing](guide-testing.html)
+* [Conditions](guide-conditions.html)
+* [Rust's Runtime](guide-runtime.html)
 
 # Libraries
 
-[The standard library, `libstd`](std/index.html)  
-[The extra library, `libextra`](extra/index.html)
+* [The standard library, `libstd`](std/index.html)
+* [The extra library, `libextra`](extra/index.html)
 
-[The M:N runtime library, `libgreen`](green/index.html)  
-[The 1:1 runtime library, `libnative`](native/index.html)
+* [The M:N runtime library, `libgreen`](green/index.html)
+* [The 1:1 runtime library, `libnative`](native/index.html)
 
-[The Rust libuv library, `librustuv`](rustuv/index.html)  
-[The Rust packaging library, `librustpkg`](rustpkg/index.html)
+* [The Rust libuv library, `librustuv`](rustuv/index.html)
+* [The Rust packaging library, `librustpkg`](rustpkg/index.html)
 
-[The Rust parser, `libsyntax`](syntax/index.html)  
-[The Rust compiler, `librustc`](rustc/index.html)
+* [The Rust parser, `libsyntax`](syntax/index.html)
+* [The Rust compiler, `librustc`](rustc/index.html)
 
 # Tooling
 
-[The `rustpkg` manual](rustpkg.html)
+* [The `rustdoc` manual](rustdoc.html)
+* [The `rustpkg` manual](rustpkg.html)
 
 # FAQs
 
-[Language FAQ](complement-lang-faq.html)  
-[Project FAQ](complement-project-faq.html)  
-[Usage FAQ](complement-usage-faq.html)  
-[Code cheatsheet](complement-cheatsheet.html) - "How do I do X?"  
-[How to submit a bug report](complement-bugreport.html)
+* [Language FAQ](complement-lang-faq.html)
+* [Project FAQ](complement-project-faq.html)
+* [Usage FAQ](complement-usage-faq.html)
+* [Code cheatsheet](complement-cheatsheet.html) - "How do I do X?"  
+* [How to submit a bug report](complement-bugreport.html)
 
 # External resources
 
-The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org  
-The Rust community on [Reddit](http://reddit.com/r/rust)  
-The Rust [wiki](http://github.com/mozilla/rust/wiki)
+* The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org  
+* The Rust community on [Reddit](http://reddit.com/r/rust)
+* The Rust [wiki](http://github.com/mozilla/rust/wiki)

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

@@ -83,7 +83,8 @@ syn keyword rustTrait OrdIterator MutableDoubleEndedIterator ExactSize
 syn keyword rustTrait Times
 
 syn keyword rustTrait Algebraic Trigonometric Exponential Hyperbolic
-syn keyword rustTrait Bitwise Bounded Integer Fractional Real RealExt
+syn keyword rustTrait Bitwise BitCount Bounded
+syn keyword rustTrait 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/comm.rs

@@ -16,8 +16,6 @@ Higher level communication abstractions.
 
 #[allow(missing_doc)];
 
-use std::comm;
-
 /// An extension of `pipes::stream` that allows both sending and receiving.
 pub struct DuplexStream<T, U> {
     priv chan: Chan<T>,
@@ -42,7 +40,7 @@ impl<T:Send,U:Send> DuplexStream<T, U> {
     pub fn recv(&self) -> U {
         self.port.recv()
     }
-    pub fn try_recv(&self) -> comm::TryRecvResult<U> {
+    pub fn try_recv(&self) -> Option<U> {
         self.port.try_recv()
     }
     pub fn recv_opt(&self) -> Option<U> {
@@ -79,11 +77,11 @@ impl<T: Send> SyncPort<T> {
         })
     }
 
-    pub fn try_recv(&self) -> comm::TryRecvResult<T> {
-        match self.duplex_stream.try_recv() {
-            comm::Data(t) => { self.duplex_stream.try_send(()); comm::Data(t) }
-            state => state,
-        }
+    pub fn try_recv(&self) -> Option<T> {
+        self.duplex_stream.try_recv().map(|val| {
+            self.duplex_stream.try_send(());
+            val
+        })
     }
 }
 

trunk/src/libextra/enum_set.rs

@@ -13,8 +13,6 @@
 //! 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/lib.rs

@@ -20,8 +20,7 @@ Rust extras are part of the standard Rust distribution.
 
 */
 
-// NOTE: upgrade to 0.10-pre after the next snapshot
-#[crate_id = "extra#0.9"];
+#[crate_id = "extra#0.10-pre"];
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];
 #[crate_type = "rlib"];

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::{Bitwise, ToPrimitive, FromPrimitive};
+use std::num::{ToPrimitive, FromPrimitive};
 use std::rand::Rng;
 use std::str;
 use std::uint;

trunk/src/libextra/sync.rs

@@ -19,7 +19,6 @@
 
 
 use std::borrow;
-use std::comm;
 use std::unstable::sync::Exclusive;
 use std::sync::arc::UnsafeArc;
 use std::sync::atomics;
@@ -50,7 +49,7 @@ impl WaitQueue {
     // Signals one live task from the queue.
     fn signal(&self) -> bool {
         match self.head.try_recv() {
-            comm::Data(ch) => {
+            Some(ch) => {
                 // Send a wakeup signal. If the waiter was killed, its port will
                 // have closed. Keep trying until we get a live task.
                 if ch.try_send_deferred(()) {
@@ -59,20 +58,20 @@ impl WaitQueue {
                     self.signal()
                 }
             }
-            _ => false
+            None => false
         }
     }
 
     fn broadcast(&self) -> uint {
         let mut count = 0;
         loop {
             match self.head.try_recv() {
-                comm::Data(ch) => {
+                None => break,
+                Some(ch) => {
                     if ch.try_send_deferred(()) {
                         count += 1;
                     }
                 }
-                _ => break
             }
         }
         count

trunk/src/libextra/time.rs

@@ -1459,7 +1459,7 @@ mod tests {
     }
 
     #[test]
-    #[ignore(cfg(target_os = "android"))] // FIXME #10958
+    #[ignore(cfg(android))] // FIXME #10958
     fn run_tests() {
         // The tests race on tzset. So instead of having many independent
         // tests, we will just call the functions now.

trunk/src/libgreen/macros.rs

@@ -13,6 +13,7 @@
 #[macro_escape];
 
 use std::fmt;
+use std::libc;
 
 // Indicates whether we should perform expensive sanity checks, including rtassert!
 // XXX: Once the runtime matures remove the `true` below to turn off rtassert, etc.
@@ -123,7 +124,6 @@ memory and partly incapable of presentation to others.",
     abort();
 
     fn abort() -> ! {
-        use std::unstable::intrinsics;
-        unsafe { intrinsics::abort() }
+        unsafe { libc::abort() }
     }
 }

trunk/src/libgreen/sched.rs

@@ -958,7 +958,6 @@ fn new_sched_rng() -> XorShiftRng {
 
 #[cfg(test)]
 mod test {
-    use std::comm;
     use std::task::TaskOpts;
     use std::rt::Runtime;
     use std::rt::task::Task;
@@ -1377,7 +1376,7 @@ mod test {
             // This task should not be able to starve the sender;
             // The sender should get stolen to another thread.
             do spawn {
-                while port.try_recv() != comm::Data(()) { }
+                while port.try_recv().is_none() { }
             }
 
             chan.send(());
@@ -1394,7 +1393,7 @@ mod test {
             // This task should not be able to starve the other task.
             // The sends should eventually yield.
             do spawn {
-                while port.try_recv() != comm::Data(()) {
+                while port.try_recv().is_none() {
                     chan2.send(());
                 }
             }

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/back/abi.rs

@@ -45,8 +45,9 @@ pub static tydesc_field_align: uint = 1u;
 pub static tydesc_field_take_glue: uint = 2u;
 pub static tydesc_field_drop_glue: uint = 3u;
 pub static tydesc_field_visit_glue: uint = 4u;
-pub static tydesc_field_name_offset: uint = 5u;
-pub static n_tydesc_fields: uint = 6u;
+pub static tydesc_field_borrow_offset: uint = 5u;
+pub static tydesc_field_name_offset: uint = 6u;
+pub static n_tydesc_fields: uint = 7u;
 
 // The two halves of a closure: code and environment.
 pub static fn_field_code: uint = 0u;

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/front/std_inject.rs

@@ -21,9 +21,6 @@ use syntax::fold;
 use syntax::opt_vec;
 use syntax::util::small_vector::SmallVector;
 
-// NOTE: upgrade to 0.10-pre after the next snapshot
-pub static VERSION: &'static str = "0.9";
-
 pub fn maybe_inject_libstd_ref(sess: Session, crate: ast::Crate)
                                -> ast::Crate {
     if use_std(&crate) {
@@ -56,21 +53,11 @@ struct StandardLibraryInjector {
     sess: Session,
 }
 
-pub fn with_version(crate: &str) -> Option<(@str, ast::StrStyle)> {
-    match option_env!("CFG_DISABLE_INJECT_STD_VERSION") {
-        Some("1") => None,
-        _ => {
-            Some((format!("{}\\#{}", crate, VERSION).to_managed(),
-                  ast::CookedStr))
-        }
-    }
-}
-
 impl fold::Folder for StandardLibraryInjector {
     fn fold_crate(&mut self, crate: ast::Crate) -> ast::Crate {
         let mut vis = ~[ast::ViewItem {
             node: ast::ViewItemExternMod(self.sess.ident_of("std"),
-                                         with_version("std"),
+                                         None,
                                          ast::DUMMY_NODE_ID),
             attrs: ~[],
             vis: ast::Private,
@@ -80,15 +67,15 @@ impl fold::Folder for StandardLibraryInjector {
         if use_uv(&crate) && !self.sess.building_library.get() {
             vis.push(ast::ViewItem {
                 node: ast::ViewItemExternMod(self.sess.ident_of("green"),
-                                             with_version("green"),
+                                             None,
                                              ast::DUMMY_NODE_ID),
                 attrs: ~[],
                 vis: ast::Private,
                 span: DUMMY_SP
             });
             vis.push(ast::ViewItem {
                 node: ast::ViewItemExternMod(self.sess.ident_of("rustuv"),
-                                             with_version("rustuv"),
+                                             None,
                                              ast::DUMMY_NODE_ID),
                 attrs: ~[],
                 vis: ast::Private,