---

yaml
---
r: 172507
b: refs/heads/auto
c: 6773651
h: refs/heads/master
i:
  172505: b23b7c0
  172503: 08630f1
v: v3

Author: bors

[refs]

@@ -10,7 +10,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: 8af47508e9dcc9537468989ccf7f656024ead176
+refs/heads/auto: 67736510aed0090f7bed69dbe6218a3d6b45e491
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/header.rs

@@ -42,8 +42,6 @@ pub struct TestProps {
     pub pretty_compare_only: bool,
     // Patterns which must not appear in the output of a cfail test.
     pub forbid_output: Vec<String>,
-    // Ignore errors which originate from a command line span
-    pub ignore_command_line: bool,
 }
 
 // Load any test directives embedded in the file
@@ -62,8 +60,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut pretty_mode = None;
     let mut pretty_compare_only = false;
     let mut forbid_output = Vec::new();
-    let mut ignore_command_line = false;
-
     iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
@@ -106,10 +102,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
             pretty_compare_only = parse_pretty_compare_only(ln);
         }
 
-        if !ignore_command_line {
-            ignore_command_line = parse_ignore_command_line(ln);
-        }
-
         match parse_aux_build(ln) {
             Some(ab) => { aux_builds.push(ab); }
             None => {}
@@ -148,7 +140,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
         pretty_mode: pretty_mode.unwrap_or("normal".to_string()),
         pretty_compare_only: pretty_compare_only,
         forbid_output: forbid_output,
-        ignore_command_line: ignore_command_line,
     }
 }
 
@@ -300,10 +291,6 @@ fn parse_pretty_compare_only(line: &str) -> bool {
     parse_name_directive(line, "pretty-compare-only")
 }
 
-fn parse_ignore_command_line(line: &str) -> bool {
-    parse_name_directive(line, "ignore-command-line")
-}
-
 fn parse_exec_env(line: &str) -> Option<(String, String)> {
     parse_name_value_directive(line, "exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR

branches/auto/src/compiletest/runtest.rs

@@ -104,7 +104,7 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
         if !props.error_patterns.is_empty() {
             fatal("both error pattern and expected errors specified");
         }
-        check_expected_errors(props, expected_errors, testfile, &proc_res);
+        check_expected_errors(expected_errors, testfile, &proc_res);
     } else {
         check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
     }
@@ -941,8 +941,7 @@ fn check_forbid_output(props: &TestProps,
     }
 }
 
-fn check_expected_errors(props: &TestProps,
-                         expected_errors: Vec<errors::ExpectedError> ,
+fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
                          testfile: &Path,
                          proc_res: &ProcRes) {
 
@@ -997,11 +996,6 @@ fn check_expected_errors(props: &TestProps,
             was_expected = true;
         }
 
-        if line.starts_with("<command line option>") &&
-           props.ignore_command_line {
-            was_expected = true;
-        }
-
         if !was_expected && is_compiler_error_or_warning(line) {
             fatal_proc_rec(format!("unexpected compiler error or warning: '{}'",
                                   line).as_slice(),

branches/auto/src/doc/intro.md

@@ -106,9 +106,9 @@ use semver::Version;
 
 fn main() {
     assert!(Version::parse("1.2.3") == Ok(Version {
-        major: 1u,
-        minor: 2u,
-        patch: 3u,
+        major: 1u64,
+        minor: 2u64,
+        patch: 3u64,
         pre: vec!(),
         build: vec!(),
     }));

branches/auto/src/doc/reference.md

@@ -2921,13 +2921,13 @@ automatically dereferenced to make the field access possible.
 ```{.ebnf .gram}
 array_expr : '[' "mut" ? vec_elems? ']' ;
 
-array_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
+array_elems : [expr [',' expr]*] | [expr ';' expr] ;
 ```
 
 An [array](#array,-and-slice-types) _expression_ is written by enclosing zero
 or more comma-separated expressions of uniform type in square brackets.
 
-In the `[expr ',' ".." expr]` form, the expression after the `".."` must be a
+In the `[expr ';' expr]` form, the expression after the `';'` must be a
 constant expression that can be evaluated at compile time, such as a
 [literal](#literals) or a [static item](#static-items).
 

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

@@ -11,7 +11,7 @@ navigate through the menu on the left.
 ## Basics
 
 This section is a linear introduction to the basic syntax and semantics of
-Rust. It has individual sections on each part of Rust's syntax, and cumulates
+Rust. It has individual sections on each part of Rust's syntax, and culminates
 in a small project: a guessing game.
 
 After reading "Basics," you will have a good foundation to learn more about
@@ -27,7 +27,7 @@ and will be able to understand most Rust code and write more complex programs.
 
 ## Advanced
 
-In a similar fashion to "Intermediate," this setion is full of individual,
+In a similar fashion to "Intermediate," this section is full of individual,
 deep-dive chapters, which stand alone and can be read in any order. These
 chapters focus on the most complex features, as well as some things that
 are only available in upcoming versions of Rust.

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

@@ -1,6 +1,6 @@
 % Advanced
 
-In a similar fashion to "Intermediate," this setion is full of individual,
+In a similar fashion to "Intermediate," this section is full of individual,
 deep-dive chapters, which stand alone and can be read in any order. These
 chapters focus on the most complex features, as well as some things that
 are only available in upcoming versions of Rust.

branches/auto/src/doc/trpl/arrays-vectors-and-slices.md

@@ -94,6 +94,6 @@ backed by arrays. Slices have type `&[T]`, which we'll talk about when we cover
 generics.
 
 We have now learned all of the most basic Rust concepts. We're ready to start
-building our guessing game, we just need to know one last thing: how to get
-input from the keyboard. You can't have a guessing game without the ability to
-guess!
+building ourselves a guessing game, we just need to know one last thing: how to
+get input from the keyboard. You can't have a guessing game without the ability
+to guess!

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

@@ -110,25 +110,27 @@ passing two variables: one is an i32, and one is a function."
 Next, let's look at how `twice` is defined:
 
 ```{rust,ignore}
-fn twice(x: i32, f: |i32| -> i32) -> i32 {
+fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 {
 ```
 
 `twice` takes two arguments, `x` and `f`. That's why we called it with two
 arguments. `x` is an `i32`, we've done that a ton of times. `f` is a function,
-though, and that function takes an `i32` and returns an `i32`. Notice
-how the `|i32| -> i32` syntax looks a lot like our definition of `square`
-above, if we added the return type in:
-
-```{rust}
-let square = |&: x: i32| -> i32 { x * x };
-//           |i32|       -> i32
-```
-
-This function takes an `i32` and returns an `i32`.
+though, and that function takes an `i32` and returns an `i32`. This is
+what the requirement `Fn(i32) -> i32` for the type parameter `F` says.
+You might ask yourself: why do we need to introduce a type parameter here?
+That is because in Rust each closure has its own unique type.
+So, not only do closures with different signatures have different types,
+but different closures with the *same* signature have *different* types!
+You can think of it this way: the behaviour of a closure is part of its type.
+And since we want to support many different closures that all take
+an `i32` and return an `i32` we introduced a type parameter that is able
+to represent all these closures. 
 
 This is the most complicated function signature we've seen yet! Give it a read
 a few times until you can see how it works. It takes a teeny bit of practice, and
-then it's easy.
+then it's easy. The good news is that this kind of passing a closure around
+can be very efficient. With all the type information available at compile-time
+the compiler can do wonders.
 
 Finally, `twice` returns an `i32` as well.
 

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

@@ -40,7 +40,8 @@ fn hello(name: &str) {
 ```
 
 When writing doc comments, adding sections for any arguments, return values,
-and providing some examples of usage is very, very helpful.
+and providing some examples of usage is very, very helpful. Don't worry about
+the `&str`, we'll get to it soon.
 
 You can use the [`rustdoc`](../rustdoc.html) tool to generate HTML documentation
 from these doc comments.

branches/auto/src/doc/trpl/compound-data-types.md

@@ -23,10 +23,10 @@ let x: (i32, &str) = (1, "hello");
 As you can see, the type of a tuple looks just like the tuple, but with each
 position having a type name rather than the value. Careful readers will also
 note that tuples are heterogeneous: we have an `i32` and a `&str` in this tuple.
-You haven't seen `&str` as a type before, and we'll discuss the details of
-strings later. In systems programming languages, strings are a bit more complex
-than in other languages. For now, just read `&str` as a *string slice*, and
-we'll learn more soon.
+You have briefly seen `&str` used as a type before, and we'll discuss the
+details of strings later. In systems programming languages, strings are a bit
+more complex than in other languages. For now, just read `&str` as a *string
+slice*, and we'll learn more soon.
 
 You can access the fields in a tuple through a *destructuring let*. Here's
 an example:

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

@@ -1,10 +1,11 @@
 % Conclusion
 
 We covered a lot of ground here. When you've mastered everything in this Guide,
-you will have a firm grasp of basic Rust development. There's a whole lot more
-out there, we've just covered the surface. There's tons of topics that you can
-dig deeper into, and we've built specialized guides for many of them. To learn
-more, dig into the [full documentation
-index](index.html).
+you will have a firm grasp of Rust development. There's a whole lot more
+out there, though, we've just covered the surface. There's tons of topics that
+you can dig deeper into, e.g. by reading the API documentation of the
+[standard library](http://doc.rust-lang.org/std/), by discovering solutions for
+common problems on [Rust by Example](http://rustbyexample.com/), or by browsing
+crates written by the community on [crates.io](https://crates.io/).
 
 Happy hacking!

branches/auto/src/doc/trpl/error-handling.md

@@ -1,6 +1,6 @@
 % Error Handling in Rust
 
-> The best-laid plans of mice and men
+> The best-laid plans of mice and men  
 > Often go awry
 >
 > "Tae a Moose", Robert Burns

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

@@ -59,15 +59,15 @@ Unlike `let`, you _must_ declare the types of function arguments. This does
 not work:
 
 ```{ignore}
-fn print_number(x, y) {
+fn print_sum(x, y) {
     println!("x is: {}", x + y);
 }
 ```
 
 You get this error:
 
 ```text
-hello.rs:5:18: 5:19 error: expected `:` but found `,`
+hello.rs:5:18: 5:19 expected one of `!`, `:`, or `@`, found `)`
 hello.rs:5 fn print_number(x, y) {
 ```
 

branches/auto/src/doc/trpl/hello-cargo.md

@@ -7,7 +7,7 @@ Rust projects, and so it is assumed that Rust projects will use Cargo from the
 beginning.
 
 Cargo manages three things: building your code, downloading the dependencies
-your code needs, and building the dependencies your code needs.  At first, your
+your code needs, and building those dependencies. At first, your
 program doesn't have any dependencies, so we'll only be using the first part of
 its functionality. Eventually, we'll add more. Since we started off by using
 Cargo, it'll be easy to add later.

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

@@ -126,7 +126,7 @@ let y: i32 = if x == 5 { 10; } else { 15; };
 Note the semicolons after the 10 and 15. Rust will give us the following error:
 
 ```text
-error: mismatched types: expected `i32` but found `()` (expected i32 but found ())
+error: mismatched types: expected `i32`, found `()` (expected i32, found ())
 ```
 
 We expected an integer, but we got `()`. `()` is pronounced *unit*, and is a

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

@@ -488,7 +488,7 @@ Here are the three rules:
   parameter.
 
 * If there is exactly one input lifetime, elided or not, that lifetime is
-  assigned to all elided lifetimes in the return values of that function..
+  assigned to all elided lifetimes in the return values of that function.
 
 * If there are multiple input lifetimes, but one of them is `&self` or `&mut
   self`, the lifetime of `self` is assigned to all elided output lifetimes.

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

@@ -309,7 +309,7 @@ extern crate adder;
 
 #[test]
 fn it_works() {
-    assert_eq(4, adder::add_two(2));
+    assert_eq!(4, adder::add_two(2));
 }   
 ```
 

branches/auto/src/doc/trpl/variable-bindings.md

@@ -98,7 +98,7 @@ let x;
 ...we'll get an error:
 
 ```text
-src/main.rs:2:9: 2:10 error: cannot determine a type for this local variable: unconstrained type
+src/main.rs:2:9: 2:10 error: unable to infer enough type information about `_`; type annotations required
 src/main.rs:2     let x;
                       ^
 ```

branches/auto/src/etc/vim/syntax/rust.vim

@@ -59,7 +59,7 @@ syn match rustMacroVariable "$\w\+"
 syn keyword   rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield abstract final override macro
 
 " Built-in types {{{2
-syn keyword   rustType        int isize uint usize float char bool u8 u16 u32 u64 f32
+syn keyword   rustType        isize usize float char bool u8 u16 u32 u64 f32
 syn keyword   rustType        f64 i8 i16 i32 i64 str Self
 
 " Things from the prelude (src/libstd/prelude.rs) {{{2
@@ -95,8 +95,6 @@ syn keyword rustTrait Vec
 syn keyword rustTrait Path GenericPath
 " FIXME: remove when I/O reform lands
 syn keyword rustTrait Buffer Writer Reader Seek BufferPrelude
-" FIXME: remove when range syntax lands
-syn keyword rustFunction range
 
 " Other syntax {{{2
 syn keyword   rustSelf        self
@@ -139,10 +137,10 @@ syn region    rustAttribute   start="#!\?\[" end="\]" contains=rustString,rustDe
 syn region    rustDerive      start="derive(" end=")" contained contains=rustTrait
 
 " Number literals
-syn match     rustDecNumber   display "\<[0-9][0-9_]*\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match     rustHexNumber   display "\<0x[a-fA-F0-9_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match     rustOctNumber   display "\<0o[0-7_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
-syn match     rustBinNumber   display "\<0b[01_]\+\%([iu]\%(8\|16\|32\|64\)\=\)\="
+syn match     rustDecNumber   display "\<[0-9][0-9_]*\%([iu]\%(s\|8\|16\|32\|64\)\)\="
+syn match     rustHexNumber   display "\<0x[a-fA-F0-9_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
+syn match     rustOctNumber   display "\<0o[0-7_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
+syn match     rustBinNumber   display "\<0b[01_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
 
 " Special case for numbers of the form "1." which are float literals, unless followed by
 " an identifier, which makes them integer literals with a method call or field access,