Centralize ident interner generation.

Author: paulstansifer

src/fuzzer/fuzzer.rs

@@ -260,8 +260,7 @@ fn check_variants_T<T: copy>(
                     @as_str(|a|pprust::print_crate(
                         codemap,
                         // Assuming we're not generating any token_trees
-                        syntax::util::interner::mk::<@~str>(
-                            |x| str::hash(*x), |x,y| str::eq(*x,*y)),
+                        syntax::parse::token::mk_ident_interner(),
                         diagnostic::mk_span_handler(handler, codemap),
                         crate2,
                         filename,
@@ -423,8 +422,7 @@ fn parse_and_print(code: @~str) -> ~str {
                pprust::print_crate(
                    sess.cm,
                    // Assuming there are no token_trees
-                   syntax::util::interner::mk::<@~str>(
-                       |x| str::hash(*x), |x,y| str::eq(*x,*y)),
+                   syntax::parse::token::mk_ident_interner(),
                    sess.span_diagnostic,
                    crate,
                    filename,
@@ -572,8 +570,7 @@ fn check_variants(files: ~[~str], cx: context) {
                    as_str(|a| pprust::print_crate(
                        sess.cm,
                        // Assuming no token_trees
-                       syntax::util::interner::mk::<@~str>(
-                            |x| str::hash(*x), |x,y| str::eq(*x,*y)),
+                       syntax::parse::token::mk_ident_interner(),
                        sess.span_diagnostic,
                        crate,
                        file,

src/libsyntax/ext/tt/transcribe.rs

@@ -1,9 +1,9 @@
-import util::interner::interner;
 import diagnostic::span_handler;
 import ast::{token_tree, tt_delim, tt_tok, tt_seq, tt_nonterminal,ident};
 import earley_parser::{named_match, matched_seq, matched_nonterminal};
 import codemap::span;
-import parse::token::{EOF, INTERPOLATED, IDENT, token, nt_ident};
+import parse::token::{EOF, INTERPOLATED, IDENT, token, nt_ident,
+                      ident_interner};
 import std::map::{hashmap, box_str_hash};
 
 export tt_reader,  new_tt_reader, dup_tt_reader, tt_next_token;
@@ -25,7 +25,7 @@ type tt_frame = @{
 
 type tt_reader = @{
     sp_diag: span_handler,
-    interner: interner<@~str>,
+    interner: ident_interner,
     mut cur: tt_frame,
     /* for MBE-style macro transcription */
     interpolations: std::map::hashmap<ident, @named_match>,
@@ -39,7 +39,7 @@ type tt_reader = @{
 /** This can do Macro-By-Example transcription. On the other hand, if
  *  `src` contains no `tt_seq`s and `tt_nonterminal`s, `interp` can (and
  *  should) be none. */
-fn new_tt_reader(sp_diag: span_handler, itr: interner<@~str>,
+fn new_tt_reader(sp_diag: span_handler, itr: ident_interner,
                  interp: option<std::map::hashmap<ident,@named_match>>,
                  src: ~[ast::token_tree])
     -> tt_reader {

src/libsyntax/parse.rs

@@ -19,12 +19,13 @@ import ast::node_id;
 import util::interner;
 import diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
 import lexer::{reader, string_reader};
+import parse::token::{ident_interner, mk_ident_interner};
 
 type parse_sess = @{
     cm: codemap::codemap,
     mut next_id: node_id,
     span_diagnostic: span_handler,
-    interner: interner::interner<@~str>,
+    interner: ident_interner,
     // these two must be kept up to date
     mut chpos: uint,
     mut byte_pos: uint
@@ -33,21 +34,19 @@ type parse_sess = @{
 fn new_parse_sess(demitter: option<emitter>) -> parse_sess {
     let cm = codemap::new_codemap();
     return @{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};
+             mut next_id: 1,
+             span_diagnostic: mk_span_handler(mk_handler(demitter), cm),
+             interner: mk_ident_interner(),
+             mut chpos: 0u, mut byte_pos: 0u};
 }
 
 fn new_parse_sess_special_handler(sh: span_handler, cm: codemap::codemap)
     -> parse_sess {
     return @{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};
+             mut next_id: 1,
+             span_diagnostic: sh,
+             interner: mk_ident_interner(),
+             mut chpos: 0u, mut byte_pos: 0u};
 }
 
 fn parse_crate_from_file(input: ~str, cfg: ast::crate_cfg,

src/libsyntax/parse/comments.rs

@@ -276,10 +276,7 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
                                 srdr: io::Reader) ->
    {cmnts: ~[cmnt], lits: ~[lit]} {
     let src = @str::from_bytes(srdr.read_whole_stream());
-    let itr = interner::mk::<@~str>(
-        |x| str::hash(*x),
-        |x,y| str::eq(*x, *y)
-    );
+    let itr = parse::token::mk_ident_interner();
     let rdr = lexer::new_low_level_string_reader
         (span_diagnostic, codemap::new_filemap(path, src, 0u, 0u), itr);
 

src/libsyntax/parse/lexer.rs

@@ -1,4 +1,3 @@
-import util::interner::interner;
 import diagnostic::span_handler;
 import codemap::span;
 import ext::tt::transcribe::{tt_reader,  new_tt_reader, dup_tt_reader,
@@ -14,7 +13,7 @@ trait reader {
     fn next_token() -> {tok: token::token, sp: span};
     fn fatal(~str) -> !;
     fn span_diag() -> span_handler;
-    pure fn interner() -> interner<@~str>;
+    pure fn interner() -> token::ident_interner;
     fn peek() -> {tok: token::token, sp: span};
     fn dup() -> reader;
 }
@@ -27,15 +26,15 @@ type string_reader = @{
     mut curr: char,
     mut chpos: uint,
     filemap: codemap::filemap,
-    interner: interner<@~str>,
+    interner: token::ident_interner,
     /* cached: */
     mut peek_tok: token::token,
     mut peek_span: span
 };
 
 fn new_string_reader(span_diagnostic: span_handler,
                      filemap: codemap::filemap,
-                     itr: interner<@~str>) -> string_reader {
+                     itr: token::ident_interner) -> string_reader {
     let r = new_low_level_string_reader(span_diagnostic, filemap, itr);
     string_advance_token(r); /* fill in peek_* */
     return r;
@@ -44,7 +43,7 @@ fn new_string_reader(span_diagnostic: span_handler,
 /* For comments.rs, which hackily pokes into 'pos' and 'curr' */
 fn new_low_level_string_reader(span_diagnostic: span_handler,
                                filemap: codemap::filemap,
-                               itr: interner<@~str>)
+                               itr: token::ident_interner)
     -> string_reader {
     let r = @{span_diagnostic: span_diagnostic, src: filemap.src,
               mut col: 0u, mut pos: 0u, mut curr: -1 as char,
@@ -79,7 +78,7 @@ impl string_reader: reader {
         self.span_diagnostic.span_fatal(copy self.peek_span, m)
     }
     fn span_diag() -> span_handler { self.span_diagnostic }
-    pure fn interner() -> interner<@~str> { self.interner }
+    pure fn interner() -> token::ident_interner { self.interner }
     fn peek() -> {tok: token::token, sp: span} {
         {tok: self.peek_tok, sp: self.peek_span}
     }
@@ -101,7 +100,7 @@ impl tt_reader: reader {
         self.sp_diag.span_fatal(copy self.cur_span, m);
     }
     fn span_diag() -> span_handler { self.sp_diag }
-    pure fn interner() -> interner<@~str> { self.interner }
+    pure fn interner() -> token::ident_interner { self.interner }
     fn peek() -> {tok: token::token, sp: span} {
         { tok: self.cur_tok, sp: self.cur_span }
     }

src/libsyntax/parse/token.rs

@@ -277,6 +277,14 @@ pure fn is_bar(t: token) -> bool {
     match t { BINOP(OR) | OROR => true, _ => false }
 }
 
+type ident_interner = util::interner::interner<@~str>;
+
+fn mk_ident_interner() -> ident_interner {
+    let rv = @interner::mk::<@~str>(|x| str::hash(*x),
+                                    |x,y| str::eq(*x, *y));
+    rv
+}
+
 /**
  * All the valid words that have meaning in the Rust language.
  *

src/libsyntax/print/pprust.rs

@@ -1,5 +1,4 @@
-import parse::comments;
-import parse::lexer;
+import parse::{comments, lexer, token};
 import codemap::codemap;
 import pp::{break_offset, word, printer,
             space, zerobreak, hardbreak, breaks, consistent,
@@ -30,7 +29,7 @@ fn no_ann() -> pp_ann {
 type ps =
     @{s: pp::printer,
       cm: option<codemap>,
-      intr: interner::interner<@~str>,
+      intr: token::ident_interner,
       comments: option<~[comments::cmnt]>,
       literals: option<~[comments::lit]>,
       mut cur_cmnt: uint,
@@ -51,8 +50,7 @@ fn end(s: ps) {
 fn rust_printer(writer: io::Writer) -> ps {
     return @{s: pp::mk_printer(writer, default_columns),
              cm: none::<codemap>,
-             intr: interner::mk::<@~str>(|x| str::hash(*x),
-                                         |x,y| str::eq(*x, *y)),
+             intr: token::mk_ident_interner(),
              comments: none::<~[comments::cmnt]>,
              literals: none::<~[comments::lit]>,
              mut cur_cmnt: 0u,