---

yaml
---
r: 208574
b: refs/heads/snap-stage3
c: 6149e32
h: refs/heads/master
v: v3

Author: brson

[refs]

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

branches/snap-stage3/README.md

@@ -1,11 +1,9 @@
 # The Rust Programming Language
 
-Rust is a systems programming language that is fast, memory safe and
-multithreaded, but does not employ a garbage collector or otherwise
-impose significant runtime overhead.
-
-This repo contains the code for `rustc`, the Rust compiler, as well
-as standard libraries, tools and documentation for Rust.
+This is a compiler for Rust, including standard libraries, tools and
+documentation. Rust is a systems programming language that is fast,
+memory safe and multithreaded, but does not employ a garbage collector
+or otherwise impose significant runtime overhead.
 
 ## Quick Start
 

branches/snap-stage3/mk/main.mk

@@ -13,7 +13,7 @@
 ######################################################################
 
 # The version number
-CFG_RELEASE_NUM=1.1.0
+CFG_RELEASE_NUM=1.2.0
 
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release

branches/snap-stage3/src/doc/trpl/const-and-static.md

@@ -31,8 +31,10 @@ static N: i32 = 5;
 
 Unlike [`let`][let] bindings, you must annotate the type of a `static`.
 
+[let]: variable-bindings.html
+
 Statics live for the entire lifetime of a program, and therefore any
-reference stored in a constant has a [`'static` lifetime][lifetimes]:
+reference stored in a constant has a [`’static` lifetime][lifetimes]:
 
 ```rust
 static NAME: &'static str = "Steve";

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

@@ -26,8 +26,8 @@ $ sh rustup.sh --channel=nightly
 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-nightly-i686-pc-windows-gnu.msi
-[win64]: https://static.rust-lang.org/dist/rust-nightly-x86_64-pc-windows-gnu.msi
+[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
 
 ## Uninstalling
 

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

@@ -208,7 +208,7 @@ let result = f.write("whatever".as_bytes());
 
 This will compile without error.
 
-This means that even if someone does something bad like add methods to `i32`,
+This means that even if someone does something bad like add methods to `int`,
 it won’t affect you, unless you `use` that trait.
 
 There’s one more restriction on implementing traits. Either the trait or the

branches/snap-stage3/src/libsyntax/parse/lexer/mod.rs

@@ -403,51 +403,45 @@ impl<'a> StringReader<'a> {
                 Some('/') => {
                     self.bump();
                     self.bump();
-
                     // line comments starting with "///" or "//!" are doc-comments
-                    let doc_comment = self.curr_is('/') || self.curr_is('!');
-                    let start_bpos = if doc_comment {
-                        self.pos - BytePos(3)
-                    } else {
-                        self.last_pos - BytePos(2)
-                    };
-
-                    while !self.is_eof() {
-                        match self.curr.unwrap() {
-                            '\n' => break,
-                            '\r' => {
-                                if self.nextch_is('\n') {
-                                    // CRLF
-                                    break
-                                } else if doc_comment {
-                                    self.err_span_(self.last_pos, self.pos,
-                                                   "bare CR not allowed in doc-comment");
+                    if self.curr_is('/') || self.curr_is('!') {
+                        let start_bpos = self.pos - BytePos(3);
+                        while !self.is_eof() {
+                            match self.curr.unwrap() {
+                                '\n' => break,
+                                '\r' => {
+                                    if self.nextch_is('\n') {
+                                        // CRLF
+                                        break
+                                    } else {
+                                        self.err_span_(self.last_pos, self.pos,
+                                                       "bare CR not allowed in doc-comment");
+                                    }
                                 }
+                                _ => ()
                             }
-                            _ => ()
+                            self.bump();
                         }
-                        self.bump();
-                    }
-
-                    return if doc_comment {
-                        self.with_str_from(start_bpos, |string| {
-                            // comments with only more "/"s are not doc comments
+                        return self.with_str_from(start_bpos, |string| {
+                            // but comments with only more "/"s are not
                             let tok = if is_doc_comment(string) {
                                 token::DocComment(token::intern(string))
                             } else {
                                 token::Comment
                             };
 
-                            Some(TokenAndSpan {
+                            return Some(TokenAndSpan{
                                 tok: tok,
                                 sp: codemap::mk_sp(start_bpos, self.last_pos)
-                            })
-                        })
+                            });
+                        });
                     } else {
-                        Some(TokenAndSpan {
+                        let start_bpos = self.last_pos - BytePos(2);
+                        while !self.curr_is('\n') && !self.is_eof() { self.bump(); }
+                        return Some(TokenAndSpan {
                             tok: token::Comment,
                             sp: codemap::mk_sp(start_bpos, self.last_pos)
-                        })
+                        });
                     }
                 }
                 Some('*') => {
@@ -1569,13 +1563,4 @@ mod tests {
         assert_eq!(lexer.next_token().tok, token::Literal(token::Char(token::intern("a")), None));
     }
 
-    #[test] fn crlf_comments() {
-        let sh = mk_sh();
-        let mut lexer = setup(&sh, "// test\r\n/// test\r\n".to_string());
-        let comment = lexer.next_token();
-        assert_eq!(comment.tok, token::Comment);
-        assert_eq!(comment.sp, ::codemap::mk_sp(BytePos(0), BytePos(7)));
-        assert_eq!(lexer.next_token().tok, token::Whitespace);
-        assert_eq!(lexer.next_token().tok, token::DocComment(token::intern("/// test")));
-    }
 }

branches/snap-stage3/src/libsyntax/parse/parser.rs

@@ -2026,8 +2026,7 @@ impl<'a> Parser<'a> {
                 return self.parse_block_expr(lo, DefaultBlock);
             },
             token::BinOp(token::Or) |  token::OrOr => {
-                let lo = self.span.lo;
-                return self.parse_lambda_expr(lo, CaptureByRef);
+                return self.parse_lambda_expr(CaptureByRef);
             },
             token::Ident(id @ ast::Ident {
                             name: token::SELF_KEYWORD_NAME,
@@ -2082,8 +2081,7 @@ impl<'a> Parser<'a> {
                     return Ok(self.mk_expr(lo, hi, ExprPath(Some(qself), path)));
                 }
                 if try!(self.eat_keyword(keywords::Move) ){
-                    let lo = self.last_span.lo;
-                    return self.parse_lambda_expr(lo, CaptureByValue);
+                    return self.parse_lambda_expr(CaptureByValue);
                 }
                 if try!(self.eat_keyword(keywords::If)) {
                     return self.parse_if_expr();
@@ -2842,9 +2840,10 @@ impl<'a> Parser<'a> {
     }
 
     // `|args| expr`
-    pub fn parse_lambda_expr(&mut self, lo: BytePos, capture_clause: CaptureClause)
+    pub fn parse_lambda_expr(&mut self, capture_clause: CaptureClause)
                              -> PResult<P<Expr>>
     {
+        let lo = self.span.lo;
         let decl = try!(self.parse_fn_block_decl());
         let body = match decl.output {
             DefaultReturn(_) => {