This commit causes an ICE.

Author: paulstansifer

src/libsyntax/ext/qquote.rs

@@ -5,6 +5,7 @@ import visit::*;
 import ext::base::*;
 import ext::build::*;
 import parse::parser;
+import parse::lexer::{reader,lexer};
 import parse::parser::parse_from_source_str;
 import dvec::{dvec, extensions};
 
@@ -163,21 +164,21 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
     };
 }
 
-fn parse_crate(p: parser) -> @ast::crate { p.parse_crate_mod([]) }
-fn parse_ty(p: parser) -> @ast::ty { p.parse_ty(false) }
-fn parse_stmt(p: parser) -> @ast::stmt { p.parse_stmt([]) }
-fn parse_expr(p: parser) -> @ast::expr { p.parse_expr() }
-fn parse_pat(p: parser) -> @ast::pat { p.parse_pat() }
+fn parse_crate(p: parser<reader>) -> @ast::crate { p.parse_crate_mod([]) }
+fn parse_ty(p: parser<reader>) -> @ast::ty { p.parse_ty(false) }
+fn parse_stmt(p: parser<reader>) -> @ast::stmt { p.parse_stmt([]) }
+fn parse_expr(p: parser<reader>) -> @ast::expr { p.parse_expr() }
+fn parse_pat(p: parser<reader>) -> @ast::pat { p.parse_pat() }
 
-fn parse_item(p: parser) -> @ast::item {
+fn parse_item(p: parser<reader>) -> @ast::item {
     alt p.parse_item([], ast::public) {
       some(item) { item }
       none       { fail "parse_item: parsing an item failed"; }
     }
 }
 
 fn finish<T: qq_helper>
-    (ecx: ext_ctxt, body: ast::mac_body_, f: fn (p: parser) -> T)
+    (ecx: ext_ctxt, body: ast::mac_body_, f: fn (p: parser<reader>) -> T)
     -> @ast::expr
 {
     let cm = ecx.codemap();

src/libsyntax/parse.rs

@@ -17,7 +17,7 @@ import attr::parser_attr;
 import common::parser_common;
 import ast::node_id;
 import util::interner;
-import lexer::reader;
+import lexer::{reader,lexer};
 
 type parse_sess = @{
     cm: codemap::codemap,
@@ -44,13 +44,13 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
                                sess: parse_sess) -> @ast::crate {
     let p = new_parser_from_file(sess, cfg, input, parser::CRATE_FILE);
     let lo = p.span.lo;
-    let prefix = path::dirname(p.reader.filemap.name);
+    let prefix = path::dirname(input);
     let leading_attrs = p.parse_inner_attrs_and_next();
     let crate_attrs = leading_attrs.inner;
     let first_cdir_attr = leading_attrs.next;
     let cdirs = p.parse_crate_directives(token::EOF, first_cdir_attr);
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.bpos();
     let cx =
         @{sess: sess,
           cfg: p.cfg};
@@ -71,17 +71,17 @@ fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg,
     let p = new_parser_from_file(sess, cfg, input, parser::SOURCE_FILE);
     let r = p.parse_crate_mod(cfg);
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.bpos();
     ret r;
 }
 
 fn parse_crate_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
                                sess: parse_sess) -> @ast::crate {
-    let p = new_parser_from_source_str(
-        sess, cfg, name, codemap::fss_none, source);
+    let p = new_parser_from_source_str(sess, cfg, name, codemap::fss_none,
+                                       source);
     let r = p.parse_crate_mod(cfg);
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.bpos();
     ret r;
 }
 
@@ -91,7 +91,7 @@ fn parse_expr_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
         sess, cfg, name, codemap::fss_none, source);
     let r = p.parse_expr();
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.bpos();
     ret r;
 }
 
@@ -102,11 +102,11 @@ fn parse_item_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
         sess, cfg, name, codemap::fss_none, source);
     let r = p.parse_item(attrs, vis);
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.bpos();
     ret r;
 }
 
-fn parse_from_source_str<T>(f: fn (p: parser) -> T,
+fn parse_from_source_str<T>(f: fn (p: parser<reader>) -> T,
                             name: str, ss: codemap::file_substr,
                             source: @str, cfg: ast::crate_cfg,
                             sess: parse_sess)
@@ -118,7 +118,7 @@ fn parse_from_source_str<T>(f: fn (p: parser) -> T,
         p.reader.fatal("expected end-of-string");
     }
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.bpos();
     ret r;
 }
 
@@ -132,7 +132,7 @@ fn next_node_id(sess: parse_sess) -> node_id {
 
 fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
                               name: str, ss: codemap::file_substr,
-                              source: @str) -> parser {
+                              source: @str) -> parser<reader> {
     let ftype = parser::SOURCE_FILE;
     let filemap = codemap::new_filemap_w_substr
         (name, ss, source, sess.chpos, sess.byte_pos);
@@ -145,7 +145,7 @@ fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
 
 fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
                         ftype: parser::file_type) ->
-   parser {
+   parser<reader> {
     let src = alt io::read_whole_file_str(path) {
       result::ok(src) {
         // FIXME: This copy is unfortunate (#2319)
@@ -155,8 +155,7 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
         sess.span_diagnostic.handler().fatal(e)
       }
     };
-    let filemap = codemap::new_filemap(path, src,
-                                       sess.chpos, sess.byte_pos);
+    let filemap = codemap::new_filemap(path, src, sess.chpos, sess.byte_pos);
     sess.cm.files.push(filemap);
     let itr = @interner::mk(str::hash, str::eq);
     let rdr = lexer::new_reader(sess.span_diagnostic, filemap, itr);

src/libsyntax/parse/attr.rs

@@ -9,118 +9,11 @@ export parser_attr;
 // extensions, which both begin with token.POUND
 type attr_or_ext = option<either<[ast::attribute], @ast::expr>>;
 
-impl parser_attr for parser {
 
-    fn parse_outer_attrs_or_ext(first_item_attrs: [ast::attribute])
-        -> attr_or_ext
-    {
-        let expect_item_next = vec::is_not_empty(first_item_attrs);
-        if self.token == token::POUND {
-            let lo = self.span.lo;
-            if self.look_ahead(1u) == token::LBRACKET {
-                self.bump();
-                let first_attr =
-                    self.parse_attribute_naked(ast::attr_outer, lo);
-                ret some(left([first_attr] + self.parse_outer_attributes()));
-            } else if !(self.look_ahead(1u) == token::LT
-                        || self.look_ahead(1u) == token::LBRACKET
-                        || self.look_ahead(1u) == token::POUND
-                        || expect_item_next) {
-                self.bump();
-                ret some(right(self.parse_syntax_ext_naked(lo)));
-            } else { ret none; }
-        } else { ret none; }
-    }
+type parser_attr = int;
+/*impl parser_attr<L: lexer> for parser<L> {
 
-    // Parse attributes that appear before an item
-    fn parse_outer_attributes() -> [ast::attribute] {
-        let mut attrs: [ast::attribute] = [];
-        while self.token == token::POUND
-            && self.look_ahead(1u) == token::LBRACKET {
-            attrs += [self.parse_attribute(ast::attr_outer)];
-        }
-        ret attrs;
-    }
-
-    fn parse_attribute(style: ast::attr_style) -> ast::attribute {
-        let lo = self.span.lo;
-        self.expect(token::POUND);
-        ret self.parse_attribute_naked(style, lo);
-    }
-
-    fn parse_attribute_naked(style: ast::attr_style, lo: uint) ->
-        ast::attribute {
-        self.expect(token::LBRACKET);
-        let meta_item = self.parse_meta_item();
-        self.expect(token::RBRACKET);
-        let mut hi = self.span.hi;
-        ret spanned(lo, hi, {style: style, value: *meta_item});
-    }
-
-    // Parse attributes that appear after the opening of an item, each
-    // terminated by a semicolon. In addition to a vector of inner attributes,
-    // this function also returns a vector that may contain the first outer
-    // attribute of the next item (since we can't know whether the attribute
-    // is an inner attribute of the containing item or an outer attribute of
-    // the first contained item until we see the semi).
-    fn parse_inner_attrs_and_next() ->
-        {inner: [ast::attribute], next: [ast::attribute]} {
-        let mut inner_attrs: [ast::attribute] = [];
-        let mut next_outer_attrs: [ast::attribute] = [];
-        while self.token == token::POUND {
-            if self.look_ahead(1u) != token::LBRACKET {
-                // This is an extension
-                break;
-            }
-            let attr = self.parse_attribute(ast::attr_inner);
-            if self.token == token::SEMI {
-                self.bump();
-                inner_attrs += [attr];
-            } else {
-                // It's not really an inner attribute
-                let outer_attr =
-                    spanned(attr.span.lo, attr.span.hi,
-                            {style: ast::attr_outer, value: attr.node.value});
-                next_outer_attrs += [outer_attr];
-                break;
-            }
-        }
-        ret {inner: inner_attrs, next: next_outer_attrs};
-    }
-
-    fn parse_meta_item() -> @ast::meta_item {
-        let lo = self.span.lo;
-        let ident = self.parse_ident();
-        alt self.token {
-          token::EQ {
-            self.bump();
-            let lit = self.parse_lit();
-            let mut hi = self.span.hi;
-            ret @spanned(lo, hi, ast::meta_name_value(ident, lit));
-          }
-          token::LPAREN {
-            let inner_items = self.parse_meta_seq();
-            let mut hi = self.span.hi;
-            ret @spanned(lo, hi, ast::meta_list(ident, inner_items));
-          }
-          _ {
-            let mut hi = self.span.hi;
-            ret @spanned(lo, hi, ast::meta_word(ident));
-          }
-        }
-    }
-
-    fn parse_meta_seq() -> [@ast::meta_item] {
-        ret self.parse_seq(token::LPAREN, token::RPAREN,
-                           seq_sep(token::COMMA),
-                           {|p| p.parse_meta_item()}).node;
-    }
-
-    fn parse_optional_meta() -> [@ast::meta_item] {
-        alt self.token { token::LPAREN { ret self.parse_meta_seq(); }
-                         _ { ret []; } }
-    }
-}
+}*/
 
 //
 // Local Variables:

src/libsyntax/parse/comments.rs

@@ -1,7 +1,7 @@
 import io::reader_util;
 import io::println;//XXXXXXXXxxx
 import util::interner;
-import lexer::{ reader, new_reader, next_token, is_whitespace };
+import lexer::{ reader, nextch, new_reader, is_whitespace };
 
 export cmnt;
 export lit;
@@ -68,7 +68,7 @@ fn read_line_comments(rdr: reader, code_to_the_left: bool) -> cmnt {
     #debug(">>> line comments");
     let p = rdr.chpos;
     let mut lines: [str] = [];
-    while rdr.curr == '/' && rdr.next() == '/' {
+    while rdr.curr == '/' && nextch(rdr) == '/' {
         let line = read_one_line_comment(rdr);
         log(debug, line);
         lines += [line];
@@ -117,13 +117,13 @@ fn read_block_comment(rdr: reader, code_to_the_left: bool) -> cmnt {
             rdr.bump();
         } else {
             str::push_char(curr_line, rdr.curr);
-            if rdr.curr == '/' && rdr.next() == '*' {
+            if rdr.curr == '/' && nextch(rdr) == '*' {
                 rdr.bump();
                 rdr.bump();
                 curr_line += "*";
                 level += 1;
             } else {
-                if rdr.curr == '*' && rdr.next() == '/' {
+                if rdr.curr == '*' && nextch(rdr) == '/' {
                     rdr.bump();
                     rdr.bump();
                     curr_line += "/";
@@ -145,18 +145,18 @@ fn read_block_comment(rdr: reader, code_to_the_left: bool) -> cmnt {
 }
 
 fn peeking_at_comment(rdr: reader) -> bool {
-    ret ((rdr.curr == '/' && rdr.next() == '/') ||
-         (rdr.curr == '/' && rdr.next() == '*')) ||
-        (rdr.curr == '#' && rdr.next() == '!');
+    ret ((rdr.curr == '/' && nextch(rdr) == '/') ||
+         (rdr.curr == '/' && nextch(rdr) == '*')) ||
+         (rdr.curr == '#' && nextch(rdr) == '!');
 }
 
 fn consume_comment(rdr: reader, code_to_the_left: bool, &comments: [cmnt]) {
     #debug(">>> consume comment");
-    if rdr.curr == '/' && rdr.next() == '/' {
+    if rdr.curr == '/' && nextch(rdr) == '/' {
         comments += [read_line_comments(rdr, code_to_the_left)];
-    } else if rdr.curr == '/' && rdr.next() == '*' {
+    } else if rdr.curr == '/' && nextch(rdr) == '*' {
         comments += [read_block_comment(rdr, code_to_the_left)];
-    } else if rdr.curr == '#' && rdr.next() == '!' {
+    } else if rdr.curr == '#' && nextch(rdr) == '!' {
         comments += [read_shebang_comment(rdr, code_to_the_left)];
     } else { fail; }
     #debug("<<< consume comment");
@@ -189,7 +189,7 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
             }
             break;
         }
-        let tok = next_token(rdr);
+        let tok = rdr.next_token();
         if token::is_lit(tok.tok) {
             let s = rdr.get_str_from(tok.bpos);
             literals += [{lit: s, pos: tok.chpos}];