---

yaml
---
r: 234111
b: refs/heads/beta
c: ca1a81d
h: refs/heads/master
i:
  234109: b69f2e9
  234107: ae9414c
  234103: 730c15b
  234095: 93290d8
  234079: 552b00a
  234047: 5c1c18a
  233983: cec7bc8
v: v3

Author: steveklabnik

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: b33b121e9529c72ffa4528852a08c108304ca77a
+refs/heads/beta: ca1a81df2388484ec6005b7c6ba8ba953c450bc7
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/RELEASES.md

@@ -1,4 +1,4 @@
-Version 1.2.0 (2015-08-07)
+Version 1.2.0 (August 2015)
 ===========================
 
 * ~1200 changes, numerous bugfixes
@@ -156,7 +156,7 @@ Misc
 [ad]: https://github.com/rust-lang/rust/pull/27382
 [win]: https://github.com/rust-lang/rust/pull/25350
 
-Version 1.1.0 (2015-06-25)
+Version 1.1.0 (June 2015)
 =========================
 
 * ~850 changes, numerous bugfixes
@@ -267,7 +267,7 @@ Misc
 [`split_off`]: https://doc.rust-lang.org/nightly/collections/linked_list/struct.LinkedList.html#method.split_off
 [drop]: https://github.com/rust-lang/rust/pull/24935
 
-Version 1.0.0 (2015-05-15)
+Version 1.0.0 (May 2015)
 ========================
 
 * ~1500 changes, numerous bugfixes

branches/beta/src/doc/trpl/macros.md

@@ -313,7 +313,7 @@ fn main() {
 }
 ```
 
-This works because Rust has a [hygienic macro system]. Each macro expansion
+This works because Rust has a [hygienic macro system][https://en.wikipedia.org/wiki/Hygienic_macro]. Each macro expansion
 happens in a distinct ‘syntax context’, and each variable is tagged with the
 syntax context where it was introduced. It’s as though the variable `state`
 inside `main` is painted a different "color" from the variable `state` inside

branches/beta/src/doc/trpl/mutability.md

@@ -62,7 +62,7 @@ fn foo(mut x: i32) {
 # Interior vs. Exterior Mutability
 
 However, when we say something is ‘immutable’ in Rust, that doesn’t mean that
-it’s not able to be changed: we mean something has ‘exterior mutability’. Consider,
+it’s not able to be changed: We mean something has ‘exterior mutability’. Consider,
 for example, [`Arc<T>`][arc]:
 
 ```rust
@@ -85,8 +85,8 @@ philosophy, memory safety, and the mechanism by which Rust guarantees it, the
 > You may have one or the other of these two kinds of borrows, but not both at
 > the same time:
 > 
-> * one or more references (`&T`) to a resource,
-> * exactly one mutable reference (`&mut T`).
+> * one or more references (`&T`) to a resource.
+> * exactly one mutable reference (`&mut T`)
 
 [ownership]: ownership.html
 [borrowing]: references-and-borrowing.html#borrowing

branches/beta/src/doc/trpl/references-and-borrowing.md

@@ -159,8 +159,8 @@ First, any borrow must last for a scope no greater than that of the owner.
 Second, you may have one or the other of these two kinds of borrows, but not
 both at the same time:
 
-* one or more references (`&T`) to a resource,
-* exactly one mutable reference (`&mut T`).
+* one or more references (`&T`) to a resource.
+* exactly one mutable reference (`&mut T`)
 
 
 You may notice that this is very similar, though not exactly the same as,
@@ -298,8 +298,8 @@ We can’t modify `v` because it’s borrowed by the loop.
 
 ### use after free
 
-References must live as long as the resource they refer to. Rust will check the
-scopes of your references to ensure that this is true.
+References must not live longer than the resource they refer to. Rust will
+check the scopes of your references to ensure that this is true.
 
 If Rust didn’t check this property, we could accidentally use a reference
 which was invalid. For example:

branches/beta/src/libarena/lib.rs

@@ -220,7 +220,7 @@ impl<'longer_than_self> Arena<'longer_than_self> {
         *self.copy_head.borrow_mut() =
             chunk((new_min_chunk_size + 1).next_power_of_two(), true);
 
-        self.alloc_copy_inner(n_bytes, align)
+        return self.alloc_copy_inner(n_bytes, align);
     }
 
     #[inline]
@@ -247,7 +247,7 @@ impl<'longer_than_self> Arena<'longer_than_self> {
                                             mem::align_of::<T>());
             let ptr = ptr as *mut T;
             ptr::write(&mut (*ptr), op());
-            &mut *ptr
+            return &mut *ptr;
         }
     }
 
@@ -261,7 +261,7 @@ impl<'longer_than_self> Arena<'longer_than_self> {
         *self.head.borrow_mut() =
             chunk((new_min_chunk_size + 1).next_power_of_two(), false);
 
-        self.alloc_noncopy_inner(n_bytes, align)
+        return self.alloc_noncopy_inner(n_bytes, align);
     }
 
     #[inline]
@@ -290,7 +290,7 @@ impl<'longer_than_self> Arena<'longer_than_self> {
 
         unsafe {
             let buf = head.as_ptr();
-            (buf.offset(tydesc_start as isize), buf.offset(start as isize))
+            return (buf.offset(tydesc_start as isize), buf.offset(start as isize));
         }
     }
 
@@ -312,7 +312,7 @@ impl<'longer_than_self> Arena<'longer_than_self> {
             // the object is there.
             *ty_ptr = bitpack_tydesc_ptr(tydesc, true);
 
-            &mut *ptr
+            return &mut *ptr;
         }
     }
 
@@ -486,12 +486,14 @@ impl<T> TypedArena<T> {
             self.grow()
         }
 
-        unsafe {
+        let ptr: &mut T = unsafe {
             let ptr: &mut T = &mut *(self.ptr.get() as *mut T);
             ptr::write(ptr, object);
             self.ptr.set(self.ptr.get().offset(1));
             ptr
-        }
+        };
+
+        ptr
     }
 
     /// Grows the arena.

branches/beta/src/libcore/str/mod.rs

@@ -1558,10 +1558,10 @@ impl StrExt for str {
             if w > 2 { val = utf8_acc_cont_byte(val, s.as_bytes()[i + 2]); }
             if w > 3 { val = utf8_acc_cont_byte(val, s.as_bytes()[i + 3]); }
 
-            CharRange {ch: unsafe { char::from_u32_unchecked(val) }, next: i}
+            return CharRange {ch: unsafe { char::from_u32_unchecked(val) }, next: i};
         }
 
-        multibyte_char_range_at_reverse(self, prev)
+        return multibyte_char_range_at_reverse(self, prev);
     }
 
     #[inline]
@@ -1683,7 +1683,7 @@ fn char_range_at_raw(bytes: &[u8], i: usize) -> (u32, usize) {
         if w > 2 { val = utf8_acc_cont_byte(val, bytes[i + 2]); }
         if w > 3 { val = utf8_acc_cont_byte(val, bytes[i + 3]); }
 
-        (val, i + w as usize)
+        return (val, i + w as usize);
     }
 
     multibyte_char_range_at(bytes, i)

branches/beta/src/libgetopts/lib.rs

@@ -229,14 +229,14 @@ impl Name {
         if nm.len() == 1 {
             Short(nm.char_at(0))
         } else {
-            Long(nm.to_owned())
+            Long(nm.to_string())
         }
     }
 
     fn to_string(&self) -> String {
         match *self {
             Short(ch) => ch.to_string(),
-            Long(ref s) => s.to_owned()
+            Long(ref s) => s.to_string()
         }
     }
 }
@@ -375,7 +375,7 @@ impl Matches {
         } else {
             match vals[0] {
                 Val(ref s) => Some((*s).clone()),
-                _ => Some(def.to_owned())
+                _ => Some(def.to_string())
             }
         }
     }
@@ -414,10 +414,10 @@ pub fn reqopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptG
     let len = short_name.len();
     assert!(len == 1 || len == 0);
     OptGroup {
-        short_name: short_name.to_owned(),
-        long_name: long_name.to_owned(),
-        hint: hint.to_owned(),
-        desc: desc.to_owned(),
+        short_name: short_name.to_string(),
+        long_name: long_name.to_string(),
+        hint: hint.to_string(),
+        desc: desc.to_string(),
         hasarg: Yes,
         occur: Req
     }
@@ -434,10 +434,10 @@ pub fn optopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptG
     let len = short_name.len();
     assert!(len == 1 || len == 0);
     OptGroup {
-        short_name: short_name.to_owned(),
-        long_name: long_name.to_owned(),
-        hint: hint.to_owned(),
-        desc: desc.to_owned(),
+        short_name: short_name.to_string(),
+        long_name: long_name.to_string(),
+        hint: hint.to_string(),
+        desc: desc.to_string(),
         hasarg: Yes,
         occur: Optional
     }
@@ -452,10 +452,10 @@ pub fn optflag(short_name: &str, long_name: &str, desc: &str) -> OptGroup {
     let len = short_name.len();
     assert!(len == 1 || len == 0);
     OptGroup {
-        short_name: short_name.to_owned(),
-        long_name: long_name.to_owned(),
-        hint: "".to_owned(),
-        desc: desc.to_owned(),
+        short_name: short_name.to_string(),
+        long_name: long_name.to_string(),
+        hint: "".to_string(),
+        desc: desc.to_string(),
         hasarg: No,
         occur: Optional
     }
@@ -471,10 +471,10 @@ pub fn optflagmulti(short_name: &str, long_name: &str, desc: &str) -> OptGroup {
     let len = short_name.len();
     assert!(len == 1 || len == 0);
     OptGroup {
-        short_name: short_name.to_owned(),
-        long_name: long_name.to_owned(),
-        hint: "".to_owned(),
-        desc: desc.to_owned(),
+        short_name: short_name.to_string(),
+        long_name: long_name.to_string(),
+        hint: "".to_string(),
+        desc: desc.to_string(),
         hasarg: No,
         occur: Multi
     }
@@ -491,10 +491,10 @@ pub fn optflagopt(short_name: &str, long_name: &str, desc: &str, hint: &str) ->
     let len = short_name.len();
     assert!(len == 1 || len == 0);
     OptGroup {
-        short_name: short_name.to_owned(),
-        long_name: long_name.to_owned(),
-        hint: hint.to_owned(),
-        desc: desc.to_owned(),
+        short_name: short_name.to_string(),
+        long_name: long_name.to_string(),
+        hint: hint.to_string(),
+        desc: desc.to_string(),
         hasarg: Maybe,
         occur: Optional
     }
@@ -512,10 +512,10 @@ pub fn optmulti(short_name: &str, long_name: &str, desc: &str, hint: &str) -> Op
     let len = short_name.len();
     assert!(len == 1 || len == 0);
     OptGroup {
-        short_name: short_name.to_owned(),
-        long_name: long_name.to_owned(),
-        hint: hint.to_owned(),
-        desc: desc.to_owned(),
+        short_name: short_name.to_string(),
+        long_name: long_name.to_string(),
+        hint: hint.to_string(),
+        desc: desc.to_string(),
         hasarg: Yes,
         occur: Multi
     }
@@ -531,10 +531,10 @@ pub fn opt(short_name: &str,
     let len = short_name.len();
     assert!(len == 1 || len == 0);
     OptGroup {
-        short_name: short_name.to_owned(),
-        long_name: long_name.to_owned(),
-        hint: hint.to_owned(),
-        desc: desc.to_owned(),
+        short_name: short_name.to_string(),
+        long_name: long_name.to_string(),
+        hint: hint.to_string(),
+        desc: desc.to_string(),
         hasarg: hasarg,
         occur: occur
     }
@@ -574,7 +574,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
     let opts: Vec<Opt> = optgrps.iter().map(|x| x.long_to_short()).collect();
     let n_opts = opts.len();
 
-    fn f(_x: usize) -> Vec<Optval> { Vec::new() }
+    fn f(_x: usize) -> Vec<Optval> { return Vec::new(); }
 
     let mut vals: Vec<_> = (0..n_opts).map(f).collect();
     let mut free: Vec<String> = Vec::new();
@@ -596,11 +596,11 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                 let tail = &cur[2..curlen];
                 let tail_eq: Vec<&str> = tail.split('=').collect();
                 if tail_eq.len() <= 1 {
-                    names = vec!(Long(tail.to_owned()));
+                    names = vec!(Long(tail.to_string()));
                 } else {
                     names =
-                        vec!(Long(tail_eq[0].to_owned()));
-                    i_arg = Some(tail_eq[1].to_owned());
+                        vec!(Long(tail_eq[0].to_string()));
+                    i_arg = Some(tail_eq[1].to_string());
                 }
             } else {
                 let mut j = 1;
@@ -630,7 +630,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
 
                     let next = j + ch.len_utf8();
                     if arg_follows && next < curlen {
-                        i_arg = Some((&cur[next..curlen]).to_owned());
+                        i_arg = Some((&cur[next..curlen]).to_string());
                         break;
                     }
 
@@ -769,7 +769,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String {
         // FIXME: #5516 should be graphemes not codepoints
         let mut desc_rows = Vec::new();
         each_split_within(&desc_normalized_whitespace[..], 54, |substr| {
-            desc_rows.push(substr.to_owned());
+            desc_rows.push(substr.to_string());
             true
         });
 
@@ -936,7 +936,7 @@ fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
         machine(&mut cont, (fake_i, ' '));
         fake_i += 1;
     }
-    cont
+    return cont;
 }
 
 #[test]