---

yaml
---
r: 231870
b: refs/heads/auto
c: 4fc09d3
h: refs/heads/master
v: v3

Author: Manishearth

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: b1e80079994e1f147c726e964278b28a972991e5
+refs/heads/auto: 4fc09d3a15d18ee15897fa90ad93dc2cef37c919
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/RELEASES.md

@@ -1,4 +1,4 @@
-Version 1.2.0 (August 2015)
+Version 1.2.0 (2015-08-07)
 ===========================
 
 * ~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 (June 2015)
+Version 1.1.0 (2015-06-25)
 =========================
 
 * ~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 (May 2015)
+Version 1.0.0 (2015-05-15)
 ========================
 
 * ~1500 changes, numerous bugfixes

branches/auto/src/doc/trpl/advanced-linking.md

@@ -34,8 +34,8 @@ formal `#[link(...)]` attribute on `extern` blocks instead.
 
 # Static linking
 
-Static linking refers to the process of creating output that contain all
-required libraries and so don't need libraries installed on every system where
+Static linking refers to the process of creating output that contains all
+required libraries and so doesn't need libraries installed on every system where
 you want to use your compiled project. Pure-Rust dependencies are statically
 linked by default so you can use created binaries and libraries without
 installing Rust everywhere. By contrast, native libraries

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

@@ -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/auto/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,

branches/auto/src/etc/featureck.py

@@ -47,20 +47,24 @@
                 is_feature_line = True
 
         if is_feature_line:
-            line = line.replace("(", "").replace("),", "").replace(")", "")
+            # turn `    ("foo", "1.0.0", Some(10), Active)` into
+            # `"foo", "1.0.0", Some(10), Active`
+            line = line.strip(' ,()')
             parts = line.split(",")
-            if len(parts) != 3:
+            if len(parts) != 4:
                 print("error: unexpected number of components in line: " + original_line)
                 sys.exit(1)
             feature_name = parts[0].strip().replace('"', "")
             since = parts[1].strip().replace('"', "")
-            status = parts[2].strip()
+            issue = parts[2].strip()
+            status = parts[3].strip()
             assert len(feature_name) > 0
             assert len(since) > 0
+            assert len(issue) > 0
             assert len(status) > 0
 
             language_feature_names += [feature_name]
-            language_features += [(feature_name, since, status)]
+            language_features += [(feature_name, since, issue, status)]
 
 assert len(language_features) > 0
 
@@ -158,7 +162,7 @@
     status = "unstable"
     stable_since = None
 
-    if f[2] == "Accepted":
+    if f[3] == "Accepted":
         status = "stable"
     if status == "stable":
         stable_since = f[1]

branches/auto/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);
 
-        return self.alloc_copy_inner(n_bytes, align);
+        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());
-            return &mut *ptr;
+            &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);
 
-        return self.alloc_noncopy_inner(n_bytes, align);
+        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();
-            return (buf.offset(tydesc_start as isize), buf.offset(start as isize));
+            (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);
 
-            return &mut *ptr;
+            &mut *ptr
         }
     }
 
@@ -486,14 +486,12 @@ impl<T> TypedArena<T> {
             self.grow()
         }
 
-        let ptr: &mut T = unsafe {
+        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/auto/src/libcore/slice.rs

@@ -303,8 +303,10 @@ impl<T> SliceExt for [T] {
     fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
         let len = self.len();
         let ptr = self.as_mut_ptr();
-        assert!(mid <= len);
+
         unsafe {
+            assert!(mid <= len);
+
             (from_raw_parts_mut(ptr, mid),
              from_raw_parts_mut(ptr.offset(mid as isize), len - mid))
         }

branches/auto/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]); }
 
-            return CharRange {ch: unsafe { char::from_u32_unchecked(val) }, next: i};
+            CharRange {ch: unsafe { char::from_u32_unchecked(val) }, next: i}
         }
 
-        return multibyte_char_range_at_reverse(self, prev);
+        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]); }
 
-        return (val, i + w as usize);
+        (val, i + w as usize)
     }
 
     multibyte_char_range_at(bytes, i)

branches/auto/src/libgetopts/lib.rs

@@ -229,14 +229,14 @@ impl Name {
         if nm.len() == 1 {
             Short(nm.char_at(0))
         } else {
-            Long(nm.to_string())
+            Long(nm.to_owned())
         }
     }
 
     fn to_string(&self) -> String {
         match *self {
             Short(ch) => ch.to_string(),
-            Long(ref s) => s.to_string()
+            Long(ref s) => s.to_owned()
         }
     }
 }
@@ -375,7 +375,7 @@ impl Matches {
         } else {
             match vals[0] {
                 Val(ref s) => Some((*s).clone()),
-                _ => Some(def.to_string())
+                _ => Some(def.to_owned())
             }
         }
     }
@@ -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_string(),
-        long_name: long_name.to_string(),
-        hint: hint.to_string(),
-        desc: desc.to_string(),
+        short_name: short_name.to_owned(),
+        long_name: long_name.to_owned(),
+        hint: hint.to_owned(),
+        desc: desc.to_owned(),
         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_string(),
-        long_name: long_name.to_string(),
-        hint: hint.to_string(),
-        desc: desc.to_string(),
+        short_name: short_name.to_owned(),
+        long_name: long_name.to_owned(),
+        hint: hint.to_owned(),
+        desc: desc.to_owned(),
         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_string(),
-        long_name: long_name.to_string(),
-        hint: "".to_string(),
-        desc: desc.to_string(),
+        short_name: short_name.to_owned(),
+        long_name: long_name.to_owned(),
+        hint: "".to_owned(),
+        desc: desc.to_owned(),
         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_string(),
-        long_name: long_name.to_string(),
-        hint: "".to_string(),
-        desc: desc.to_string(),
+        short_name: short_name.to_owned(),
+        long_name: long_name.to_owned(),
+        hint: "".to_owned(),
+        desc: desc.to_owned(),
         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_string(),
-        long_name: long_name.to_string(),
-        hint: hint.to_string(),
-        desc: desc.to_string(),
+        short_name: short_name.to_owned(),
+        long_name: long_name.to_owned(),
+        hint: hint.to_owned(),
+        desc: desc.to_owned(),
         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_string(),
-        long_name: long_name.to_string(),
-        hint: hint.to_string(),
-        desc: desc.to_string(),
+        short_name: short_name.to_owned(),
+        long_name: long_name.to_owned(),
+        hint: hint.to_owned(),
+        desc: desc.to_owned(),
         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_string(),
-        long_name: long_name.to_string(),
-        hint: hint.to_string(),
-        desc: desc.to_string(),
+        short_name: short_name.to_owned(),
+        long_name: long_name.to_owned(),
+        hint: hint.to_owned(),
+        desc: desc.to_owned(),
         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> { return Vec::new(); }
+    fn f(_x: usize) -> Vec<Optval> { 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_string()));
+                    names = vec!(Long(tail.to_owned()));
                 } else {
                     names =
-                        vec!(Long(tail_eq[0].to_string()));
-                    i_arg = Some(tail_eq[1].to_string());
+                        vec!(Long(tail_eq[0].to_owned()));
+                    i_arg = Some(tail_eq[1].to_owned());
                 }
             } 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_string());
+                        i_arg = Some((&cur[next..curlen]).to_owned());
                         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_string());
+            desc_rows.push(substr.to_owned());
             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;
     }
-    return cont;
+    cont
 }
 
 #[test]