---

yaml
---
r: 97715
b: refs/heads/snap-stage3
c: 149fc76
h: refs/heads/master
i:
  97713: 9d68c9b
  97711: a3c2c98
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 86c60b68f996c45565543370b9fb93f2ce14865d
+refs/heads/snap-stage3: 149fc76698318f8f7cdfaa37a818e347721764e7
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/Makefile.in

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

branches/snap-stage3/configure

@@ -381,6 +381,7 @@ 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"
@@ -1042,6 +1043,7 @@ 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.

branches/snap-stage3/doc/index.md

@@ -19,7 +19,7 @@
 [Macros](guide-macros.html)  
 [Packaging](guide-rustpkg.html)  
 [Testing](guide-testing.html)  
-[Conditions](guide-conditions.html)
+[Conditions](guide-conditions.html)  
 [Rust's Runtime](guide-runtime.html)
 
 # Libraries

branches/snap-stage3/src/libextra/comm.rs

@@ -16,6 +16,8 @@ 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>,
@@ -40,7 +42,7 @@ impl<T:Send,U:Send> DuplexStream<T, U> {
     pub fn recv(&self) -> U {
         self.port.recv()
     }
-    pub fn try_recv(&self) -> Option<U> {
+    pub fn try_recv(&self) -> comm::TryRecvResult<U> {
         self.port.try_recv()
     }
     pub fn recv_opt(&self) -> Option<U> {
@@ -77,11 +79,11 @@ impl<T: Send> SyncPort<T> {
         })
     }
 
-    pub fn try_recv(&self) -> Option<T> {
-        self.duplex_stream.try_recv().map(|val| {
-            self.duplex_stream.try_send(());
-            val
-        })
+    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,
+        }
     }
 }
 

branches/snap-stage3/src/libextra/lib.rs

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

branches/snap-stage3/src/libextra/sync.rs

@@ -19,6 +19,7 @@
 
 
 use std::borrow;
+use std::comm;
 use std::unstable::sync::Exclusive;
 use std::sync::arc::UnsafeArc;
 use std::sync::atomics;
@@ -49,7 +50,7 @@ impl WaitQueue {
     // Signals one live task from the queue.
     fn signal(&self) -> bool {
         match self.head.try_recv() {
-            Some(ch) => {
+            comm::Data(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(()) {
@@ -58,20 +59,20 @@ impl WaitQueue {
                     self.signal()
                 }
             }
-            None => false
+            _ => false
         }
     }
 
     fn broadcast(&self) -> uint {
         let mut count = 0;
         loop {
             match self.head.try_recv() {
-                None => break,
-                Some(ch) => {
+                comm::Data(ch) => {
                     if ch.try_send_deferred(()) {
                         count += 1;
                     }
                 }
+                _ => break
             }
         }
         count

branches/snap-stage3/src/libextra/time.rs

@@ -1459,7 +1459,7 @@ mod tests {
     }
 
     #[test]
-    #[ignore(cfg(android))] // FIXME #10958
+    #[ignore(cfg(target_os = "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.

branches/snap-stage3/src/libgreen/macros.rs

@@ -13,7 +13,6 @@
 #[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.
@@ -124,6 +123,7 @@ memory and partly incapable of presentation to others.",
     abort();
 
     fn abort() -> ! {
-        unsafe { libc::abort() }
+        use std::unstable::intrinsics;
+        unsafe { intrinsics::abort() }
     }
 }

branches/snap-stage3/src/libgreen/sched.rs

@@ -958,6 +958,7 @@ 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;
@@ -1376,7 +1377,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().is_none() { }
+                while port.try_recv() != comm::Data(()) { }
             }
 
             chan.send(());
@@ -1393,7 +1394,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().is_none() {
+                while port.try_recv() != comm::Data(()) {
                     chan2.send(());
                 }
             }

branches/snap-stage3/src/librustc/back/abi.rs

@@ -45,9 +45,8 @@ 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_borrow_offset: uint = 5u;
-pub static tydesc_field_name_offset: uint = 6u;
-pub static n_tydesc_fields: uint = 7u;
+pub static tydesc_field_name_offset: uint = 5u;
+pub static n_tydesc_fields: uint = 6u;
 
 // The two halves of a closure: code and environment.
 pub static fn_field_code: uint = 0u;

branches/snap-stage3/src/librustc/front/std_inject.rs

@@ -21,6 +21,9 @@ 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) {
@@ -53,11 +56,21 @@ 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"),
-                                         None,
+                                         with_version("std"),
                                          ast::DUMMY_NODE_ID),
             attrs: ~[],
             vis: ast::Private,
@@ -67,15 +80,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"),
-                                             None,
+                                             with_version("green"),
                                              ast::DUMMY_NODE_ID),
                 attrs: ~[],
                 vis: ast::Private,
                 span: DUMMY_SP
             });
             vis.push(ast::ViewItem {
                 node: ast::ViewItemExternMod(self.sess.ident_of("rustuv"),
-                                             None,
+                                             with_version("rustuv"),
                                              ast::DUMMY_NODE_ID),
                 attrs: ~[],
                 vis: ast::Private,

branches/snap-stage3/src/librustc/front/test.rs

@@ -13,6 +13,7 @@
 
 use driver::session;
 use front::config;
+use front::std_inject::with_version;
 
 use std::cell::RefCell;
 use std::vec;
@@ -292,7 +293,7 @@ fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
                                           ast::DUMMY_NODE_ID))])
     } else {
         ast::ViewItemExternMod(id_extra,
-                               None,
+                               with_version("extra"),
                                ast::DUMMY_NODE_ID)
     };
     ast::ViewItem {

branches/snap-stage3/src/librustc/middle/trans/_match.rs

@@ -1584,14 +1584,9 @@ fn compile_submatch_continue<'r,
     }
 
     if any_uniq_pat(m, col) {
-        let pat_ty = node_id_type(bcx, pat_id);
         let llbox = Load(bcx, val);
-        let unboxed = match ty::get(pat_ty).sty {
-            ty::ty_uniq(..) if !ty::type_contents(bcx.tcx(), pat_ty).owns_managed() => llbox,
-            _ => GEPi(bcx, llbox, [0u, abi::box_field_body])
-        };
         compile_submatch(bcx, enter_uniq(bcx, dm, m, col, val),
-                         vec::append(~[unboxed], vals_left), chk);
+                         vec::append(~[llbox], vals_left), chk);
         return;
     }
 
@@ -2231,13 +2226,8 @@ fn bind_irrefutable_pat<'a>(
             }
         }
         ast::PatUniq(inner) => {
-            let pat_ty = node_id_type(bcx, pat.id);
             let llbox = Load(bcx, val);
-            let unboxed = match ty::get(pat_ty).sty {
-                ty::ty_uniq(..) if !ty::type_contents(bcx.tcx(), pat_ty).owns_managed() => llbox,
-                    _ => GEPi(bcx, llbox, [0u, abi::box_field_body])
-            };
-            bcx = bind_irrefutable_pat(bcx, inner, unboxed, binding_mode);
+            bcx = bind_irrefutable_pat(bcx, inner, llbox, binding_mode);
         }
         ast::PatRegion(inner) => {
             let loaded_val = Load(bcx, val);

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -368,7 +368,7 @@ pub fn malloc_raw_dyn<'a>(
     } else {
         // we treat ~fn, @fn and @[] as @ here, which isn't ideal
         let langcall = match heap {
-            heap_managed | heap_managed_unique => {
+            heap_managed => {
                 require_alloc_fn(bcx, t, MallocFnLangItem)
             }
             heap_exchange_closure => {
@@ -392,9 +392,7 @@ pub fn malloc_raw_dyn<'a>(
             langcall,
             [tydesc, size],
             None);
-        let r = rslt(r.bcx, PointerCast(r.bcx, r.val, llty));
-        maybe_set_managed_unique_rc(r.bcx, r.val, heap);
-        r
+        rslt(r.bcx, PointerCast(r.bcx, r.val, llty))
     }
 }
 
@@ -441,27 +439,6 @@ pub fn malloc_general<'a>(bcx: &'a Block, t: ty::t, heap: heap)
     malloc_general_dyn(bcx, t, heap, llsize_of(bcx.ccx(), ty))
 }
 
-pub fn heap_for_unique(bcx: &Block, t: ty::t) -> heap {
-    if ty::type_contents(bcx.tcx(), t).owns_managed() {
-        heap_managed_unique
-    } else {
-        heap_exchange
-    }
-}
-
-pub fn maybe_set_managed_unique_rc(bcx: &Block, bx: ValueRef, heap: heap) {
-    assert!(heap != heap_exchange);
-    if heap == heap_managed_unique {
-        // In cases where we are looking at a unique-typed allocation in the
-        // managed heap (thus have refcount 1 from the managed allocator),
-        // such as a ~(@foo) or such. These need to have their refcount forced
-        // to -2 so the annihilator ignores them.
-        let rc = GEPi(bcx, bx, [0u, abi::box_field_refcnt]);
-        let rc_val = C_int(bcx.ccx(), -2);
-        Store(bcx, rc_val, rc);
-    }
-}
-
 // Type descriptor and type glue stuff
 
 pub fn get_tydesc_simple(ccx: &CrateContext, t: ty::t) -> ValueRef {

branches/snap-stage3/src/librustc/middle/trans/closure.rs

@@ -150,14 +150,6 @@ pub fn mk_closure_tys(tcx: ty::ctxt,
     return cdata_ty;
 }
 
-fn heap_for_unique_closure(bcx: &Block, t: ty::t) -> heap {
-    if ty::type_contents(bcx.tcx(), t).owns_managed() {
-        heap_managed_unique
-    } else {
-        heap_exchange_closure
-    }
-}
-
 pub fn allocate_cbox<'a>(
                      bcx: &'a Block<'a>,
                      sigil: ast::Sigil,
@@ -173,7 +165,7 @@ pub fn allocate_cbox<'a>(
             tcx.sess.bug("trying to trans allocation of @fn")
         }
         ast::OwnedSigil => {
-            malloc_raw(bcx, cdata_ty, heap_for_unique_closure(bcx, cdata_ty))
+            malloc_raw(bcx, cdata_ty, heap_exchange_closure)
         }
         ast::BorrowedSigil => {
             let cbox_ty = tuplify_box_ty(tcx, cdata_ty);

branches/snap-stage3/src/librustc/middle/trans/common.rs

@@ -90,7 +90,6 @@ pub struct tydesc_info {
     tydesc: ValueRef,
     size: ValueRef,
     align: ValueRef,
-    borrow_offset: ValueRef,
     name: ValueRef,
     take_glue: Cell<Option<ValueRef>>,
     drop_glue: Cell<Option<ValueRef>>,
@@ -316,7 +315,6 @@ pub fn warn_not_to_commit(ccx: &CrateContext, msg: &str) {
 #[deriving(Eq)]
 pub enum heap {
     heap_managed,
-    heap_managed_unique,
     heap_exchange,
     heap_exchange_closure
 }
@@ -498,7 +496,7 @@ pub fn add_clean_temp_mem_in_scope_(bcx: &Block, scope_id: Option<ast::NodeId>,
 
 pub fn add_clean_free(cx: &Block, ptr: ValueRef, heap: heap) {
     let free_fn = match heap {
-        heap_managed | heap_managed_unique => {
+        heap_managed => {
             @GCHeapFreeingCleanupFunction {
                 ptr: ptr,
             } as @CleanupFunction