---

yaml
---
r: 63098
b: refs/heads/snap-stage3
c: b870477
h: refs/heads/master
v: v3

Author: dotdash

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 93b2ddfc88f581a1155236c9ac79983f72b0ff46
+refs/heads/snap-stage3: b87047789723ac140f471c56cebf3faa27e0c06f
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial.md

@@ -1439,15 +1439,10 @@ call_closure_with_ten(closure);
 ~~~~
 
 Closures begin with the argument list between vertical bars and are followed by
-a single expression. Remember that a block, `{ <expr1>; <expr2>; ... }`, is
-considered a single expression: it evaluates to the result of the last
-expression it contains if that expression is not followed by a semicolon,
-otherwise the block evaluates to `()`.
-
-The types of the arguments are generally omitted, as is the return type,
-because the compiler can almost always infer them. In the rare case where the
-compiler needs assistance, though, the arguments and return types may be
-annotated.
+a single expression. The types of the arguments are generally omitted,
+as is the return type, because the compiler can almost always infer
+them. In the rare case where the compiler needs assistance, though, the
+arguments and return types may be annotated.
 
 ~~~~
 let square = |x: int| -> uint { x * x as uint };

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

@@ -347,7 +347,7 @@ pub fn gather_comments_and_literals(span_diagnostic:
         }
 
 
-        let bstart = rdr.pos;
+        let bstart = rdr.last_pos;
         rdr.next_token();
         //discard, and look ahead; we're working with internal state
         let TokenAndSpan {tok: tok, sp: sp} = rdr.peek();

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

@@ -161,22 +161,20 @@ fn string_advance_token(r: @mut StringReader) {
     }
 }
 
-fn byte_offset(rdr: &StringReader) -> BytePos {
-    (rdr.pos - rdr.filemap.start_pos)
+fn byte_offset(rdr: &StringReader, pos: BytePos) -> BytePos {
+    (pos - rdr.filemap.start_pos)
 }
 
 pub fn get_str_from(rdr: @mut StringReader, start: BytePos) -> ~str {
-    // I'm pretty skeptical about this subtraction. What if there's a
-    // multi-byte character before the mark?
-    return str::slice(*rdr.src, start.to_uint() - 1u,
-                      byte_offset(rdr).to_uint() - 1u).to_owned();
+    return str::slice(*rdr.src, start.to_uint(),
+                      byte_offset(rdr, rdr.last_pos).to_uint()).to_owned();
 }
 
 // EFFECT: advance the StringReader by one character. If a newline is
 // discovered, add it to the FileMap's list of line start offsets.
 pub fn bump(rdr: &mut StringReader) {
     rdr.last_pos = rdr.pos;
-    let current_byte_offset = byte_offset(rdr).to_uint();;
+    let current_byte_offset = byte_offset(rdr, rdr.pos).to_uint();
     if current_byte_offset < (*rdr.src).len() {
         assert!(rdr.curr != -1 as char);
         let last_char = rdr.curr;
@@ -202,7 +200,7 @@ pub fn is_eof(rdr: @mut StringReader) -> bool {
     rdr.curr == -1 as char
 }
 pub fn nextch(rdr: @mut StringReader) -> char {
-    let offset = byte_offset(rdr).to_uint();
+    let offset = byte_offset(rdr, rdr.pos).to_uint();
     if offset < (*rdr.src).len() {
         return str::char_at(*rdr.src, offset);
     } else { return -1 as char; }
@@ -540,19 +538,19 @@ fn ident_continue(c: char) -> bool {
 // EFFECT: advances the input past that token
 // EFFECT: updates the interner
 fn next_token_inner(rdr: @mut StringReader) -> token::Token {
-    let mut accum_str = ~"";
     let mut c = rdr.curr;
     if ident_start(c) {
-        while ident_continue(c) {
-            str::push_char(&mut accum_str, c);
+        let start = byte_offset(rdr, rdr.last_pos);
+        while ident_continue(rdr.curr) {
             bump(rdr);
-            c = rdr.curr;
         }
-        if accum_str == ~"_" { return token::UNDERSCORE; }
-        let is_mod_name = c == ':' && nextch(rdr) == ':';
+        let string = get_str_from(rdr, start);
+
+        if "_" == string { return token::UNDERSCORE; }
+        let is_mod_name = rdr.curr == ':' && nextch(rdr) == ':';
 
         // FIXME: perform NFKC normalization here. (Issue #2253)
-        return token::IDENT(str_to_ident(accum_str), is_mod_name);
+        return token::IDENT(str_to_ident(string), is_mod_name);
     }
     if is_dec_digit(c) {
         return scan_number(c, rdr);
@@ -692,7 +690,8 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
         return token::LIT_INT(c2 as i64, ast::ty_char);
       }
       '"' => {
-        let n = byte_offset(rdr);
+        let mut accum_str = ~"";
+        let n = byte_offset(rdr, rdr.last_pos);
         bump(rdr);
         while rdr.curr != '"' {
             if is_eof(rdr) {