---

yaml
---
r: 158575
b: refs/heads/try
c: c1b1951
h: refs/heads/master
i:
  158573: 934cf6e
  158571: e5b0765
  158567: 1032c4d
  158559: cc74a42
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a0a7ab461283322215f0343cd2b5e66fc19a7bd5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 1b2ad7831f1745bf4a4709a1fa1772afb47c933c
-refs/heads/try: 2b6c2b6e348407ceaac749209e26f0dbf67227fd
+refs/heads/try: c1b19513ee75a36e3bee604531028af394673c1c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/compiletest/runtest.rs

@@ -627,7 +627,7 @@ fn find_rust_src_root(config: &Config) -> Option<Path> {
     let path_postfix = Path::new("src/etc/lldb_batchmode.py");
 
     while path.pop() {
-        if path.join(path_postfix.clone()).is_file() {
+        if path.join(&path_postfix).is_file() {
             return Some(path);
         }
     }

branches/try/src/doc/guide-testing.md

@@ -287,7 +287,7 @@ The benchmarking runner offers two ways to avoid this. Either, the
 closure that the `iter` method receives can return an arbitrary value
 which forces the optimizer to consider the result used and ensures it
 cannot remove the computation entirely. This could be done for the
-example above by adjusting the `bh.iter` call to
+example above by adjusting the `b.iter` call to
 
 ~~~
 # struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let b = X;

branches/try/src/doc/guide.md

@@ -777,7 +777,7 @@ fn add_one(x: int) -> int {
      x + 1;
 }
 
-note: consider removing this semicolon:
+help: consider removing this semicolon:
      x + 1;
           ^
 ```
@@ -4467,18 +4467,19 @@ see why consumers matter.
 
 ## Iterators
 
-As we've said before, an iterator is something that we can call the `.next()`
-method on repeatedly, and it gives us a sequence of things. Because you need
-to call the method, this means that iterators are **lazy**. This code, for
-example, does not actually generate the numbers `1-100`, and just creates a
-value that represents the sequence:
+As we've said before, an iterator is something that we can call the
+`.next()` method on repeatedly, and it gives us a sequence of things.
+Because you need to call the method, this means that iterators
+are **lazy** and don't need to generate all of the values upfront.
+This code, for example, does not actually generate the numbers
+`1-100`, and just creates a value that represents the sequence:
 
 ```{rust}
 let nums = range(1i, 100i);
 ```
 
 Since we didn't do anything with the range, it didn't generate the sequence.
-Once we add the consumer:
+Let's add the consumer:
 
 ```{rust}
 let nums = range(1i, 100i).collect::<Vec<int>>();
@@ -4507,8 +4508,8 @@ std::iter::count(1i, 5i);
 ```
 
 This iterator counts up from one, adding five each time. It will give
-you a new integer every time, forever. Well, technically, until the
-maximum number that an `int` can represent. But since iterators are lazy,
+you a new integer every time, forever (well, technically, until it reaches the
+maximum number representable by an `int`). But since iterators are lazy,
 that's okay! You probably don't want to use `collect()` on it, though...
 
 That's enough about iterators. Iterator adapters are the last concept
@@ -5251,8 +5252,8 @@ to do something that it can't currently do? You may be able to write a macro
 to extend Rust's capabilities.
 
 You've already used one macro extensively: `println!`. When we invoke
-a Rust macro, we need to use the exclamation mark (`!`). There's two reasons
-that this is true: the first is that it makes it clear when you're using a
+a Rust macro, we need to use the exclamation mark (`!`). There are two reasons
+why this is so: the first is that it makes it clear when you're using a
 macro. The second is that macros allow for flexible syntax, and so Rust must
 be able to tell where a macro starts and ends. The `!(...)` helps with this.
 
@@ -5267,7 +5268,7 @@ println!("x is: {}", x);
 
 The `println!` macro does a few things:
 
-1. It parses the string to find any `{}`s
+1. It parses the string to find any `{}`s.
 2. It checks that the number of `{}`s matches the number of other arguments.
 3. It generates a bunch of Rust code, taking this in mind.
 
@@ -5276,8 +5277,8 @@ Rust will generate code that takes all of the types into account. If
 `println!` was a function, it could still do this type checking, but it
 would happen at run time rather than compile time.
 
-We can check this out using a special flag to `rustc`. This code, in a file
-`print.rs`:
+We can check this out using a special flag to `rustc`. Put this code in a file
+called `print.rs`:
 
 ```{rust}
 fn main() {
@@ -5286,7 +5287,7 @@ fn main() {
 }
 ```
 
-Can have its macros expanded like this: `rustc print.rs --pretty=expanded`, will
+You can have the macros expanded like this: `rustc print.rs --pretty=expanded` – which will
 give us this huge result:
 
 ```{rust,ignore}
@@ -5325,12 +5326,12 @@ invoke the `println_args` function with the generated arguments.
 This is the code that Rust actually compiles. You can see all of the extra
 information that's here. We get all of the type safety and options that it
 provides, but at compile time, and without needing to type all of this out.
-This is how macros are powerful. Without them, you would need to type all of
-this by hand to get a type checked `println`.
+This is how macros are powerful: without them you would need to type all of
+this by hand to get a type-checked `println`.
 
 For more on macros, please consult [the Macros Guide](guide-macros.html).
-Macros are a very advanced and still slightly experimental feature, but don't
-require a deep understanding to call, since they look just like functions. The
+Macros are a very advanced and still slightly experimental feature, but they don't
+require a deep understanding to be called, since they look just like functions. The
 Guide can help you if you want to write your own.
 
 # Unsafe
@@ -5347,8 +5348,8 @@ keyword, which indicates that the function may not behave properly.
 
 Second, if you'd like to create some sort of shared-memory data structure, Rust
 won't allow it, because memory must be owned by a single owner. However, if
-you're planning on making access to that shared memory safe, such as with a
-mutex, _you_ know that it's safe, but Rust can't know. Writing an `unsafe`
+you're planning on making access to that shared memory safe – such as with a
+mutex – _you_ know that it's safe, but Rust can't know. Writing an `unsafe`
 block allows you to ask the compiler to trust you. In this case, the _internal_
 implementation of the mutex is considered unsafe, but the _external_ interface
 we present is safe. This allows it to be effectively used in normal Rust, while

branches/try/src/doc/intro.md

@@ -494,14 +494,14 @@ non-deterministic aspect:
 $ cargo run
    Compiling hello_world v0.0.1 (file:///Users/you/src/hello_world)
      Running `target/hello_world`
-numbers[1] is 2
-numbers[0] is 1
-numbers[2] is 3
+numbers[1] is 3
+numbers[0] is 2
+numbers[2] is 4
 $ cargo run
      Running `target/hello_world`
-numbers[2] is 3
-numbers[1] is 2
-numbers[0] is 1
+numbers[2] is 4
+numbers[1] is 3
+numbers[0] is 2
 ```
 
 Each time, we get a slightly different output, because each thread works in a

branches/try/src/doc/reference.md

@@ -400,11 +400,11 @@ An _integer literal_ has one of four forms:
 * A _decimal literal_ starts with a *decimal digit* and continues with any
   mixture of *decimal digits* and _underscores_.
 * A _hex literal_ starts with the character sequence `U+0030` `U+0078`
-  (`0x`) and continues as any mixture hex digits and underscores.
+  (`0x`) and continues as any mixture of hex digits and underscores.
 * An _octal literal_ starts with the character sequence `U+0030` `U+006F`
-  (`0o`) and continues as any mixture octal digits and underscores.
+  (`0o`) and continues as any mixture of octal digits and underscores.
 * A _binary literal_ starts with the character sequence `U+0030` `U+0062`
-  (`0b`) and continues as any mixture binary digits and underscores.
+  (`0b`) and continues as any mixture of binary digits and underscores.
 
 An integer literal may be followed (immediately, without any spaces) by an
 _integer suffix_, which changes the type of the literal. There are two kinds of
@@ -944,10 +944,10 @@ An example of `use` declarations:
 ```
 use std::iter::range_step;
 use std::option::{Some, None};
-use std::collections::hashmap::{mod, HashMap};
+use std::collections::hash_map::{mod, HashMap};
 
-# fn foo<T>(_: T){}
-# fn bar(map: HashMap<String, uint>, set: hashmap::HashSet<String>){}
+fn foo<T>(_: T){}
+fn bar(map1: HashMap<String, uint>, map2: hash_map::HashMap<String, uint>){}
 
 fn main() {
     // Equivalent to 'std::iter::range_step(0u, 10u, 2u);'
@@ -957,10 +957,10 @@ fn main() {
     // std::option::None]);'
     foo(vec![Some(1.0f64), None]);
 
-    // Both `hash` and `HashMap` are in scope.
-    let map = HashMap::new();
-    let set = hashmap::HashSet::new();
-    bar(map, set);
+    // Both `hash_map` and `HashMap` are in scope.
+    let map1 = HashMap::new();
+    let map2 = hash_map::HashMap::new();
+    bar(map1, map2);
 }
 ```
 
@@ -2100,15 +2100,15 @@ plugins](guide-plugin.html#lint-plugins) can provide additional lint checks.
 ```{.ignore}
 mod m1 {
     // Missing documentation is ignored here
-    #[allow(missing_doc)]
+    #[allow(missing_docs)]
     pub fn undocumented_one() -> int { 1 }
 
     // Missing documentation signals a warning here
-    #[warn(missing_doc)]
+    #[warn(missing_docs)]
     pub fn undocumented_too() -> int { 2 }
 
     // Missing documentation signals an error here
-    #[deny(missing_doc)]
+    #[deny(missing_docs)]
     pub fn undocumented_end() -> int { 3 }
 }
 ```
@@ -2117,16 +2117,16 @@ This example shows how one can use `allow` and `warn` to toggle a particular
 check on and off.
 
 ```{.ignore}
-#[warn(missing_doc)]
+#[warn(missing_docs)]
 mod m2{
-    #[allow(missing_doc)]
+    #[allow(missing_docs)]
     mod nested {
         // Missing documentation is ignored here
         pub fn undocumented_one() -> int { 1 }
 
         // Missing documentation signals a warning here,
         // despite the allow above.
-        #[warn(missing_doc)]
+        #[warn(missing_docs)]
         pub fn undocumented_two() -> int { 2 }
     }
 
@@ -2139,10 +2139,10 @@ This example shows how one can use `forbid` to disallow uses of `allow` for
 that lint check.
 
 ```{.ignore}
-#[forbid(missing_doc)]
+#[forbid(missing_docs)]
 mod m3 {
     // Attempting to toggle warning signals an error here
-    #[allow(missing_doc)]
+    #[allow(missing_docs)]
     /// Returns 2.
     pub fn undocumented_too() -> int { 2 }
 }
@@ -4096,7 +4096,7 @@ cause transitions between the states. The lifecycle states of a task are:
 
 * running
 * blocked
-* panicked 
+* panicked
 * dead
 
 A task begins its lifecycle &mdash; once it has been spawned &mdash; in the

branches/try/src/doc/rust.css

@@ -62,6 +62,10 @@ body {
     font-size: 18px;
     color: #333;
     line-height: 1.428571429;
+
+    -webkit-font-feature-settings: "kern", "liga";
+    -moz-font-feature-settings: "kern", "liga";
+    font-feature-settings: "kern", "liga";
 }
 @media (min-width: 768px) {
     body {

branches/try/src/etc/unicode.py

@@ -34,7 +34,7 @@
 
 // NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly
 
-#![allow(missing_doc, non_uppercase_statics, non_snake_case)]
+#![allow(missing_docs, non_uppercase_statics, non_snake_case)]
 '''
 
 # Mapping taken from Table 12 from:

branches/try/src/etc/vim/autoload/rust.vim

@@ -178,14 +178,14 @@ function! s:WithPath(func, ...)
 			call mkdir(tmpdir)
 
 			let save_cwd = getcwd()
-			silent exe 'lcd' tmpdir
+			silent exe 'lcd' fnameescape(tmpdir)
 
 			let path = 'unnamed.rs'
 
 			let save_mod = &mod
 			set nomod
 
-			silent exe 'keepalt write! ' . path
+			silent exe 'keepalt write! ' . fnameescape(path)
 			if pathisempty
 				silent keepalt 0file
 			endif
@@ -195,10 +195,10 @@ function! s:WithPath(func, ...)
 
 		call call(a:func, [path] + a:000)
 	finally
-		if exists("save_mod")   | let &mod = save_mod          | endif
-		if exists("save_write") | let &write = save_write      | endif
-		if exists("save_cwd")   | silent exe 'lcd' save_cwd    | endif
-		if exists("tmpdir")     | silent call s:RmDir(tmpdir)  | endif
+		if exists("save_mod")   | let &mod = save_mod                    | endif
+		if exists("save_write") | let &write = save_write                | endif
+		if exists("save_cwd")   | silent exe 'lcd' fnameescape(save_cwd) | endif
+		if exists("tmpdir")     | silent call s:RmDir(tmpdir)            | endif
 	endtry
 endfunction