---

yaml
---
r: 273499
b: refs/heads/beta
c: ca609cc
h: refs/heads/master
i:
  273497: 27850d1
  273495: 8ad77d6

Author: GuillaumeGomez

[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: 7a38ac8e874d5f22a3a103acde9ef84268ec9388
+refs/heads/beta: ca609cc6743df537a287e7b4fe9833f2f8342047
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/configure

@@ -1034,7 +1034,7 @@ then
         if [ -n "$CFG_OSX_CLANG_VERSION" ]
         then
             case $CFG_OSX_CLANG_VERSION in
-                (7.0* | 7.1* | 7.2* | 7.3*)
+                (7.0* | 7.1* | 7.2*)
                 step_msg "found ok version of APPLE CLANG: $CFG_OSX_CLANG_VERSION"
                 ;;
                 (*)

branches/beta/src/compiletest/compiletest.rs

@@ -15,7 +15,6 @@
 #![feature(rustc_private)]
 #![feature(str_char)]
 #![feature(test)]
-#![feature(question_mark)]
 
 #![deny(warnings)]
 
@@ -281,16 +280,16 @@ fn collect_tests_from_dir(config: &Config,
                           -> io::Result<()> {
     // Ignore directories that contain a file
     // `compiletest-ignore-dir`.
-    for file in fs::read_dir(dir)? {
-        let file = file?;
+    for file in try!(fs::read_dir(dir)) {
+        let file = try!(file);
         if file.file_name() == *"compiletest-ignore-dir" {
             return Ok(());
         }
     }
 
-    let dirs = fs::read_dir(dir)?;
+    let dirs = try!(fs::read_dir(dir));
     for file in dirs {
-        let file = file?;
+        let file = try!(file);
         let file_path = file.path();
         debug!("inspecting file {:?}", file_path.display());
         if is_test(config, &file_path) {
@@ -311,11 +310,11 @@ fn collect_tests_from_dir(config: &Config,
             tests.push(make_test(config, &paths))
         } else if file_path.is_dir() {
             let relative_file_path = relative_dir_path.join(file.file_name());
-            collect_tests_from_dir(config,
-                                   base,
-                                   &file_path,
-                                   &relative_file_path,
-                                   tests)?;
+            try!(collect_tests_from_dir(config,
+                                        base,
+                                        &file_path,
+                                        &relative_file_path,
+                                        tests));
         }
     }
     Ok(())

branches/beta/src/doc/book/lifetimes.md

@@ -282,12 +282,14 @@ to it.
 
 ## Lifetime Elision
 
-Rust supports powerful local type inference in the bodies of functions but not in their item signatures. 
-It's forbidden to allow reasoning about types based on the item signature alone. 
-However, for ergonomic reasons, a very restricted secondary inference algorithm called 
-“lifetime elision” does apply when judging lifetimes. Lifetime elision is concerned solely to infer 
-lifetime parameters using three easily memorizable and unambiguous rules. This means lifetime elision 
-acts as a shorthand for writing an item signature, while not hiding
+Rust supports powerful local type inference in function bodies, but it’s
+forbidden in item signatures to allow reasoning about the types based on
+the item signature alone. However, for ergonomic reasons a very restricted
+secondary inference algorithm called “lifetime elision” applies in function
+signatures. It infers only based on the signature components themselves and not
+based on the body of the function, only infers lifetime parameters, and does
+this with only three easily memorizable and unambiguous rules. This makes
+lifetime elision a shorthand for writing an item signature, while not hiding
 away the actual types involved as full local inference would if applied to it.
 
 When talking about lifetime elision, we use the term *input lifetime* and

branches/beta/src/doc/book/patterns.md

@@ -1,7 +1,7 @@
 % Patterns
 
 Patterns are quite common in Rust. We use them in [variable
-bindings][bindings], [match expressions][match], and other places, too. Let’s go
+bindings][bindings], [match statements][match], and other places, too. Let’s go
 on a whirlwind tour of all of the things patterns can do!
 
 [bindings]: variable-bindings.html

branches/beta/src/doc/reference.md

@@ -1905,8 +1905,6 @@ type int8_t = i8;
 - `should_panic` - indicates that this test function should panic, inverting the success condition.
 - `cold` - The function is unlikely to be executed, so optimize it (and calls
   to it) differently.
-- `naked` - The function utilizes a custom ABI or custom inline ASM that requires
-  epilogue and prologue to be skipped.
 
 ### Static-only attributes
 

branches/beta/src/libcore/clone.rs

@@ -18,29 +18,6 @@
 //! them cheap and safe to copy. For other types copies must be made
 //! explicitly, by convention implementing the `Clone` trait and calling
 //! the `clone` method.
-//!
-//! Basic usage example:
-//!
-//! ```
-//! let s = String::new(); // String type implements Clone
-//! let copy = s.clone(); // so we can clone it
-//! ```
-//!
-//! To easily implement the Clone trait, you can also use
-//! `#[derive(Clone)]`. Example:
-//!
-//! ```
-//! #[derive(Clone)] // we add the Clone trait to Morpheus struct
-//! struct Morpheus {
-//!    blue_pill: f32,
-//!    red_pill: i64,
-//! }
-//!
-//! fn main() {
-//!    let f = Morpheus { blue_pill: 0.0, red_pill: 0 };
-//!    let copy = f.clone(); // and now we can clone it!
-//! }
-//! ```
 
 #![stable(feature = "rust1", since = "1.0.0")]
 

branches/beta/src/libcore/fmt/builders.rs

@@ -29,7 +29,7 @@ impl<'a, 'b: 'a> fmt::Write for PadAdapter<'a, 'b> {
     fn write_str(&mut self, mut s: &str) -> fmt::Result {
         while !s.is_empty() {
             if self.on_newline {
-                self.fmt.write_str("    ")?;
+                try!(self.fmt.write_str("    "));
             }
 
             let split = match s.find('\n') {
@@ -42,7 +42,7 @@ impl<'a, 'b: 'a> fmt::Write for PadAdapter<'a, 'b> {
                     s.len()
                 }
             };
-            self.fmt.write_str(&s[..split])?;
+            try!(self.fmt.write_str(&s[..split]));
             s = &s[split..];
         }
 
@@ -169,10 +169,10 @@ impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
         if self.fields > 0 {
             self.result = self.result.and_then(|_| {
                 if self.is_pretty() {
-                    self.fmt.write_str("\n")?;
+                    try!(self.fmt.write_str("\n"));
                 }
                 if self.fields == 1 && self.empty_name {
-                    self.fmt.write_str(",")?;
+                    try!(self.fmt.write_str(","));
                 }
                 self.fmt.write_str(")")
             });

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

@@ -795,24 +795,24 @@ pub fn write(output: &mut Write, args: Arguments) -> Result {
         None => {
             // We can use default formatting parameters for all arguments.
             for (arg, piece) in args.args.iter().zip(pieces.by_ref()) {
-                formatter.buf.write_str(*piece)?;
-                (arg.formatter)(arg.value, &mut formatter)?;
+                try!(formatter.buf.write_str(*piece));
+                try!((arg.formatter)(arg.value, &mut formatter));
             }
         }
         Some(fmt) => {
             // Every spec has a corresponding argument that is preceded by
             // a string piece.
             for (arg, piece) in fmt.iter().zip(pieces.by_ref()) {
-                formatter.buf.write_str(*piece)?;
-                formatter.run(arg)?;
+                try!(formatter.buf.write_str(*piece));
+                try!(formatter.run(arg));
             }
         }
     }
 
     // There can be only one trailing string piece left.
     match pieces.next() {
         Some(piece) => {
-            formatter.buf.write_str(*piece)?;
+            try!(formatter.buf.write_str(*piece));
         }
         None => {}
     }
@@ -897,9 +897,9 @@ impl<'a> Formatter<'a> {
         // Writes the sign if it exists, and then the prefix if it was requested
         let write_prefix = |f: &mut Formatter| {
             if let Some(c) = sign {
-                f.buf.write_str(unsafe {
+                try!(f.buf.write_str(unsafe {
                     str::from_utf8_unchecked(c.encode_utf8().as_slice())
-                })?;
+                }));
             }
             if prefixed { f.buf.write_str(prefix) }
             else { Ok(()) }
@@ -910,26 +910,26 @@ impl<'a> Formatter<'a> {
             // If there's no minimum length requirements then we can just
             // write the bytes.
             None => {
-                write_prefix(self)?; self.buf.write_str(buf)
+                try!(write_prefix(self)); self.buf.write_str(buf)
             }
             // Check if we're over the minimum width, if so then we can also
             // just write the bytes.
             Some(min) if width >= min => {
-                write_prefix(self)?; self.buf.write_str(buf)
+                try!(write_prefix(self)); self.buf.write_str(buf)
             }
             // The sign and prefix goes before the padding if the fill character
             // is zero
             Some(min) if self.sign_aware_zero_pad() => {
                 self.fill = '0';
-                write_prefix(self)?;
+                try!(write_prefix(self));
                 self.with_padding(min - width, rt::v1::Alignment::Right, |f| {
                     f.buf.write_str(buf)
                 })
             }
             // Otherwise, the sign and prefix goes after the padding
             Some(min) => {
                 self.with_padding(min - width, rt::v1::Alignment::Right, |f| {
-                    write_prefix(f)?; f.buf.write_str(buf)
+                    try!(write_prefix(f)); f.buf.write_str(buf)
                 })
             }
         }
@@ -1008,13 +1008,13 @@ impl<'a> Formatter<'a> {
         };
 
         for _ in 0..pre_pad {
-            self.buf.write_str(fill)?;
+            try!(self.buf.write_str(fill));
         }
 
-        f(self)?;
+        try!(f(self));
 
         for _ in 0..post_pad {
-            self.buf.write_str(fill)?;
+            try!(self.buf.write_str(fill));
         }
 
         Ok(())
@@ -1033,7 +1033,7 @@ impl<'a> Formatter<'a> {
             if self.sign_aware_zero_pad() {
                 // a sign always goes first
                 let sign = unsafe { str::from_utf8_unchecked(formatted.sign) };
-                self.buf.write_str(sign)?;
+                try!(self.buf.write_str(sign));
 
                 // remove the sign from the formatted parts
                 formatted.sign = b"";
@@ -1065,19 +1065,19 @@ impl<'a> Formatter<'a> {
         }
 
         if !formatted.sign.is_empty() {
-            write_bytes(self.buf, formatted.sign)?;
+            try!(write_bytes(self.buf, formatted.sign));
         }
         for part in formatted.parts {
             match *part {
                 flt2dec::Part::Zero(mut nzeroes) => {
                     const ZEROES: &'static str = // 64 zeroes
                         "0000000000000000000000000000000000000000000000000000000000000000";
                     while nzeroes > ZEROES.len() {
-                        self.buf.write_str(ZEROES)?;
+                        try!(self.buf.write_str(ZEROES));
                         nzeroes -= ZEROES.len();
                     }
                     if nzeroes > 0 {
-                        self.buf.write_str(&ZEROES[..nzeroes])?;
+                        try!(self.buf.write_str(&ZEROES[..nzeroes]));
                     }
                 }
                 flt2dec::Part::Num(mut v) => {
@@ -1087,10 +1087,10 @@ impl<'a> Formatter<'a> {
                         *c = b'0' + (v % 10) as u8;
                         v /= 10;
                     }
-                    write_bytes(self.buf, &s[..len])?;
+                    try!(write_bytes(self.buf, &s[..len]));
                 }
                 flt2dec::Part::Copy(buf) => {
-                    write_bytes(self.buf, buf)?;
+                    try!(write_bytes(self.buf, buf));
                 }
             }
         }
@@ -1349,20 +1349,20 @@ impl Display for bool {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Debug for str {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        f.write_char('"')?;
+        try!(f.write_char('"'));
         let mut from = 0;
         for (i, c) in self.char_indices() {
             let esc = c.escape_default();
             // If char needs escaping, flush backlog so far and write, else skip
             if esc.size_hint() != (1, Some(1)) {
-                f.write_str(&self[from..i])?;
+                try!(f.write_str(&self[from..i]));
                 for c in esc {
-                    f.write_char(c)?;
+                    try!(f.write_char(c));
                 }
                 from = i + c.len_utf8();
             }
         }
-        f.write_str(&self[from..])?;
+        try!(f.write_str(&self[from..]));
         f.write_char('"')
     }
 }
@@ -1377,9 +1377,9 @@ impl Display for str {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Debug for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        f.write_char('\'')?;
+        try!(f.write_char('\''));
         for c in self.escape_default() {
-            f.write_char(c)?
+            try!(f.write_char(c))
         }
         f.write_char('\'')
     }

branches/beta/src/libcore/lib.rs

@@ -77,7 +77,6 @@
 #![feature(rustc_attrs)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
-#![feature(question_mark)]
 
 #[macro_use]
 mod macros;

branches/beta/src/libcore/num/dec2flt/mod.rs

@@ -214,7 +214,7 @@ fn dec2flt<T: RawFloat>(s: &str) -> Result<T, ParseFloatError> {
     }
     let (sign, s) = extract_sign(s);
     let flt = match parse_decimal(s) {
-        ParseResult::Valid(decimal) => convert(decimal)?,
+        ParseResult::Valid(decimal) => try!(convert(decimal)),
         ParseResult::ShortcutToInf => T::infinity(),
         ParseResult::ShortcutToZero => T::zero(),
         ParseResult::Invalid => match s {

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

@@ -240,7 +240,7 @@ impl Utf8Error {
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
-    run_utf8_validation(v)?;
+    try!(run_utf8_validation(v));
     Ok(unsafe { from_utf8_unchecked(v) })
 }