librustc: Lots of de-muting. rs=demuting

3 files changed, 106 insertions, 100 deletions

diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index d7640ce3a23..a8db06fe085 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -14,7 +14,7 @@ use ast;
 use codemap::{BytePos, CharPos, CodeMap, FileMap, Pos};
 use diagnostic;
 use parse::lexer::{is_whitespace, get_str_from, reader};
-use parse::lexer::{string_reader, bump, is_eof, nextch, TokenAndSpan};
+use parse::lexer::{StringReader, bump, is_eof, nextch, TokenAndSpan};
 use parse::lexer;
 use parse::token;
 use parse;
@@ -120,7 +120,7 @@ pub fn strip_doc_comment_decoration(comment: ~str) -> ~str {
     die!(~"not a doc-comment: " + comment);
 }
 
-fn read_to_eol(rdr: string_reader) -> ~str {
+fn read_to_eol(rdr: @mut StringReader) -> ~str {
     let mut val = ~"";
     while rdr.curr != '\n' && !is_eof(rdr) {
         str::push_char(&mut val, rdr.curr);
@@ -130,26 +130,26 @@ fn read_to_eol(rdr: string_reader) -> ~str {
     return val;
 }
 
-fn read_one_line_comment(rdr: string_reader) -> ~str {
+fn read_one_line_comment(rdr: @mut StringReader) -> ~str {
     let val = read_to_eol(rdr);
     assert ((val[0] == '/' as u8 && val[1] == '/' as u8) ||
             (val[0] == '#' as u8 && val[1] == '!' as u8));
     return val;
 }
 
-fn consume_non_eol_whitespace(rdr: string_reader) {
+fn consume_non_eol_whitespace(rdr: @mut StringReader) {
     while is_whitespace(rdr.curr) && rdr.curr != '\n' && !is_eof(rdr) {
         bump(rdr);
     }
 }
 
-fn push_blank_line_comment(rdr: string_reader, comments: &mut ~[cmnt]) {
+fn push_blank_line_comment(rdr: @mut StringReader, comments: &mut ~[cmnt]) {
     debug!(">>> blank-line comment");
     let v: ~[~str] = ~[];
     comments.push({style: blank_line, lines: v, pos: rdr.last_pos});
 }
 
-fn consume_whitespace_counting_blank_lines(rdr: string_reader,
+fn consume_whitespace_counting_blank_lines(rdr: @mut StringReader,
                                            comments: &mut ~[cmnt]) {
     while is_whitespace(rdr.curr) && !is_eof(rdr) {
         if rdr.col == CharPos(0u) && rdr.curr == '\n' {
@@ -160,7 +160,7 @@ fn consume_whitespace_counting_blank_lines(rdr: string_reader,
 }
 
 
-fn read_shebang_comment(rdr: string_reader, code_to_the_left: bool,
+fn read_shebang_comment(rdr: @mut StringReader, code_to_the_left: bool,
                                             comments: &mut ~[cmnt]) {
     debug!(">>> shebang comment");
     let p = rdr.last_pos;
@@ -172,7 +172,7 @@ fn read_shebang_comment(rdr: string_reader, code_to_the_left: bool,
     });
 }
 
-fn read_line_comments(rdr: string_reader, code_to_the_left: bool,
+fn read_line_comments(rdr: @mut StringReader, code_to_the_left: bool,
                                           comments: &mut ~[cmnt]) {
     debug!(">>> line comments");
     let p = rdr.last_pos;
@@ -221,8 +221,9 @@ fn trim_whitespace_prefix_and_push_line(lines: &mut ~[~str],
     lines.push(s1);
 }
 
-fn read_block_comment(rdr: string_reader, code_to_the_left: bool,
-                                          comments: &mut ~[cmnt]) {
+fn read_block_comment(rdr: @mut StringReader,
+                      code_to_the_left: bool,
+                      comments: &mut ~[cmnt]) {
     debug!(">>> block comment");
     let p = rdr.last_pos;
     let mut lines: ~[~str] = ~[];
@@ -280,13 +281,14 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool,
     comments.push({style: style, lines: lines, pos: p});
 }
 
-fn peeking_at_comment(rdr: string_reader) -> bool {
+fn peeking_at_comment(rdr: @mut StringReader) -> bool {
     return ((rdr.curr == '/' && nextch(rdr) == '/') ||
          (rdr.curr == '/' && nextch(rdr) == '*')) ||
          (rdr.curr == '#' && nextch(rdr) == '!');
 }
 
-fn consume_comment(rdr: string_reader, code_to_the_left: bool,
+fn consume_comment(rdr: @mut StringReader,
+                   code_to_the_left: bool,
                    comments: &mut ~[cmnt]) {
     debug!(">>> consume comment");
     if rdr.curr == '/' && nextch(rdr) == '/' {
@@ -309,8 +311,9 @@ pub fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
     let itr = parse::token::mk_fake_ident_interner();
     let cm = CodeMap::new();
     let filemap = cm.new_filemap(path, src);
-    let rdr = lexer::new_low_level_string_reader(
-        span_diagnostic, filemap, itr);
+    let rdr = lexer::new_low_level_string_reader(span_diagnostic,
+                                                 filemap,
+                                                 itr);
 
     let mut comments: ~[cmnt] = ~[];
     let mut literals: ~[lit] = ~[];
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 07c2a9f5e7e..9ac0093eda6 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -24,45 +24,45 @@ use core::either;
 use core::str;
 use core::u64;
 
-pub use ext::tt::transcribe::{tt_reader, tt_reader_, new_tt_reader};
+pub use ext::tt::transcribe::{TtReader, new_tt_reader};
 
 //use std;
 
 pub trait reader {
-    fn is_eof(&self) -> bool;
-    fn next_token(&self) -> TokenAndSpan;
-    fn fatal(&self,~str) -> !;
-    fn span_diag(&self) -> span_handler;
-    pure fn interner(&self) -> @token::ident_interner;
-    fn peek(&self) -> TokenAndSpan;
-    fn dup(&self) -> reader;
+    fn is_eof(@mut self) -> bool;
+    fn next_token(@mut self) -> TokenAndSpan;
+    fn fatal(@mut self, ~str) -> !;
+    fn span_diag(@mut self) -> span_handler;
+    pure fn interner(@mut self) -> @token::ident_interner;
+    fn peek(@mut self) -> TokenAndSpan;
+    fn dup(@mut self) -> reader;
 }
 
 #[deriving_eq]
 pub struct TokenAndSpan {tok: token::Token, sp: span}
 
-pub type string_reader = @string_reader_;
-pub type string_reader_ = {
+pub struct StringReader {
     span_diagnostic: span_handler,
     src: @~str,
     // The absolute offset within the codemap of the next character to read
-    mut pos: BytePos,
+    pos: BytePos,
     // The absolute offset within the codemap of the last character read(curr)
-    mut last_pos: BytePos,
+    last_pos: BytePos,
     // The column of the next character to read
-    mut col: CharPos,
+    col: CharPos,
     // The last character to be read
-    mut curr: char,
+    curr: char,
     filemap: @codemap::FileMap,
     interner: @token::ident_interner,
     /* cached: */
-    mut peek_tok: token::Token,
-    mut peek_span: span
-};
+    peek_tok: token::Token,
+    peek_span: span
+}
 
 pub fn new_string_reader(span_diagnostic: span_handler,
                          filemap: @codemap::FileMap,
-                         itr: @token::ident_interner) -> string_reader {
+                         itr: @token::ident_interner)
+                      -> @mut StringReader {
     let r = new_low_level_string_reader(span_diagnostic, filemap, itr);
     string_advance_token(r); /* fill in peek_* */
     return r;
@@ -72,18 +72,20 @@ pub fn new_string_reader(span_diagnostic: span_handler,
 pub fn new_low_level_string_reader(span_diagnostic: span_handler,
                                    filemap: @codemap::FileMap,
                                    itr: @token::ident_interner)
-    -> string_reader {
+                                -> @mut StringReader {
     // Force the initial reader bump to start on a fresh line
     let initial_char = '\n';
-    let r = @{span_diagnostic: span_diagnostic, src: filemap.src,
-              mut pos: filemap.start_pos,
-              mut last_pos: filemap.start_pos,
-              mut col: CharPos(0),
-              mut curr: initial_char,
-              filemap: filemap, interner: itr,
-              /* dummy values; not read */
-              mut peek_tok: token::EOF,
-              mut peek_span: codemap::dummy_sp()};
+    let r = @mut StringReader {
+        span_diagnostic: span_diagnostic, src: filemap.src,
+        pos: filemap.start_pos,
+        last_pos: filemap.start_pos,
+        col: CharPos(0),
+        curr: initial_char,
+        filemap: filemap, interner: itr,
+        /* dummy values; not read */
+        peek_tok: token::EOF,
+        peek_span: codemap::dummy_sp()
+    };
     bump(r);
     return r;
 }
@@ -91,58 +93,56 @@ pub fn new_low_level_string_reader(span_diagnostic: span_handler,
 // duplicating the string reader is probably a bad idea, in
 // that using them will cause interleaved pushes of line
 // offsets to the underlying filemap...
-fn dup_string_reader(r: &string_reader_) -> string_reader {
-    @{span_diagnostic: r.span_diagnostic, src: r.src,
-      mut pos: r.pos,
-      mut last_pos: r.last_pos,
-      mut col: r.col, mut curr: r.curr,
-      filemap: r.filemap, interner: r.interner,
-      mut peek_tok: r.peek_tok, mut peek_span: r.peek_span}
+fn dup_string_reader(r: @mut StringReader) -> @mut StringReader {
+    @mut StringReader {
+        span_diagnostic: r.span_diagnostic,
+        src: r.src,
+        pos: r.pos,
+        last_pos: r.last_pos,
+        col: r.col,
+        curr: r.curr,
+        filemap: r.filemap,
+        interner: r.interner,
+        peek_tok: r.peek_tok,
+        peek_span: r.peek_span
+    }
 }
 
-impl string_reader_: reader {
-    fn is_eof(&self) -> bool { is_eof(self) }
+impl StringReader: reader {
+    fn is_eof(@mut self) -> bool { is_eof(self) }
     // return the next token. EFFECT: advances the string_reader.
-    fn next_token(&self) -> TokenAndSpan {
+    fn next_token(@mut self) -> TokenAndSpan {
         let ret_val = TokenAndSpan {tok: self.peek_tok, sp: self.peek_span};
         string_advance_token(self);
         return ret_val;
     }
-    fn fatal(&self, m: ~str) -> ! {
+    fn fatal(@mut self, m: ~str) -> ! {
         self.span_diagnostic.span_fatal(copy self.peek_span, m)
     }
-    fn span_diag(&self) -> span_handler { self.span_diagnostic }
-    pure fn interner(&self) -> @token::ident_interner { self.interner }
-    fn peek(&self) -> TokenAndSpan {
+    fn span_diag(@mut self) -> span_handler { self.span_diagnostic }
+    pure fn interner(@mut self) -> @token::ident_interner { self.interner }
+    fn peek(@mut self) -> TokenAndSpan {
         TokenAndSpan {tok: self.peek_tok, sp: self.peek_span}
     }
-    fn dup(&self) -> reader { dup_string_reader(self) as reader }
+    fn dup(@mut self) -> reader { dup_string_reader(self) as reader }
 }
 
-pub impl tt_reader_: reader {
-    fn is_eof(&self) -> bool { self.cur_tok == token::EOF }
-    fn next_token(&self) -> TokenAndSpan {
-        /* weird resolve bug: if the following `if`, or any of its
-        statements are removed, we get resolution errors */
-        if false {
-            let _ignore_me = 0;
-            let _me_too = self.cur.readme[self.cur.idx];
-        }
-        tt_next_token(self)
-    }
-    fn fatal(&self, m: ~str) -> ! {
+pub impl TtReader: reader {
+    fn is_eof(@mut self) -> bool { self.cur_tok == token::EOF }
+    fn next_token(@mut self) -> TokenAndSpan { tt_next_token(self) }
+    fn fatal(@mut self, m: ~str) -> ! {
         self.sp_diag.span_fatal(copy self.cur_span, m);
     }
-    fn span_diag(&self) -> span_handler { self.sp_diag }
-    pure fn interner(&self) -> @token::ident_interner { self.interner }
-    fn peek(&self) -> TokenAndSpan {
+    fn span_diag(@mut self) -> span_handler { self.sp_diag }
+    pure fn interner(@mut self) -> @token::ident_interner { self.interner }
+    fn peek(@mut self) -> TokenAndSpan {
         TokenAndSpan { tok: self.cur_tok, sp: self.cur_span }
     }
-    fn dup(&self) -> reader { dup_tt_reader(self) as reader }
+    fn dup(@mut self) -> reader { dup_tt_reader(self) as reader }
 }
 
 // EFFECT: advance peek_tok and peek_span to refer to the next token.
-fn string_advance_token(r: &string_reader_) {
+fn string_advance_token(r: @mut StringReader) {
     match (consume_whitespace_and_comments(r)) {
         Some(comment) => {
             r.peek_tok = comment.tok;
@@ -160,11 +160,11 @@ fn string_advance_token(r: &string_reader_) {
     }
 }
 
-fn byte_offset(rdr: &string_reader_) -> BytePos {
+fn byte_offset(rdr: @mut StringReader) -> BytePos {
     (rdr.pos - rdr.filemap.start_pos)
 }
 
-pub fn get_str_from(rdr: &string_reader_, start: BytePos) -> ~str {
+pub fn get_str_from(rdr: @mut StringReader, start: BytePos) -> ~str {
     unsafe {
         // I'm pretty skeptical about this subtraction. What if there's a
         // multi-byte character before the mark?
@@ -175,7 +175,7 @@ pub fn get_str_from(rdr: &string_reader_, start: BytePos) -> ~str {
 
 // 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: &string_reader_) {
+pub fn bump(rdr: @mut StringReader) {
     rdr.last_pos = rdr.pos;
     let current_byte_offset = byte_offset(rdr).to_uint();;
     if current_byte_offset < (*rdr.src).len() {
@@ -199,10 +199,10 @@ pub fn bump(rdr: &string_reader_) {
         rdr.curr = -1 as char;
     }
 }
-pub fn is_eof(rdr: &string_reader_) -> bool {
+pub fn is_eof(rdr: @mut StringReader) -> bool {
     rdr.curr == -1 as char
 }
-pub fn nextch(rdr: &string_reader_) -> char {
+pub fn nextch(rdr: @mut StringReader) -> char {
     let offset = byte_offset(rdr).to_uint();
     if offset < (*rdr.src).len() {
         return str::char_at(*rdr.src, offset);
@@ -247,8 +247,8 @@ fn is_bin_digit(c: char) -> bool { return c == '0' || c == '1'; }
 
 // EFFECT: eats whitespace and comments.
 // returns a Some(sugared-doc-attr) if one exists, None otherwise.
-fn consume_whitespace_and_comments(rdr: &string_reader_)
-    -> Option<TokenAndSpan> {
+fn consume_whitespace_and_comments(rdr: @mut StringReader)
+                                -> Option<TokenAndSpan> {
     while is_whitespace(rdr.curr) { bump(rdr); }
     return consume_any_line_comment(rdr);
 }
@@ -256,8 +256,8 @@ fn consume_whitespace_and_comments(rdr: &string_reader_)
 // PRECONDITION: rdr.curr is not whitespace
 // EFFECT: eats any kind of comment.
 // returns a Some(sugared-doc-attr) if one exists, None otherwise
-fn consume_any_line_comment(rdr: &string_reader_)
-                                -> Option<TokenAndSpan> {
+fn consume_any_line_comment(rdr: @mut StringReader)
+                         -> Option<TokenAndSpan> {
     if rdr.curr == '/' {
         match nextch(rdr) {
           '/' => {
@@ -299,9 +299,8 @@ fn consume_any_line_comment(rdr: &string_reader_)
 }
 
 // might return a sugared-doc-attr
-fn consume_block_comment(rdr: &string_reader_)
-                                -> Option<TokenAndSpan> {
-
+fn consume_block_comment(rdr: @mut StringReader)
+                      -> Option<TokenAndSpan> {
     // block comments starting with "/**" or "/*!" are doc-comments
     if rdr.curr == '*' || rdr.curr == '!' {
         let start_bpos = rdr.pos - BytePos(2u);
@@ -338,7 +337,7 @@ fn consume_block_comment(rdr: &string_reader_)
     return consume_whitespace_and_comments(rdr);
 }
 
-fn scan_exponent(rdr: &string_reader_) -> Option<~str> {
+fn scan_exponent(rdr: @mut StringReader) -> Option<~str> {
     let mut c = rdr.curr;
     let mut rslt = ~"";
     if c == 'e' || c == 'E' {
@@ -356,7 +355,7 @@ fn scan_exponent(rdr: &string_reader_) -> Option<~str> {
     } else { return None::<~str>; }
 }
 
-fn scan_digits(rdr: &string_reader_, radix: uint) -> ~str {
+fn scan_digits(rdr: @mut StringReader, radix: uint) -> ~str {
     let mut rslt = ~"";
     loop {
         let c = rdr.curr;
@@ -371,7 +370,7 @@ fn scan_digits(rdr: &string_reader_, radix: uint) -> ~str {
     };
 }
 
-fn scan_number(c: char, rdr: &string_reader_) -> token::Token {
+fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
     let mut num_str, base = 10u, c = c, n = nextch(rdr);
     if c == '0' && n == 'x' {
         bump(rdr);
@@ -487,7 +486,7 @@ fn scan_number(c: char, rdr: &string_reader_) -> token::Token {
     }
 }
 
-fn scan_numeric_escape(rdr: &string_reader_, n_hex_digits: uint) -> char {
+fn scan_numeric_escape(rdr: @mut StringReader, n_hex_digits: uint) -> char {
     let mut accum_int = 0, i = n_hex_digits;
     while i != 0u {
         let n = rdr.curr;
@@ -502,7 +501,7 @@ fn scan_numeric_escape(rdr: &string_reader_, n_hex_digits: uint) -> char {
     return accum_int as char;
 }
 
-fn next_token_inner(rdr: &string_reader_) -> token::Token {
+fn next_token_inner(rdr: @mut StringReader) -> token::Token {
     let mut accum_str = ~"";
     let mut c = rdr.curr;
     if (c >= 'a' && c <= 'z')
@@ -527,7 +526,7 @@ fn next_token_inner(rdr: &string_reader_) -> token::Token {
     if is_dec_digit(c) {
         return scan_number(c, rdr);
     }
-    fn binop(rdr: &string_reader_, op: token::binop) -> token::Token {
+    fn binop(rdr: @mut StringReader, op: token::binop) -> token::Token {
         bump(rdr);
         if rdr.curr == '=' {
             bump(rdr);
@@ -720,7 +719,7 @@ fn next_token_inner(rdr: &string_reader_) -> token::Token {
     }
 }
 
-fn consume_whitespace(rdr: &string_reader_) {
+fn consume_whitespace(rdr: @mut StringReader) {
     while is_whitespace(rdr.curr) && !is_eof(rdr) { bump(rdr); }
 }
 
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 6169233c1b7..b8e671b3265 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -15,9 +15,9 @@ use ast::node_id;
 use ast;
 use codemap::{span, CodeMap, FileMap, CharPos, BytePos};
 use codemap;
-use diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
+use diagnostic::{span_handler, mk_span_handler, mk_handler, Emitter};
 use parse::attr::parser_attr;
-use parse::lexer::{reader, string_reader};
+use parse::lexer::{reader, StringReader};
 use parse::parser::Parser;
 use parse::token::{ident_interner, mk_ident_interner};
 use util::interner;
@@ -54,7 +54,7 @@ pub type parse_sess = @{
     interner: @ident_interner,
 };
 
-pub fn new_parse_sess(demitter: Option<emitter>) -> parse_sess {
+pub fn new_parse_sess(demitter: Option<Emitter>) -> parse_sess {
     let cm = @CodeMap::new();
     return @{cm: cm,
              mut next_id: 1,
@@ -166,18 +166,22 @@ pub fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
                               +name: ~str, +ss: codemap::FileSubstr,
                               source: @~str) -> Parser {
     let filemap = sess.cm.new_filemap_w_substr(name, ss, source);
-    let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap,
+    let srdr = lexer::new_string_reader(sess.span_diagnostic,
+                                        filemap,
                                         sess.interner);
     return Parser(sess, cfg, srdr as reader);
 }
 
-pub fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg,
-                        path: &Path) -> Result<Parser, ~str> {
+pub fn new_parser_from_file(sess: parse_sess,
+                            cfg: ast::crate_cfg,
+                            path: &Path)
+                         -> Result<Parser, ~str> {
     match io::read_whole_file_str(path) {
       result::Ok(move src) => {
 
           let filemap = sess.cm.new_filemap(path.to_str(), @move src);
-          let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap,
+          let srdr = lexer::new_string_reader(sess.span_diagnostic,
+                                              filemap,
                                               sess.interner);
 
           Ok(Parser(sess, cfg, srdr as reader))