---

yaml
---
r: 220539
b: refs/heads/tmp
c: 71e7fee
h: refs/heads/master
i:
  220537: a553d46
  220535: 4f28dc0
v: v3

Author: IvanUkhov

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: c8bab9d06a179028a0d5129aa62f09d694d9cc49
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: dd46cf8b22c39a74b786361e00af22314a32b196
+refs/heads/tmp: 71e7fee803ff5158c85962144f47073210fdb6ba
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 1b28ffa5216c845d1cef6b0cb3e5ac7db12025d0
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/AUTHORS.txt

@@ -958,7 +958,7 @@ Santiago Rodriguez <[email protected]>
 Saurabh Anand <[email protected]>
 Scott Jenkins <[email protected]>
 Scott Lawrence <[email protected]>
-Scott Olson <scott@solson.me>
+Scott Olson <scott@scott-olson.org>
 Sean Bowe <[email protected]>
 Sean Chalmers <[email protected]>
 Sean Collins <[email protected]>

branches/tmp/configure

@@ -988,44 +988,29 @@ if [ ! -z "$CFG_ENABLE_CLANG" ]
 then
     case "$CC" in
         (''|*clang)
-        CFG_CLANG_REPORTED_VERSION=$($CFG_CC --version | grep version)
-
-        if [[ $CFG_CLANG_REPORTED_VERSION == *"(based on LLVM "* ]]
-        then
-            CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*(based on LLVM \(.*\))/\1/')
-        elif [[ $CFG_CLANG_REPORTED_VERSION == "Apple LLVM"* ]]
-        then
-            CFG_OSX_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/')
-        else
-            CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/')
-        fi
-
-        if [ ! -z "$CFG_OSX_CLANG_VERSION" ]
-        then
-            case $CFG_OSX_CLANG_VERSION in
-                (7.0*)
-                step_msg "found ok version of APPLE CLANG: $CFG_OSX_CLANG_VERSION"
-                ;;
-                (*)
-                err "bad APPLE CLANG version: $CFG_OSX_CLANG_VERSION, need >=7.0"
-                ;;
-            esac
-        else
-            case $CFG_CLANG_VERSION in
-                (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7*)
-                step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
-                ;;
-                (*)
-                err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn"
-                ;;
-            esac
-        fi
-
-        if [ -z "$CC" ]
-        then
-            CFG_CC="clang"
-            CFG_CXX="clang++"
-        fi
+        CFG_CLANG_VERSION=$($CFG_CC \
+            --version \
+            | grep version \
+            | sed 's/.*\(version .*\)/\1/; s/.*based on \(LLVM .*\))/\1/' \
+            | cut -d ' ' -f 2)
+
+        case $CFG_CLANG_VERSION in
+            (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7*)
+            step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
+            if [ -z "$CC" ]
+            then
+                CFG_CC="clang"
+                CFG_CXX="clang++"
+            fi
+            ;;
+            (*)
+            err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn"
+            ;;
+        esac
+        ;;
+        (*)
+        msg "skipping CFG_ENABLE_CLANG version check; provided CC=$CC"
+        ;;
     esac
 fi
 

branches/tmp/src/doc/trpl/dining-philosophers.md

@@ -151,15 +151,15 @@ look at `main()` again:
 # struct Philosopher {
 #     name: String,
 # }
-#
+# 
 # impl Philosopher {
 #     fn new(name: &str) -> Philosopher {
 #         Philosopher {
 #             name: name.to_string(),
 #         }
 #     }
 # }
-#
+# 
 fn main() {
     let p1 = Philosopher::new("Judith Butler");
     let p2 = Philosopher::new("Gilles Deleuze");
@@ -197,15 +197,15 @@ a method, and then loop through all the philosophers, calling it:
 ```rust
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
         }
     }
-
+    
     fn eat(&self) {
         println!("{} is done eating.", self.name);
     }
@@ -267,15 +267,15 @@ use std::thread;
 
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
         }
     }
-
+    
     fn eat(&self) {
         println!("{} is eating.", self.name);
 
@@ -348,9 +348,9 @@ use std::thread;
 
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
@@ -401,7 +401,7 @@ let handles: Vec<_> = philosophers.into_iter().map(|p| {
 While this is only five lines, they’re a dense five. Let’s break it down.
 
 ```rust,ignore
-let handles: Vec<_> =
+let handles: Vec<_> = 
 ```
 
 We introduce a new binding, called `handles`. We’ve given it this name because
@@ -460,15 +460,15 @@ If you run this program, you’ll see that the philosophers eat out of order!
 We have multi-threading!
 
 ```text
-Judith Butler is eating.
 Gilles Deleuze is eating.
-Karl Marx is eating.
+Gilles Deleuze is done eating.
 Emma Goldman is eating.
+Emma Goldman is done eating.
 Michel Foucault is eating.
+Judith Butler is eating.
 Judith Butler is done eating.
-Gilles Deleuze is done eating.
+Karl Marx is eating.
 Karl Marx is done eating.
-Emma Goldman is done eating.
 Michel Foucault is done eating.
 ```
 

branches/tmp/src/etc/errorck.py

@@ -23,18 +23,6 @@
 errcode_map = {}
 error_re = re.compile("(E\d\d\d\d)")
 
-# In the register_long_diagnostics! macro, entries look like this:
-#
-# EXXXX: r##"
-# <Long diagnostic message>
-# "##,
-#
-# These two variables are for detecting the beginning and end of diagnostic
-# messages so that duplicate error codes are not reported when a code occurs
-# inside a diagnostic message
-long_diag_begin = "r##\""
-long_diag_end = "\"##"
-
 for (dirpath, dirnames, filenames) in os.walk(src_dir):
     if "src/test" in dirpath or "src/llvm" in dirpath:
         # Short circuit for fast
@@ -47,14 +35,7 @@
         path = os.path.join(dirpath, filename)
 
         with open(path, 'r') as f:
-            inside_long_diag = False
             for line_num, line in enumerate(f, start=1):
-                if inside_long_diag:
-                    # Skip duplicate error code checking for this line
-                    if long_diag_end in line:
-                        inside_long_diag = False
-                    continue
-
                 match = error_re.search(line)
                 if match:
                     errcode = match.group(1)
@@ -66,9 +47,6 @@
                     else:
                         errcode_map[errcode] = new_record
 
-                if long_diag_begin in line:
-                    inside_long_diag = True
-
 errors = False
 all_errors = []
 

branches/tmp/src/liballoc/boxed.rs

@@ -71,7 +71,7 @@ use core::raw::{TraitObject};
 /// The following two examples are equivalent:
 ///
 /// ```
-/// # #![feature(box_heap)]
+/// #![feature(box_heap)]
 /// #![feature(box_syntax)]
 /// use std::boxed::HEAP;
 ///
@@ -162,7 +162,7 @@ impl<T : ?Sized> Box<T> {
 ///
 /// # Examples
 /// ```
-/// # #![feature(box_raw)]
+/// #![feature(box_raw)]
 /// use std::boxed;
 ///
 /// let seventeen = Box::new(17u32);

branches/tmp/src/libcollections/str.rs

@@ -550,14 +550,6 @@ impl str {
         core_str::StrExt::slice_unchecked(self, begin, end)
     }
 
-    /// Takes a bytewise mutable slice from a string.
-    ///
-    /// Same as `slice_unchecked`, but works with `&mut str` instead of `&str`.
-    #[unstable(feature = "str_slice_mut", reason = "recently added")]
-    pub unsafe fn slice_mut_unchecked(&mut self, begin: usize, end: usize) -> &mut str {
-        core_str::StrExt::slice_mut_unchecked(self, begin, end)
-    }
-
     /// Returns a slice of the string from the character range [`begin`..`end`).
     ///
     /// That is, start at the `begin`-th code point of the string and continue
@@ -784,7 +776,7 @@ impl str {
     ///
     /// # Examples
     /// ```
-    /// # #![feature(str_split_at)]
+    /// # #![feature(collections)]
     /// let s = "Löwe 老虎 Léopard";
     /// let first_space = s.find(' ').unwrap_or(s.len());
     /// let (a, b) = s.split_at(first_space);
@@ -793,18 +785,10 @@ impl str {
     /// assert_eq!(b, " 老虎 Léopard");
     /// ```
     #[inline]
-    #[unstable(feature = "str_split_at", reason = "recently added")]
     pub fn split_at(&self, mid: usize) -> (&str, &str) {
         core_str::StrExt::split_at(self, mid)
     }
 
-    /// Divide one mutable string slice into two at an index.
-    #[inline]
-    #[unstable(feature = "str_split_at", reason = "recently added")]
-    pub fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str) {
-        core_str::StrExt::split_at_mut(self, mid)
-    }
-
     /// An iterator over the codepoints of `self`.
     ///
     /// # Examples

branches/tmp/src/libcollections/string.rs

@@ -979,38 +979,6 @@ impl ops::Index<ops::RangeFull> for String {
     }
 }
 
-#[cfg(not(stage0))]
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::IndexMut<ops::Range<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[cfg(not(stage0))]
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::IndexMut<ops::RangeTo<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[cfg(not(stage0))]
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::IndexMut<ops::RangeFrom<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::IndexMut<ops::RangeFull> for String {
-    #[inline]
-    fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str {
-        unsafe { mem::transmute(&mut *self.vec) }
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl ops::Deref for String {
     type Target = str;
@@ -1021,14 +989,6 @@ impl ops::Deref for String {
     }
 }
 
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::DerefMut for String {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut str {
-        unsafe { mem::transmute(&mut self.vec[..]) }
-    }
-}
-
 /// Wrapper type providing a `&String` reference via `Deref`.
 #[unstable(feature = "collections")]
 #[deprecated(since = "1.2.0",

branches/tmp/src/libcollectionstest/lib.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(ascii)]
 #![feature(append)]
 #![feature(bitset)]
 #![feature(bitvec)]
@@ -44,7 +43,6 @@
 #![feature(str_char)]
 #![feature(str_escape)]
 #![feature(str_match_indices)]
-#![feature(str_split_at)]
 #![feature(str_utf16)]
 #![feature(box_str)]
 #![feature(subslice_offset)]

branches/tmp/src/libcollectionstest/str.rs

@@ -701,18 +701,6 @@ fn test_split_at() {
     assert_eq!(b, "");
 }
 
-#[test]
-fn test_split_at_mut() {
-    use std::ascii::AsciiExt;
-    let mut s = "Hello World".to_string();
-    {
-        let (a, b) = s.split_at_mut(5);
-        a.make_ascii_uppercase();
-        b.make_ascii_lowercase();
-    }
-    assert_eq!(s, "HELLO world");
-}
-
 #[test]
 #[should_panic]
 fn test_split_at_boundscheck() {