---

yaml
---
r: 118414
b: refs/heads/try
c: c20aed0
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3770c42a4959cbabc73da52abc7e3db96657974e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d6736a1440d42f6af967a8a20ab8d73522112b72
-refs/heads/try: c7426cf05a166fca8aa76a690bad17111ea0dea4
+refs/heads/try: c20aed09307d1b486c22e9b62156b02500ae1e6e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/guide-lifetimes.md

@@ -275,8 +275,10 @@ invalidate the pointer `owner_age`.
 
 # Borrowing and enums
 
-The previous example showed that the type system forbids any borrowing
-of owned boxes found in aliasable, mutable memory. This restriction
+The previous example showed that the type system forbids any mutations
+of owned boxed values while they are being borrowed. In general, the type
+system also forbids borrowing a value as mutable if it is already being
+borrowed - either as a mutable reference or an immutable one. This restriction
 prevents pointers from pointing into freed memory. There is one other
 case where the compiler must be very careful to ensure that pointers
 remain valid: pointers into the interior of an `enum`.

branches/try/src/libcore/cell.rs

@@ -385,6 +385,7 @@ impl<'b, T> DerefMut<T> for RefMut<'b, T> {
 #[cfg(test)]
 mod test {
     use super::*;
+    use mem::drop;
 
     #[test]
     fn smoketest_cell() {
@@ -412,6 +413,22 @@ mod test {
         assert!(format!("{}", x).as_slice().contains(x.get()));
     }
 
+    #[test]
+    fn ref_and_refmut_have_sensible_show() {
+        use str::StrSlice;
+        use realstd::str::Str;
+
+        let refcell = RefCell::new("foo");
+
+        let refcell_refmut = refcell.borrow_mut();
+        assert!(format!("{}", refcell_refmut).as_slice().contains("foo"));
+        drop(refcell_refmut);
+
+        let refcell_ref = refcell.borrow();
+        assert!(format!("{}", refcell_ref).as_slice().contains("foo"));
+        drop(refcell_ref);
+    }
+
     #[test]
     fn double_imm_borrow() {
         let x = RefCell::new(0);

branches/try/src/libcore/fmt/mod.rs

@@ -13,13 +13,14 @@
 #![allow(unused_variable)]
 
 use any;
-use cell::Cell;
+use cell::{Cell, Ref, RefMut};
 use char::Char;
 use collections::Collection;
 use iter::{Iterator, range};
 use kinds::Copy;
 use mem;
 use option::{Option, Some, None};
+use ops::Deref;
 use result::{Ok, Err};
 use result;
 use slice::{Vector, ImmutableVector};
@@ -840,5 +841,17 @@ impl<T: Copy + Show> Show for Cell<T> {
     }
 }
 
+impl<'b, T: Show> Show for Ref<'b, T> {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<'b, T: Show> Show for RefMut<'b, T> {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        (*(self.deref())).fmt(f)
+    }
+}
+
 // If you expected tests to be here, look instead at the run-pass/ifmt.rs test,
 // it's a lot easier than creating all of the rt::Piece structures here.

branches/try/src/libstd/rand/mod.rs

@@ -60,7 +60,7 @@ use std::rand;
 use std::rand::Rng;
 
 let mut rng = rand::task_rng();
-if rng.gen() { // bool
+if rng.gen() { // random bool
     println!("int: {}, uint: {}", rng.gen::<int>(), rng.gen::<uint>())
 }
 ```

branches/try/src/libsync/one.rs

@@ -20,22 +20,18 @@ use core::atomics;
 
 use mutex::{StaticMutex, MUTEX_INIT};
 
-/// A type which can be used to run a one-time global initialization. This type
-/// is *unsafe* to use because it is built on top of the `Mutex` in this module.
-/// It does not know whether the currently running task is in a green or native
-/// context, and a blocking mutex should *not* be used under normal
-/// circumstances on a green task.
-///
-/// Despite its unsafety, it is often useful to have a one-time initialization
-/// routine run for FFI bindings or related external functionality. This type
-/// can only be statically constructed with the `ONCE_INIT` value.
+/// A synchronization primitive which can be used to run a one-time global
+/// initialization. Useful for one-time initialization for FFI or related
+/// functionality. This type can only be constructed with the `ONCE_INIT`
+/// value.
 ///
 /// # Example
 ///
 /// ```rust
 /// use sync::one::{Once, ONCE_INIT};
 ///
 /// static mut START: Once = ONCE_INIT;
+///
 /// unsafe {
 ///     START.doit(|| {
 ///         // run initialization here
@@ -60,7 +56,7 @@ impl Once {
     /// will be executed if this is the first time `doit` has been called, and
     /// otherwise the routine will *not* be invoked.
     ///
-    /// This method will block the calling *os thread* if another initialization
+    /// This method will block the calling task if another initialization
     /// routine is currently running.
     ///
     /// When this function returns, it is guaranteed that some initialization