---

yaml
---
r: 208638
b: refs/heads/snap-stage3
c: a0815c8
h: refs/heads/master
v: v3

Author: Manishearth

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 38a97becdf3e6a6157f6f7ec2d98ade8d8edc193
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: e5e722bd3244c927fb672850805c3b3f3bd46e79
+refs/heads/snap-stage3: a0815c8c747eb63adec7b863047c0f176eafce94
 refs/heads/try: 7b4ef47b7805a402d756fb8157101f64880a522f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/AUTHORS.txt

@@ -8,7 +8,7 @@ Aaron Raimist <[email protected]>
 Aaron Todd <[email protected]>
 Aaron Turon <[email protected]>
 Aaron Weiss <[email protected]>
-Abhishek Chanda <abhishek@cloudscaling.com>
+Abhishek Chanda <abhishek.becs@gmail.com>
 Adam Bozanich <[email protected]>
 Adam Jacob <[email protected]>
 Adam Roben <[email protected]>

branches/snap-stage3/src/doc/complement-lang-faq.md

@@ -5,8 +5,8 @@
 There aren't many large programs yet. The Rust [compiler][rustc], 60,000+ lines at the time of writing, is written in Rust. As the oldest body of Rust code it has gone through many iterations of the language, and some parts are nicer to look at than others. It may not be the best code to learn from, but [borrowck] and [resolve] were written recently.
 
 [rustc]: https://github.com/rust-lang/rust/tree/master/src/librustc
-[resolve]: https://github.com/rust-lang/rust/blob/master/src/librustc/middle/resolve.rs
-[borrowck]: https://github.com/rust-lang/rust/blob/master/src/librustc/middle/borrowck/
+[resolve]: https://github.com/rust-lang/rust/tree/master/src/librustc_resolve
+[borrowck]: https://github.com/rust-lang/rust/tree/master/src/librustc_borrowck/borrowck
 
 A research browser engine called [Servo][servo], currently 30,000+ lines across more than a dozen crates, will be exercising a lot of Rust's distinctive type-system and concurrency features, and integrating many native libraries.
 
@@ -20,8 +20,8 @@ Some examples that demonstrate different aspects of the language:
 * The standard library's [json] module. Enums and pattern matching
 
 [sprocketnes]: https://github.com/pcwalton/sprocketnes
-[hash]: https://github.com/rust-lang/rust/blob/master/src/libstd/hash/mod.rs
-[HashMap]: https://github.com/rust-lang/rust/blob/master/src/libcollections/hashmap.rs
+[hash]: https://github.com/rust-lang/rust/tree/master/src/libcore/hash
+[HashMap]: https://github.com/rust-lang/rust/tree/master/src/libstd/collections/hash
 [json]: https://github.com/rust-lang/rust/blob/master/src/libserialize/json.rs
 
 You may also be interested in browsing [trending Rust repositories][github-rust] on GitHub.

branches/snap-stage3/src/doc/trpl/dining-philosophers.md

@@ -320,7 +320,7 @@ from the standard library, and so we need to `use` it.
 We now print out two messages, with a `sleep_ms()` in the middle. This will
 simulate the time it takes a philosopher to eat.
 
-If you run this program, You should see each philosopher eat in turn:
+If you run this program, you should see each philosopher eat in turn:
 
 ```text
 Baruch Spinoza is eating.
@@ -480,7 +480,7 @@ struct Table {
 }
 ```
 
-This `Table` has an vector of `Mutex`es. A mutex is a way to control
+This `Table` has a vector of `Mutex`es. A mutex is a way to control
 concurrency: only one thread can access the contents at once. This is exactly
 the property we need with our forks. We use an empty tuple, `()`, inside the
 mutex, since we’re not actually going to use the value, just hold onto it.

branches/snap-stage3/src/doc/trpl/installing-rust.md

@@ -23,8 +23,8 @@ $ sh rustup.sh
 If you're on Windows, please download either the [32-bit installer][win32] or
 the [64-bit installer][win64] and run it.
 
-[win32]: https://static.rust-lang.org/dist/rust-1.0.0-beta-i686-pc-windows-gnu.msi
-[win64]: https://static.rust-lang.org/dist/rust-1.0.0-beta-x86_64-pc-windows-gnu.msi
+[win32]: https://static.rust-lang.org/dist/rust-1.0.0-i686-pc-windows-gnu.msi
+[win64]: https://static.rust-lang.org/dist/rust-1.0.0-x86_64-pc-windows-gnu.msi
 
 ## Uninstalling
 
@@ -74,7 +74,7 @@ $ rustc --version
 You should see the version number, commit hash, commit date and build date:
 
 ```bash
-rustc 1.0.0-beta (9854143cb 2015-04-02) (built 2015-04-02)
+rustc 1.0.0 (a59de37e9 2015-05-13) (built 2015-05-14)
 ```
 
 If you did, Rust has been installed successfully! Congrats!

branches/snap-stage3/src/doc/trpl/rust-inside-other-languages.md

@@ -104,7 +104,7 @@ fn process() {
     let handles: Vec<_> = (0..10).map(|_| {
         thread::spawn(|| {
             let mut _x = 0;
-            for _ in (0..5_000_001) {
+            for _ in (0..5_000_000) {
                 _x += 1
             }
         })
@@ -217,7 +217,7 @@ end
 
 Hello.process
 
-puts "done!”
+puts "done!"
 ```
 
 Before we can run this, we need to install the `ffi` gem:

branches/snap-stage3/src/doc/trpl/strings.md

@@ -16,11 +16,11 @@ Rust has two main types of strings: `&str` and `String`. Let’s talk about
 `&'static str`:
 
 ```rust
-let string = "Hello there."; // string: &'static str
+let greeting = "Hello there."; // greeting: &'static str
 ```
 
 This string is statically allocated, meaning that it’s saved inside our
-compiled program, and exists for the entire duration it runs. The `string`
+compiled program, and exists for the entire duration it runs. The `greeting`
 binding is a reference to this statically allocated string. String slices
 have a fixed size, and cannot be mutated.
 

branches/snap-stage3/src/grammar/verify.rs

@@ -287,11 +287,9 @@ fn main() {
     let options = config::basic_options();
     let session = session::build_session(options, None,
                                          syntax::diagnostics::registry::Registry::new(&[]));
-    let filemap = parse::string_to_filemap(&session.parse_sess,
-                                           code,
-                                           String::from_str("<n/a>"));
+    let filemap = session.parse_sess.codemap().new_filemap(String::from_str("<n/a>"), code);
     let mut lexer = lexer::StringReader::new(session.diagnostic(), filemap);
-    let ref cm = lexer.span_diagnostic.cm;
+    let cm = session.codemap();
 
     // ANTLR
     let mut token_file = File::open(&Path::new(&args.next().unwrap())).unwrap();