---

yaml
---
r: 13513
b: refs/heads/master
c: 1e36d21
h: refs/heads/master
i:
  13511: 55a4083
v: v3

Author: paulstansifer

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 85ded92736290073b6c591c2607ee3d829cb2874
+refs/heads/master: 1e36d216bebc9ae5b1bfd2cd013e7e707199cdf7
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/cargo/cargo.rs

@@ -238,15 +238,7 @@ fn load_link(mis: [@ast::meta_item]) -> (option<str>,
 }
 
 fn load_crate(filename: str) -> option<crate> {
-    let cm = codemap::new_codemap();
-    let handler = diagnostic::mk_handler(none);
-    let sess = @{
-        cm: cm,
-        mut next_id: 1,
-        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mut chpos: 0u,
-        mut byte_pos: 0u
-    };
+    let sess = parse::new_parse_sess(none);
     let c = parse::parse_crate_from_crate_file(filename, [], sess);
 
     let mut name = none;

trunk/src/fuzzer/fuzzer.rs

@@ -416,15 +416,7 @@ fn check_compiling(filename: str) -> happiness {
 
 fn parse_and_print(code: @str) -> str {
     let filename = "tmp.rs";
-    let cm = codemap::new_codemap();
-    let handler = diagnostic::mk_handler(none);
-    let sess = @{
-        cm: cm,
-        mut next_id: 1,
-        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mut chpos: 0u,
-        mut byte_pos: 0u
-    };
+    let sess = parse::new_parse_sess(option::none);
     write_file(filename, *code);
     let crate = parse::parse_crate_from_source_str(
         filename, code, [], sess);
@@ -566,15 +558,7 @@ fn check_variants(files: [str], cx: context) {
         }
 
         log(error, "check_variants: " + file);
-        let cm = codemap::new_codemap();
-        let handler = diagnostic::mk_handler(none);
-        let sess = @{
-            cm: cm,
-            mut next_id: 1,
-            span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-            mut chpos: 0u,
-            mut byte_pos: 0u
-        };
+        let sess = parse::new_parse_sess(option::none);
         let crate =
             parse::parse_crate_from_source_str(
                 file,

trunk/src/libsyntax/ext/expand.rs

@@ -49,6 +49,10 @@ fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt,
                   }
                 }
               }
+              /*
+              mac_invoc_tt(path, body) {
+                let p = new_parser_from_tt(cx.sess, cx.cfg, )
+              }*/
               _ { cx.span_bug(mac.span, "naked syntactic bit") }
             }
           }

trunk/src/libsyntax/parse.rs

@@ -2,6 +2,8 @@
 import dvec::extensions;
 
 export parse_sess;
+export new_parse_sess;
+export new_parse_sess_special_handler;
 export next_node_id;
 export new_parser_from_file;
 export new_parser_etc_from_file;
@@ -20,16 +22,38 @@ import ast::node_id;
 import util::interner;
 import lexer::{string_reader_as_reader, tt_reader_as_reader,
                reader, string_reader, tt_reader};
+import diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
 
 type parse_sess = @{
     cm: codemap::codemap,
     mut next_id: node_id,
-    span_diagnostic: diagnostic::span_handler,
+    span_diagnostic: span_handler,
+    interner: @interner::interner<@str>,
     // these two must be kept up to date
     mut chpos: uint,
     mut byte_pos: uint
 };
 
+fn new_parse_sess(demitter: option<emitter>) -> parse_sess {
+    let cm = codemap::new_codemap();
+    ret @{cm: cm,
+          mut next_id: 1,
+          span_diagnostic: mk_span_handler(mk_handler(demitter), cm),
+          interner: @interner::mk::<@str>({|x|str::hash(*x)},
+                                          {|x,y|str::eq(*x, *y)}),
+          mut chpos: 0u, mut byte_pos: 0u};
+}
+
+fn new_parse_sess_special_handler(sh: span_handler, cm: codemap::codemap)
+    -> parse_sess {
+    ret @{cm: cm,
+          mut next_id: 1,
+          span_diagnostic: sh,
+          interner: @interner::mk::<@str>({|x|str::hash(*x)},
+                                          {|x,y|str::eq(*x, *y)}),
+          mut chpos: 0u, mut byte_pos: 0u};
+}
+
 fn parse_crate_from_file(input: str, cfg: ast::crate_cfg, sess: parse_sess) ->
    @ast::crate {
     if str::ends_with(input, ".rc") {
@@ -139,11 +163,8 @@ fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
     let filemap = codemap::new_filemap_w_substr
         (name, ss, source, sess.chpos, sess.byte_pos);
     sess.cm.files.push(filemap);
-    let itr = @interner::mk::<@str>(
-        {|x|str::hash(*x)},
-        {|x,y|str::eq(*x, *y)}
-    );
-    let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap, itr);
+    let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap,
+                                        sess.interner);
     ret (parser(sess, cfg, srdr as reader, ftype), srdr);
 }
 
@@ -166,11 +187,8 @@ fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: str,
     let src = @result::unwrap(res);
     let filemap = codemap::new_filemap(path, src, sess.chpos, sess.byte_pos);
     sess.cm.files.push(filemap);
-    let itr = @interner::mk::<@str>(
-        {|x|str::hash(*x)},
-        {|x,y|str::eq(*x, *y)}
-    );
-    let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap, itr);
+    let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap,
+                                        sess.interner);
     ret (parser(sess, cfg, srdr as reader, ftype), srdr);
 }
 
@@ -181,8 +199,7 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: str,
 }
 
 fn new_parser_from_tt(sess: parse_sess, cfg: ast::crate_cfg,
-                      itr: @interner::interner<@str>, tt: ast::token_tree)
-    -> parser {
-    let trdr = lexer::new_tt_reader(sess.span_diagnostic, itr, tt);
+                      tt: ast::token_tree) -> parser {
+    let trdr = lexer::new_tt_reader(sess.span_diagnostic, sess.interner, tt);
     ret parser(sess, cfg, trdr as reader, parser::SOURCE_FILE)
 }

trunk/src/rustc/driver/driver.rs

@@ -508,8 +508,7 @@ fn build_session(sopts: @session::options,
 }
 
 fn build_session_(
-    sopts: @session::options,
-    codemap: codemap::codemap,
+    sopts: @session::options, cm: codemap::codemap,
     demitter: diagnostic::emitter,
     span_diagnostic_handler: diagnostic::span_handler
 ) -> session {
@@ -523,14 +522,9 @@ fn build_session_(
     @{targ_cfg: target_cfg,
       opts: sopts,
       cstore: cstore,
-      parse_sess: @{
-          cm: codemap,
-          mut next_id: 1,
-          span_diagnostic: span_diagnostic_handler,
-          mut chpos: 0u,
-          mut byte_pos: 0u
-      },
-      codemap: codemap,
+      parse_sess:
+          parse::new_parse_sess_special_handler(span_diagnostic_handler, cm),
+      codemap: cm,
       // For a library crate, this is always none
       mut main_fn: none,
       span_diagnostic: span_diagnostic_handler,

trunk/src/rustc/middle/astencode.rs

@@ -1018,20 +1018,6 @@ fn decode_item_ast(par_doc: ebml::doc) -> @ast::item {
     @ast::deserialize_item(d)
 }
 
-#[cfg(test)]
-fn new_parse_sess() -> parse::parse_sess {
-    let cm = codemap::new_codemap();
-    let handler = diagnostic::mk_handler(option::none);
-    let sess = @{
-        cm: cm,
-        mut next_id: 1,
-        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mut chpos: 0u,
-        mut byte_pos: 0u
-    };
-    ret sess;
-}
-
 #[cfg(test)]
 iface fake_ext_ctxt {
     fn cfg() -> ast::crate_cfg;
@@ -1044,7 +1030,7 @@ type fake_session = ();
 #[cfg(test)]
 impl of fake_ext_ctxt for fake_session {
     fn cfg() -> ast::crate_cfg { [] }
-    fn parse_sess() -> parse::parse_sess { new_parse_sess() }
+    fn parse_sess() -> parse::parse_sess { parse::new_parse_sess(none) }
 }
 
 #[cfg(test)]

trunk/src/rustdoc/attr_parser.rs

@@ -27,15 +27,7 @@ mod test {
         import syntax::codemap;
         import syntax::diagnostic;
 
-        let cm = codemap::new_codemap();
-        let handler = diagnostic::mk_handler(none);
-        let parse_sess = @{
-            cm: cm,
-            mut next_id: 0,
-            span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-            mut chpos: 0u,
-            mut byte_pos: 0u
-        };
+        let parse_sess = syntax::parse::new_parse_sess(none);
         let parser = parse::new_parser_from_source_str(
             parse_sess, [], "-", codemap::fss_none, @source);
 

trunk/src/rustdoc/parse.rs

@@ -10,27 +10,14 @@ import syntax::parse;
 
 export from_file, from_str, from_file_sess, from_str_sess;
 
-fn new_parse_sess() -> parse::parse_sess {
-    let cm = codemap::new_codemap();
-    let handler = diagnostic::mk_handler(none);
-    let sess = @{
-        cm: cm,
-        mut next_id: 1,
-        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mut chpos: 0u,
-        mut byte_pos: 0u
-    };
-    ret sess;
-}
-
 fn from_file(file: str) -> @ast::crate {
     parse::parse_crate_from_file(
-        file, [], new_parse_sess())
+        file, [], parse::new_parse_sess(none))
 }
 
 fn from_str(source: str) -> @ast::crate {
     parse::parse_crate_from_source_str(
-        "-", @source, [], new_parse_sess())
+        "-", @source, [], parse::new_parse_sess(none))
 }
 
 fn from_file_sess(sess: session::session, file: str) -> @ast::crate {

trunk/src/test/run-pass-fulldeps/qquote.rs

@@ -11,19 +11,6 @@ import syntax::codemap;
 import syntax::parse;
 import syntax::print::*;
 
-fn new_parse_sess() -> parse::parse_sess {
-    let cm = codemap::new_codemap();
-    let handler = diagnostic::mk_handler(option::none);
-    let sess = @{
-        cm: cm,
-        mut next_id: 1,
-        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mut chpos: 0u,
-        mut byte_pos: 0u
-    };
-    ret sess;
-}
-
 iface fake_ext_ctxt {
     fn cfg() -> ast::crate_cfg;
     fn parse_sess() -> parse::parse_sess;
@@ -33,7 +20,7 @@ type fake_session = ();
 
 impl of fake_ext_ctxt for fake_session {
     fn cfg() -> ast::crate_cfg { [] }
-    fn parse_sess() -> parse::parse_sess { new_parse_sess() }
+    fn parse_sess() -> parse::parse_sess { parse::new_parse_sess(none) }
 }
 
 fn mk_ctxt() -> fake_ext_ctxt {