---

yaml
---
r: 273497
b: refs/heads/beta
c: b3aa35e
h: refs/heads/master
i:
  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: 87aee45988e81cb1a7bc9881aa7172d4f9caefd4
+refs/heads/beta: b3aa35e756c4d1c0d015a502b2e5b854752c99e7
 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/mk/crates.mk

@@ -97,7 +97,7 @@ DEPS_rustc := syntax fmt_macros flate arena serialize getopts rbml rustc_front\
               log graphviz rustc_llvm rustc_back rustc_data_structures\
 		  	  rustc_const_eval
 DEPS_rustc_back := std syntax rustc_llvm rustc_front flate log libc
-DEPS_rustc_borrowck := rustc rustc_front rustc_mir log graphviz syntax
+DEPS_rustc_borrowck := rustc rustc_front log graphviz syntax
 DEPS_rustc_data_structures := std log serialize
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
                      rustc_typeck rustc_mir rustc_resolve log syntax serialize rustc_llvm \

branches/beta/src/bootstrap/build/check.rs

@@ -16,11 +16,3 @@ pub fn linkcheck(build: &Build, stage: u32, host: &str) {
     build.run(build.tool_cmd(&compiler, "linkchecker")
                    .arg(build.out.join(host).join("doc")));
 }
-
-pub fn cargotest(build: &Build, stage: u32, host: &str) {
-    let ref compiler = Compiler::new(stage, host);
-    build.run(build.tool_cmd(compiler, "cargotest")
-              .env("RUSTC", build.compiler_path(compiler))
-              .env("RUSTDOC", build.rustdoc(compiler))
-              .arg(&build.cargo));
-}

branches/beta/src/bootstrap/build/mod.rs

@@ -183,9 +183,6 @@ impl Build {
                     compile::tool(self, stage, target.target,
                                   "error_index_generator");
                 }
-                ToolCargoTest { stage } => {
-                    compile::tool(self, stage, target.target, "cargotest");
-                }
                 DocBook { stage } => {
                     doc::rustbook(self, stage, target.target, "book", &doc_out);
                 }
@@ -213,9 +210,6 @@ impl Build {
                 CheckLinkcheck { stage } => {
                     check::linkcheck(self, stage, target.target);
                 }
-                CheckCargoTest { stage } => {
-                    check::cargotest(self, stage, target.target);
-                }
 
                 DistDocs { stage } => dist::docs(self, stage, target.target),
                 DistMingw { _dummy } => dist::mingw(self, target.target),

branches/beta/src/bootstrap/build/step.rs

@@ -47,7 +47,6 @@ macro_rules! targets {
             (tool_linkchecker, ToolLinkchecker { stage: u32 }),
             (tool_rustbook, ToolRustbook { stage: u32 }),
             (tool_error_index, ToolErrorIndex { stage: u32 }),
-            (tool_cargotest, ToolCargoTest { stage: u32 }),
 
             // Steps for long-running native builds. Ideally these wouldn't
             // actually exist and would be part of build scripts, but for now
@@ -74,7 +73,6 @@ macro_rules! targets {
             // target to depend on a bunch of others.
             (check, Check { stage: u32, compiler: Compiler<'a> }),
             (check_linkcheck, CheckLinkcheck { stage: u32 }),
-            (check_cargotest, CheckCargoTest { stage: u32 }),
 
             // Distribution targets, creating tarballs
             (dist, Dist { stage: u32 }),
@@ -294,9 +292,6 @@ impl<'a> Step<'a> {
             Source::CheckLinkcheck { stage } => {
                 vec![self.tool_linkchecker(stage), self.doc(stage)]
             }
-            Source::CheckCargoTest { stage } => {
-                vec![self.tool_cargotest(stage)]
-            }
 
             Source::ToolLinkchecker { stage } => {
                 vec![self.libstd(self.compiler(stage))]
@@ -305,9 +300,6 @@ impl<'a> Step<'a> {
             Source::ToolRustbook { stage } => {
                 vec![self.librustc(self.compiler(stage))]
             }
-            Source::ToolCargoTest { stage } => {
-                vec![self.libstd(self.compiler(stage))]
-            }
 
             Source::DistDocs { stage } => vec![self.doc(stage)],
             Source::DistMingw { _dummy: _ } => Vec::new(),

branches/beta/src/bootstrap/mk/Makefile.in

@@ -38,8 +38,6 @@ standalone-docs:
 	$(Q)$(BOOTSTRAP) --step doc-standalone
 check:
 	$(Q)$(BOOTSTRAP) --step check
-cargotest:
-	$(Q)$(BOOTSTRAP) --step cargotest
 dist:
 	$(Q)$(BOOTSTRAP) --step dist
 

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/compiletest/errors.rs

@@ -9,54 +9,14 @@
 // except according to those terms.
 use self::WhichLine::*;
 
-use std::fmt;
 use std::fs::File;
 use std::io::BufReader;
 use std::io::prelude::*;
 use std::path::Path;
-use std::str::FromStr;
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum ErrorKind {
-    Help,
-    Error,
-    Note,
-    Suggestion,
-    Warning,
-}
-
-impl FromStr for ErrorKind {
-    type Err = ();
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match &s.trim_right_matches(':') as &str {
-            "HELP" => Ok(ErrorKind::Help),
-            "ERROR" => Ok(ErrorKind::Error),
-            "NOTE" => Ok(ErrorKind::Note),
-            "SUGGESTION" => Ok(ErrorKind::Suggestion),
-            "WARN" => Ok(ErrorKind::Warning),
-            "WARNING" => Ok(ErrorKind::Warning),
-            _ => Err(()),
-        }
-    }
-}
-
-impl fmt::Display for ErrorKind {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ErrorKind::Help => write!(f, "help"),
-            ErrorKind::Error => write!(f, "error"),
-            ErrorKind::Note => write!(f, "note"),
-            ErrorKind::Suggestion => write!(f, "suggestion"),
-            ErrorKind::Warning => write!(f, "warning"),
-        }
-    }
-}
 
 pub struct ExpectedError {
     pub line_num: usize,
-    /// What kind of message we expect (e.g. warning, error, suggestion).
-    /// `None` if not specified or unknown message kind.
-    pub kind: Option<ErrorKind>,
+    pub kind: String,
     pub msg: String,
 }
 
@@ -121,11 +81,11 @@ fn parse_expected(last_nonfollow_error: Option<usize>,
         (false, line[start + tag.len()..].chars().take_while(|c| *c == '^').count())
     };
     let kind_start = start + tag.len() + adjusts + (follow as usize);
-    let kind = line[kind_start..].split_whitespace()
-                                 .next()
-                                 .expect("Encountered unexpected empty comment")
-                                 .parse::<ErrorKind>()
-                                 .ok();
+    let letters = line[kind_start..].chars();
+    let kind = letters.skip_while(|c| c.is_whitespace())
+                      .take_while(|c| !c.is_whitespace())
+                      .flat_map(|c| c.to_lowercase())
+                      .collect::<String>();
     let letters = line[kind_start..].chars();
     let msg = letters.skip_while(|c| c.is_whitespace())
                      .skip_while(|c| !c.is_whitespace())

branches/beta/src/compiletest/runtest.rs

@@ -11,7 +11,7 @@
 use common::Config;
 use common::{CompileFail, ParseFail, Pretty, RunFail, RunPass, RunPassValgrind};
 use common::{Codegen, DebugInfoLldb, DebugInfoGdb, Rustdoc, CodegenUnits};
-use errors::{self, ErrorKind};
+use errors;
 use header::TestProps;
 use header;
 use procsrv;
@@ -1033,8 +1033,8 @@ fn check_expected_errors(revision: Option<&str>,
         expected_errors.iter()
                         .fold((false, false),
                               |(acc_help, acc_note), ee|
-                                  (acc_help || ee.kind == Some(ErrorKind::Help),
-                                   acc_note || ee.kind == Some(ErrorKind::Note)));
+                                  (acc_help || ee.kind == "help:" || ee.kind == "help",
+                                   acc_note || ee.kind == "note:" || ee.kind == "note"));
 
     // Scan and extract our error/warning messages,
     // which look like:
@@ -1052,15 +1052,15 @@ fn check_expected_errors(revision: Option<&str>,
         let mut prev = 0;
         for (i, ee) in expected_errors.iter().enumerate() {
             if !found_flags[i] {
-                debug!("prefix={} ee.kind={:?} ee.msg={} line={}",
+                debug!("prefix={} ee.kind={} ee.msg={} line={}",
                        prefixes[i],
                        ee.kind,
                        ee.msg,
                        line);
                 // Suggestions have no line number in their output, so take on the line number of
                 // the previous expected error
-                if ee.kind == Some(ErrorKind::Suggestion) {
-                    assert!(expected_errors[prev].kind == Some(ErrorKind::Help),
+                if ee.kind == "suggestion" {
+                    assert!(expected_errors[prev].kind == "help",
                             "SUGGESTIONs must be preceded by a HELP");
                     if line.contains(&ee.msg) {
                         found_flags[i] = true;
@@ -1070,7 +1070,7 @@ fn check_expected_errors(revision: Option<&str>,
                 }
                 if
                     (prefix_matches(line, &prefixes[i]) || continuation(line)) &&
-                    (ee.kind.is_none() || line.contains(&ee.kind.as_ref().unwrap().to_string())) &&
+                    line.contains(&ee.kind) &&
                     line.contains(&ee.msg)
                 {
                     found_flags[i] = true;
@@ -1096,10 +1096,7 @@ fn check_expected_errors(revision: Option<&str>,
         if !flag {
             let ee = &expected_errors[i];
             error(revision, &format!("expected {} on line {} not found: {}",
-                                     ee.kind.as_ref()
-                                            .map_or("message".into(),
-                                                    |k| k.to_string()),
-                                     ee.line_num, ee.msg));
+                                     ee.kind, ee.line_num, ee.msg));
             not_found += 1;
         }
     }

branches/beta/src/doc/book/error-handling.md

@@ -2019,16 +2019,6 @@ impl Error for CliError {
             CliError::NotFound => "not found",
         }
     }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {            
-            CliError::Io(ref err) => Some(err),
-            CliError::Parse(ref err) => Some(err),
-            // Our custom error doesn't have an underlying cause, but we could
-            // modify it so that it does.
-            CliError::NotFound() => None,
-        }
-    }
 }
 ```
 

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/match.md

@@ -36,10 +36,10 @@ give us an error:
 error: non-exhaustive patterns: `_` not covered
 ```
 
-Rust is telling us that we forgot some value. The compiler infers from `x` that it
-can have any 32bit integer value; for example -2,147,483,648 to 2,147,483,647. The `_` acts 
+Rust is telling us that we forgot a value. The compiler infers from `x` that it
+can have any positive 32bit value; for example 1 to 2,147,483,647. The `_` acts 
 as a 'catch-all', and will catch all possible values that *aren't* specified in 
-an arm of `match`. As you can see in the previous example, we provide `match` 
+an arm of `match`. As you can see with the previous example, we provide `match` 
 arms for integers 1-5, if `x` is 6 or any other value, then it is caught by `_`.
 
 `match` is also an expression, which means we can use it on the right-hand

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/book/primitive-types.md

@@ -7,7 +7,7 @@ of these ones, as well, but these are the most primitive.
 
 # Booleans
 
-Rust has a built-in boolean type, named `bool`. It has two values, `true` and `false`:
+Rust has a built in boolean type, named `bool`. It has two values, `true` and `false`:
 
 ```rust
 let x = true;
@@ -89,13 +89,13 @@ Unsigned types use a `u` for their category, and signed types use `i`. The `i`
 is for ‘integer’. So `u8` is an eight-bit unsigned number, and `i8` is an
 eight-bit signed number.
 
-## Fixed-size types
+## Fixed size types
 
-Fixed-size types have a specific number of bits in their representation. Valid
+Fixed size types have a specific number of bits in their representation. Valid
 bit sizes are `8`, `16`, `32`, and `64`. So, `u32` is an unsigned, 32-bit integer,
 and `i64` is a signed, 64-bit integer.
 
-## Variable-size types
+## Variable sized types
 
 Rust also provides types whose size depends on the size of a pointer of the
 underlying machine. These types have ‘size’ as the category, and come in signed

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

@@ -212,7 +212,7 @@ fn main() {
 
 In other words, the mutable borrow is held through the rest of our example. What
 we want is for the mutable borrow by `y` to end so that the resource can be
-returned to the owner, `x`. `x` can then provide a immutable borrow to `println!`.
+returned to the owner, `x`. `x` can then provide a mutable borrow to `println!`.
 In Rust, borrowing is tied to the scope that the borrow is valid for. And our
 scopes look like this:
 

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