The parser is represented by a class now.

src/librustsyntax/ext/qquote.rs

@@ -49,7 +49,7 @@ impl of qq_helper for @ast::expr {
         }
     }
     fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
-        mk_path(cx, sp, ["syntax", "parse", "parser", "parse_expr"])
+        mk_path(cx, sp, ["syntax", "ext", "qquote", "parse_expr"])
     }
     fn get_fold_fn() -> str {"fold_expr"}
 }
@@ -90,7 +90,7 @@ impl of qq_helper for @ast::pat {
     fn visit(cx: aq_ctxt, v: vt<aq_ctxt>) {visit_pat(self, cx, v);}
     fn extract_mac() -> option<ast::mac_> {fail}
     fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
-        mk_path(cx, sp, ["syntax", "parse", "parser", "parse_pat"])
+        mk_path(cx, sp, ["syntax", "ext", "qquote", "parse_pat"])
     }
     fn get_fold_fn() -> str {"fold_pat"}
 }
@@ -154,29 +154,23 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
 
     ret alt what {
       "crate" {finish(ecx, body, parse_crate)}
-      "expr" {finish(ecx, body, parser::parse_expr)}
+      "expr" {finish(ecx, body, parse_expr)}
       "ty" {finish(ecx, body, parse_ty)}
       "item" {finish(ecx, body, parse_item)}
       "stmt" {finish(ecx, body, parse_stmt)}
-      "pat" {finish(ecx, body, parser::parse_pat)}
+      "pat" {finish(ecx, body, parse_pat)}
       _ {ecx.span_fatal(_sp, "unsupported ast type")}
     };
 }
 
-fn parse_crate(p: parser) -> @ast::crate {
+fn parse_crate(p: parser) -> @ast::crate { p.parse_crate_mod([]) }
-    parser::parse_crate_mod(p, [])
+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_ty(p: parser) -> @ast::ty {
+fn parse_pat(p: parser) -> @ast::pat { p.parse_pat() }
-    parser::parse_ty(p, false)
-}
-
-fn parse_stmt(p: parser) -> @ast::stmt {
-    parser::parse_stmt(p, [])
-}
 
 fn parse_item(p: parser) -> @ast::item {
-    alt parser::parse_item(p, [], ast::public) {
+    alt p.parse_item([], ast::public) {
       some(item) { item }
       none       { fail "parse_item: parsing an item failed"; }
     }

src/librustsyntax/parse.rs

@@ -46,13 +46,11 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
     let leading_attrs = attr::parse_inner_attrs_and_next(p);
     let crate_attrs = leading_attrs.inner;
     let first_cdir_attr = leading_attrs.next;
-    let cdirs = parser::parse_crate_directives(
+    let cdirs = p.parse_crate_directives(token::EOF, first_cdir_attr);
-        p, token::EOF, first_cdir_attr);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
     let cx =
-        @{p: p,
+        @{sess: sess,
-          sess: sess,
           cfg: p.cfg};
     let (companionmod, _) = path::splitext(path::basename(input));
     let (m, attrs) = eval::eval_crate_directives_to_mod(
@@ -69,7 +67,7 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
 fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg,
                                 sess: parse_sess) -> @ast::crate {
     let p = new_parser_from_file(sess, cfg, input, parser::SOURCE_FILE);
-    let r = parser::parse_crate_mod(p, cfg);
+    let r = p.parse_crate_mod(cfg);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
@@ -79,7 +77,7 @@ 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 r = parser::parse_crate_mod(p, cfg);
+    let r = p.parse_crate_mod(cfg);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
@@ -89,7 +87,7 @@ fn parse_expr_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
                               sess: parse_sess) -> @ast::expr {
     let p = new_parser_from_source_str(
         sess, cfg, name, codemap::fss_none, source);
-    let r = parser::parse_expr(p);
+    let r = p.parse_expr();
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
@@ -100,7 +98,7 @@ fn parse_item_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
                               sess: parse_sess) -> option<@ast::item> {
     let p = new_parser_from_source_str(
         sess, cfg, name, codemap::fss_none, source);
-    let r = parser::parse_item(p, attrs, vis);
+    let r = p.parse_item(attrs, vis);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
@@ -130,23 +128,6 @@ fn next_node_id(sess: parse_sess) -> node_id {
     ret rv;
 }
 
-fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
-              ftype: parser::file_type) -> parser {
-    let tok0 = lexer::next_token(rdr);
-    let span0 = ast_util::mk_sp(tok0.chpos, rdr.chpos);
-    @{sess: sess,
-      cfg: cfg,
-      file_type: ftype,
-      mut token: tok0.tok,
-      mut span: span0,
-      mut last_span: span0,
-      buffer: dvec::dvec(),
-      mut restriction: parser::UNRESTRICTED,
-      reader: rdr,
-      keywords: token::keyword_table(),
-      restricted_keywords: token::restricted_keyword_table()}
-}
-
 fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
                               name: str, ss: codemap::file_substr,
                               source: @str) -> parser {
@@ -157,7 +138,7 @@ fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
     let itr = @interner::mk(str::hash, str::eq);
     let rdr = lexer::new_reader(sess.span_diagnostic,
                                 filemap, itr);
-    ret new_parser(sess, cfg, rdr, ftype);
+    ret parser(sess, cfg, rdr, ftype);
 }
 
 fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
@@ -177,5 +158,5 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
     sess.cm.files.push(filemap);
     let itr = @interner::mk(str::hash, str::eq);
     let rdr = lexer::new_reader(sess.span_diagnostic, filemap, itr);
-    ret new_parser(sess, cfg, rdr, ftype);
+    ret parser(sess, cfg, rdr, ftype);
 }

src/librustsyntax/parse/attr.rs

@@ -4,8 +4,6 @@ import common::{parse_seq,
                 seq_sep,
                 expect,
                 parse_ident};
-import parser::{parse_lit,
-                parse_syntax_ext_naked};
 
 export attr_or_ext;
 export parse_outer_attributes;
@@ -31,7 +29,7 @@ fn parse_outer_attrs_or_ext(
                     || p.look_ahead(1u) == token::LBRACKET
                     || expect_item_next) {
             p.bump();
-            ret some(right(parse_syntax_ext_naked(p, lo)));
+            ret some(right(p.parse_syntax_ext_naked(lo)));
         } else { ret none; }
     } else { ret none; }
 }
@@ -97,7 +95,7 @@ fn parse_meta_item(p: parser) -> @ast::meta_item {
     alt p.token {
       token::EQ {
         p.bump();
-        let lit = parse_lit(p);
+        let lit = p.parse_lit();
         let mut hi = p.span.hi;
         ret @spanned(lo, hi, ast::meta_name_value(ident, lit));
       }
@@ -115,7 +113,7 @@ fn parse_meta_item(p: parser) -> @ast::meta_item {
 
 fn parse_meta_seq(p: parser) -> [@ast::meta_item] {
     ret parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
-                  parse_meta_item, p).node;
+                  p, {|p| parse_meta_item(p)}).node;
 }
 
 fn parse_optional_meta(p: parser) -> [@ast::meta_item] {

src/librustsyntax/parse/common.rs

@@ -126,8 +126,7 @@ fn expect_gt(p: parser) {
 }
 
 fn parse_seq_to_before_gt<T: copy>(sep: option<token::token>,
-                                  f: fn(parser) -> T,
+                                   p: parser, f: fn(parser) -> T) -> [T] {
-                                  p: parser) -> [T] {
     let mut first = true;
     let mut v = [];
     while p.token != token::GT && p.token != token::BINOP(token::SHR) {
@@ -142,27 +141,26 @@ fn parse_seq_to_before_gt<T: copy>(sep: option<token::token>,
 }
 
 fn parse_seq_to_gt<T: copy>(sep: option<token::token>,
-                           f: fn(parser) -> T, p: parser) -> [T] {
+                            p: parser, f: fn(parser) -> T) -> [T] {
-    let v = parse_seq_to_before_gt(sep, f, p);
+    let v = parse_seq_to_before_gt(sep, p, f);
     expect_gt(p);
 
     ret v;
 }
 
 fn parse_seq_lt_gt<T: copy>(sep: option<token::token>,
-                           f: fn(parser) -> T,
+                            p: parser, f: fn(parser) -> T) -> spanned<[T]> {
-                           p: parser) -> spanned<[T]> {
     let lo = p.span.lo;
     expect(p, token::LT);
-    let result = parse_seq_to_before_gt::<T>(sep, f, p);
+    let result = parse_seq_to_before_gt::<T>(sep, p, f);
     let hi = p.span.hi;
     expect_gt(p);
     ret spanned(lo, hi, result);
 }
 
-fn parse_seq_to_end<T: copy>(ket: token::token, sep: seq_sep,
+fn parse_seq_to_end<T: copy>(ket: token::token, sep: seq_sep, p: parser,
-                            f: fn(parser) -> T, p: parser) -> [T] {
+                             f: fn(parser) -> T) -> [T] {
-    let val = parse_seq_to_before_end(ket, sep, f, p);
+    let val = parse_seq_to_before_end(ket, sep, p, f);
     p.bump();
     ret val;
 }
@@ -182,9 +180,8 @@ fn seq_sep_none() -> seq_sep {
     ret {sep: option::none, trailing_opt: false};
 }
 
-fn parse_seq_to_before_end<T: copy>(ket: token::token,
+fn parse_seq_to_before_end<T: copy>(ket: token::token, sep: seq_sep,
-                                   sep: seq_sep,
+                                    p: parser, f: fn(parser) -> T) -> [T] {
-                                   f: fn(parser) -> T, p: parser) -> [T] {
     let mut first: bool = true;
     let mut v: [T] = [];
     while p.token != ket {
@@ -198,12 +195,11 @@ fn parse_seq_to_before_end<T: copy>(ket: token::token,
     ret v;
 }
 
-fn parse_seq<T: copy>(bra: token::token, ket: token::token,
+fn parse_seq<T: copy>(bra: token::token, ket: token::token, sep: seq_sep,
-                     sep: seq_sep, f: fn(parser) -> T,
+                      p: parser, f: fn(parser) -> T) -> spanned<[T]> {
-                     p: parser) -> spanned<[T]> {
     let lo = p.span.lo;
     expect(p, bra);
-    let result = parse_seq_to_before_end::<T>(ket, sep, f, p);
+    let result = parse_seq_to_before_end::<T>(ket, sep, p, f);
     let hi = p.span.hi;
     p.bump();
     ret spanned(lo, hi, result);

src/librustsyntax/parse/eval.rs

@@ -1,12 +1,10 @@
-import parser::{parser,
+import parser::{parser, SOURCE_FILE};
-                parse_mod_items, SOURCE_FILE};
 import attr::parse_inner_attrs_and_next;
 
 export eval_crate_directives_to_mod;
 
 type ctx =
-    @{p: parser,
+    @{sess: parse::parse_sess,
-      sess: parse::parse_sess,
       cfg: ast::crate_cfg};
 
 fn eval_crate_directives(cx: ctx, cdirs: [@ast::crate_directive], prefix: str,
@@ -66,11 +64,10 @@ fn parse_companion_mod(cx: ctx, prefix: str, suffix: option<str>)
     #debug("looking for companion mod %s", modpath);
     if file_exists(modpath) {
         #debug("found companion mod");
-        let p0 = new_parser_from_file(cx.sess, cx.cfg, modpath,
+        let p0 = new_parser_from_file(cx.sess, cx.cfg, modpath, SOURCE_FILE);
-                                     SOURCE_FILE);
         let inner_attrs = parse_inner_attrs_and_next(p0);
         let first_item_outer_attrs = inner_attrs.next;
-        let m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs);
+        let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
         cx.sess.chpos = p0.reader.chpos;
         cx.sess.byte_pos = cx.sess.byte_pos + p0.reader.pos;
         ret (m0.view_items, m0.items, inner_attrs.inner);
@@ -103,10 +100,9 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
         let inner_attrs = parse_inner_attrs_and_next(p0);
         let mod_attrs = attrs + inner_attrs.inner;
         let first_item_outer_attrs = inner_attrs.next;
-        let m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs);
+        let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
 
-        let i =
+        let i = p0.mk_item(cdir.span.lo, cdir.span.hi, id,
-            parser::mk_item(p0, cdir.span.lo, cdir.span.hi, id,
                            ast::item_mod(m0), ast::public, mod_attrs);
         // Thread defids, chpos and byte_pos through the parsers
         cx.sess.chpos = p0.reader.chpos;