syntax: Put the main parser interface in mod parse

Author: brson

src/cargo/cargo.rs

@@ -1,7 +1,7 @@
 // cargo.rs - Rust package manager
 
 import rustc::syntax::{ast, codemap};
-import rustc::syntax::parse::parser;
+import rustc::syntax::parse;
 import rustc::util::filesearch::{get_cargo_root, get_cargo_root_nearest,
                                  get_cargo_sysroot, libdir};
 import rustc::driver::diagnostic;
@@ -119,7 +119,7 @@ fn load_pkg(filename: str) -> option<pkg> {
         mut chpos: 0u,
         mut byte_pos: 0u
     };
-    let c = parser::parse_crate_from_crate_file(filename, [], sess);
+    let c = parse::parse_crate_from_crate_file(filename, [], sess);
 
     let mut name = none;
     let mut vers = none;

src/fuzzer/fuzzer.rs

@@ -1,7 +1,7 @@
 import io::writer_util;
 
 import rustc::syntax::{ast, ast_util, fold, visit, codemap};
-import rustc::syntax::parse::parser;
+import rustc::syntax::parse;
 import rustc::syntax::print::pprust;
 import rustc::driver::diagnostic;
 
@@ -429,7 +429,7 @@ fn parse_and_print(code: @str) -> str {
         mut byte_pos: 0u
     };
     write_file(filename, *code);
-    let crate = parser::parse_crate_from_source_str(
+    let crate = parse::parse_crate_from_source_str(
         filename, code, [], sess);
     io::with_str_reader(*code) { |rdr|
         as_str(bind pprust::print_crate(sess.cm,
@@ -579,7 +579,7 @@ fn check_variants(files: [str], cx: context) {
             mut byte_pos: 0u
         };
         let crate =
-            parser::parse_crate_from_source_str(
+            parse::parse_crate_from_source_str(
                 file,
                 s, [], sess);
         io::with_str_reader(*s) { |rdr|

src/librustsyntax/ext/base.rs

@@ -46,7 +46,7 @@ fn syntax_expander_table() -> hashmap<str, syntax_extension> {
 
 iface ext_ctxt {
     fn codemap() -> codemap;
-    fn parse_sess() -> parser::parse_sess;
+    fn parse_sess() -> parse::parse_sess;
     fn cfg() -> ast::crate_cfg;
     fn print_backtrace();
     fn backtrace() -> expn_info;
@@ -60,14 +60,14 @@ iface ext_ctxt {
     fn next_id() -> ast::node_id;
 }
 
-fn mk_ctxt(parse_sess: parser::parse_sess,
+fn mk_ctxt(parse_sess: parse::parse_sess,
            cfg: ast::crate_cfg) -> ext_ctxt {
-    type ctxt_repr = {parse_sess: parser::parse_sess,
+    type ctxt_repr = {parse_sess: parse::parse_sess,
                       cfg: ast::crate_cfg,
                       mut backtrace: expn_info};
     impl of ext_ctxt for ctxt_repr {
         fn codemap() -> codemap { self.parse_sess.cm }
-        fn parse_sess() -> parser::parse_sess { self.parse_sess }
+        fn parse_sess() -> parse::parse_sess { self.parse_sess }
         fn cfg() -> ast::crate_cfg { self.cfg }
         fn print_backtrace() { }
         fn backtrace() -> expn_info { self.backtrace }
@@ -111,7 +111,7 @@ fn mk_ctxt(parse_sess: parser::parse_sess,
             self.parse_sess.span_diagnostic.handler().bug(msg);
         }
         fn next_id() -> ast::node_id {
-            ret parser::next_node_id(self.parse_sess);
+            ret parse::next_node_id(self.parse_sess);
         }
     }
     let imp : ctxt_repr = {

src/librustsyntax/ext/expand.rs

@@ -5,7 +5,7 @@ import fold::*;
 import ext::base::*;
 import ext::qquote::{qq_helper};
 import parse::parser;
-import parse::parser::parse_expr_from_source_str;
+import parse::parse_expr_from_source_str;
 
 
 import codemap::{span, expanded_from};
@@ -110,7 +110,7 @@ fn core_macros() -> str {
 }";
 }
 
-fn expand_crate(parse_sess: parser::parse_sess,
+fn expand_crate(parse_sess: parse::parse_sess,
                 cfg: ast::crate_cfg, c: @crate) -> @crate {
     let exts = syntax_expander_table();
     let afp = default_ast_fold();

src/librustsyntax/ext/qquote.rs

@@ -5,7 +5,7 @@ import visit::*;
 import ext::base::*;
 import ext::build::*;
 import parse::parser;
-import parse::parser::{parser, parse_from_source_str};
+import parse::parser::parse_from_source_str;
 
 import print::*;
 import io::*;

src/librustsyntax/parse.rs

@@ -0,0 +1,166 @@
+export parse_sess;
+export next_node_id;
+export new_parser_from_file;
+export new_parser_from_source_str;
+export parse_crate_from_file;
+export parse_crate_from_crate_file;
+export parse_crate_from_source_str;
+export parse_expr_from_source_str;
+export parse_from_source_str;
+
+import parser::parser;
+import ast::node_id;
+import util::interner;
+import lexer::reader;
+
+type parse_sess = @{
+    cm: codemap::codemap,
+    mut next_id: node_id,
+    span_diagnostic: diagnostic::span_handler,
+    // these two must be kept up to date
+    mut chpos: uint,
+    mut byte_pos: uint
+};
+
+fn next_node_id(sess: parse_sess) -> node_id {
+    let rv = sess.next_id;
+    sess.next_id += 1;
+    // ID 0 is reserved for the crate and doesn't actually exist in the AST
+    assert rv != 0;
+    ret rv;
+}
+
+fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
+                        ftype: parser::file_type) ->
+   parser {
+    let src = alt io::read_whole_file_str(path) {
+      result::ok(src) {
+        // FIXME: This copy is unfortunate
+        @src
+      }
+      result::err(e) {
+        sess.span_diagnostic.handler().fatal(e)
+      }
+    };
+    let filemap = codemap::new_filemap(path, src,
+                                       sess.chpos, sess.byte_pos);
+    sess.cm.files += [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);
+}
+
+fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
+                              name: str, ss: codemap::file_substr,
+                              source: @str) -> parser {
+    let ftype = parser::SOURCE_FILE;
+    let filemap = codemap::new_filemap_w_substr
+        (name, ss, source, sess.chpos, sess.byte_pos);
+    sess.cm.files += [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);
+}
+
+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,
+      mut buffer: [],
+      mut restriction: parser::UNRESTRICTED,
+      reader: rdr,
+      binop_precs: prec::binop_prec_table(),
+      bad_expr_words: token::bad_expr_word_table()}
+}
+
+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 leading_attrs = parser::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(
+        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,
+          cfg: p.cfg};
+    let (companionmod, _) = path::splitext(path::basename(input));
+    let (m, attrs) = eval::eval_crate_directives_to_mod(
+        cx, cdirs, prefix, option::some(companionmod));
+    let mut hi = p.span.hi;
+    parser::expect(p, token::EOF);
+    ret @ast_util::respan(ast_util::mk_sp(lo, hi),
+                          {directives: cdirs,
+                           module: m,
+                           attrs: crate_attrs + attrs,
+                           config: p.cfg});
+}
+
+fn parse_crate_from_file(input: str, cfg: ast::crate_cfg, sess: parse_sess) ->
+   @ast::crate {
+    if str::ends_with(input, ".rc") {
+        parse_crate_from_crate_file(input, cfg, sess)
+    } else if str::ends_with(input, ".rs") {
+        parse_crate_from_source_file(input, cfg, sess)
+    } else {
+        sess.span_diagnostic.handler().fatal("unknown input file type: " +
+                                             input)
+    }
+}
+
+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);
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    ret r;
+}
+
+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);
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    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 r = parser::parse_crate_mod(p, cfg);
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    ret r;
+}
+
+fn parse_from_source_str<T>(f: fn (p: parser) -> T,
+                            name: str, ss: codemap::file_substr,
+                            source: @str, cfg: ast::crate_cfg,
+                            sess: parse_sess)
+    -> T
+{
+    let p = new_parser_from_source_str(sess, cfg, name, ss, source);
+    let r = f(p);
+    if !p.reader.is_eof() {
+        p.reader.fatal("expected end-of-string");
+    }
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    ret r;
+}

src/librustsyntax/parse/eval.rs

@@ -1,13 +1,13 @@
 import attr;
-import parser::{parser, new_parser_from_file,
+import parser::{parser,
                 parse_inner_attrs_and_next,
                 parse_mod_items, SOURCE_FILE};
 
 export eval_crate_directives_to_mod;
 
 type ctx =
     @{p: parser,
-      sess: parser::parse_sess,
+      sess: parse::parse_sess,
       cfg: ast::crate_cfg};
 
 fn eval_crate_directives(cx: ctx, cdirs: [@ast::crate_directive], prefix: str,