just use TLS interner

19 files changed, 84 insertions, 75 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 523e4fd8332..2cd8e5dea67 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -81,15 +81,13 @@ pub type Mrk = uint;
 
 impl<S:Encoder> Encodable<S> for ident {
     fn encode(&self, s: &mut S) {
-        let intr = get_ident_interner();
-        s.emit_str(*(*intr).get(*self));
+        s.emit_str(*get_ident_interner().get(*self));
     }
 }
 
 impl<D:Decoder> Decodable<D> for ident {
     fn decode(d: &mut D) -> ident {
-        let intr = get_ident_interner();
-        (*intr).intern(d.read_str())
+        get_ident_interner().intern(d.read_str())
     }
 }
 
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 48cfe61309c..bf9f32b6030 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -19,7 +19,7 @@ use diagnostic::span_handler;
 use ext;
 use parse;
 use parse::token;
-use parse::token::{intern};
+use parse::token::{intern, get_ident_interner};
 
 use core::hashmap::HashMap;
 use core::vec;
@@ -310,10 +310,10 @@ impl ExtCtxt {
         *self.trace_mac = x
     }
     pub fn str_of(&self, id: ast::ident) -> ~str {
-        copy *self.parse_sess.interner.get(id)
+        copy *get_ident_interner().get(id)
     }
     pub fn ident_of(&self, st: &str) -> ast::ident {
-        self.parse_sess.interner.intern(st)
+        get_ident_interner().intern(st)
     }
 }
 
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index 358f4041dd0..cdb57adb7bb 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -15,6 +15,7 @@ use codemap::span;
 use ext::base::*;
 use ext::base;
 use parse::token;
+use parse::token::{get_ident_interner};
 
 pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
@@ -33,7 +34,7 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
             }
         }
     }
-    let res = cx.parse_sess().interner.intern(res_str);
+    let res = get_ident_interner().intern(res_str);
 
     let e = @ast::expr {
         id: cx.next_id(),
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index d42ca684ec0..75602352b3f 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -735,6 +735,7 @@ mod test {
     use codemap;
     use codemap::spanned;
     use parse;
+    use parse::token::{get_ident_interner};
     use core::io;
     use core::option::{None, Some};
     use util::parser_testing::{string_to_item_and_sess};
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 65b29ecaa91..46b1334835f 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -25,6 +25,7 @@ use ext::build::AstBuilder;
 use core::option;
 use core::unstable::extfmt::ct::*;
 use core::vec;
+use parse::token::{get_ident_interner};
 
 pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
@@ -53,7 +54,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                   pieces: ~[Piece], args: ~[@ast::expr])
    -> @ast::expr {
     fn make_path_vec(cx: @ExtCtxt, ident: &str) -> ~[ast::ident] {
-        let intr = cx.parse_sess().interner;
+        let intr = get_ident_interner();
         return ~[intr.intern("std"),
                  intr.intern("unstable"),
                  intr.intern("extfmt"),
@@ -112,7 +113,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
         fn make_conv_struct(cx: @ExtCtxt, sp: span, flags_expr: @ast::expr,
                          width_expr: @ast::expr, precision_expr: @ast::expr,
                          ty_expr: @ast::expr) -> @ast::expr {
-            let intr = cx.parse_sess().interner;
+            let intr = get_ident_interner();
             cx.expr_struct(
                 sp,
                 cx.path_global(sp, make_path_vec(cx, "Conv")),
@@ -255,11 +256,11 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
     let nargs = args.len();
 
     /* 'ident' is the local buffer building up the result of fmt! */
-    let ident = cx.parse_sess().interner.intern("__fmtbuf");
+    let ident = get_ident_interner().intern("__fmtbuf");
     let buf = || cx.expr_ident(fmt_sp, ident);
-    let core_ident = cx.parse_sess().interner.intern("std");
-    let str_ident = cx.parse_sess().interner.intern("str");
-    let push_ident = cx.parse_sess().interner.intern("push_str");
+    let core_ident = get_ident_interner().intern("std");
+    let str_ident = get_ident_interner().intern("str");
+    let push_ident = get_ident_interner().intern("push_str");
     let mut stms = ~[];
 
     /* Translate each piece (portion of the fmt expression) by invoking the
diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs
index 598537c97e8..3ad4f87083f 100644
--- a/src/libsyntax/ext/log_syntax.rs
+++ b/src/libsyntax/ext/log_syntax.rs
@@ -15,6 +15,7 @@ use codemap;
 use ext::base::*;
 use ext::base;
 use print;
+use parse::token::{get_ident_interner};
 
 use core::io;
 use core::vec;
@@ -28,7 +29,7 @@ pub fn expand_syntax_ext(cx: @ExtCtxt,
     io::stdout().write_line(
         print::pprust::tt_to_str(
             ast::tt_delim(vec::to_owned(tt)),
-            cx.parse_sess().interner));
+            get_ident_interner()));
 
     //trivial expression
     MRExpr(@ast::expr {
diff --git a/src/libsyntax/ext/pipes/mod.rs b/src/libsyntax/ext/pipes/mod.rs
index 46de21d1c0b..906fa08bad7 100644
--- a/src/libsyntax/ext/pipes/mod.rs
+++ b/src/libsyntax/ext/pipes/mod.rs
@@ -52,7 +52,7 @@ use ext::pipes::pipec::gen_init;
 use ext::pipes::proto::visit;
 use parse::lexer::{new_tt_reader, reader};
 use parse::parser::Parser;
-
+use parse::token::{get_ident_interner};
 use core::option::None;
 
 pub mod ast_builder;
@@ -68,7 +68,7 @@ pub fn expand_proto(cx: @ExtCtxt, _sp: span, id: ast::ident,
     let sess = cx.parse_sess();
     let cfg = cx.cfg();
     let tt_rdr = new_tt_reader(copy cx.parse_sess().span_diagnostic,
-                               cx.parse_sess().interner,
+                               get_ident_interner(),
                                None,
                                copy tt);
     let rdr = tt_rdr as @reader;
diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs
index 67ef3347ff7..732094655f2 100644
--- a/src/libsyntax/ext/pipes/parse_proto.rs
+++ b/src/libsyntax/ext/pipes/parse_proto.rs
@@ -17,6 +17,7 @@ use ext::pipes::proto::*;
 use parse::common::SeqSep;
 use parse::parser;
 use parse::token;
+use parse::token::{get_ident_interner};
 
 pub trait proto_parser {
     fn parse_proto(&self, id: ~str) -> protocol;
@@ -42,11 +43,11 @@ impl proto_parser for parser::Parser {
 
     fn parse_state(&self, proto: protocol) {
         let id = self.parse_ident();
-        let name = copy *self.interner.get(id);
+        let name = copy *get_ident_interner().get(id);
 
         self.expect(&token::COLON);
         let dir = match copy *self.token {
-            token::IDENT(n, _) => self.interner.get(n),
+            token::IDENT(n, _) => get_ident_interner().get(n),
             _ => fail!()
         };
         self.bump();
@@ -77,7 +78,7 @@ impl proto_parser for parser::Parser {
     }
 
     fn parse_message(&self, state: state) {
-        let mname = copy *self.interner.get(self.parse_ident());
+        let mname = copy *get_ident_interner().get(self.parse_ident());
 
         let args = if *self.token == token::LPAREN {
             self.parse_unspanned_seq(
@@ -96,7 +97,7 @@ impl proto_parser for parser::Parser {
 
         let next = match *self.token {
           token::IDENT(_, _) => {
-            let name = copy *self.interner.get(self.parse_ident());
+            let name = copy *get_ident_interner().get(self.parse_ident());
             let ntys = if *self.token == token::LT {
                 self.parse_unspanned_seq(
                     &token::LT,
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 9182b99bf30..bfa4faa8b28 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -80,13 +80,13 @@ pub mod rt {
 
     impl ToSource for ast::ident {
         fn to_source(&self, cx: @ExtCtxt) -> ~str {
-            copy *cx.parse_sess().interner.get(*self)
+            copy *get_ident_interner().get(*self)
         }
     }
 
     impl ToSource for @ast::item {
         fn to_source(&self, cx: @ExtCtxt) -> ~str {
-            item_to_str(*self, cx.parse_sess().interner)
+            item_to_str(*self, get_ident_interner())
         }
     }
 
@@ -98,7 +98,7 @@ pub mod rt {
 
     impl ToSource for @ast::Ty {
         fn to_source(&self, cx: @ExtCtxt) -> ~str {
-            ty_to_str(*self, cx.parse_sess().interner)
+            ty_to_str(*self, get_ident_interner())
         }
     }
 
@@ -110,19 +110,19 @@ pub mod rt {
 
     impl ToSource for Generics {
         fn to_source(&self, cx: @ExtCtxt) -> ~str {
-            pprust::generics_to_str(self, cx.parse_sess().interner)
+            pprust::generics_to_str(self, get_ident_interner())
         }
     }
 
     impl ToSource for @ast::expr {
         fn to_source(&self, cx: @ExtCtxt) -> ~str {
-            pprust::expr_to_str(*self, cx.parse_sess().interner)
+            pprust::expr_to_str(*self, get_ident_interner())
         }
     }
 
     impl ToSource for ast::blk {
         fn to_source(&self, cx: @ExtCtxt) -> ~str {
-            pprust::block_to_str(self, cx.parse_sess().interner)
+            pprust::block_to_str(self, get_ident_interner())
         }
     }
 
@@ -418,11 +418,11 @@ pub fn expand_quote_stmt(cx: @ExtCtxt,
 }
 
 fn ids_ext(cx: @ExtCtxt, strs: ~[~str]) -> ~[ast::ident] {
-    strs.map(|str| cx.parse_sess().interner.intern(*str))
+    strs.map(|str| get_ident_interner().intern(*str))
 }
 
 fn id_ext(cx: @ExtCtxt, str: &str) -> ast::ident {
-    cx.parse_sess().interner.intern(str)
+    get_ident_interner().intern(str)
 }
 
 // Lift an ident to the expr that evaluates to that ident.
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 91fad0c22a6..fcdfb0a6ba7 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -18,6 +18,7 @@ use ext::base::*;
 use ext::base;
 use ext::build::AstBuilder;
 use parse;
+use parse::token::{get_ident_interner};
 use print::pprust;
 
 use core::io;
@@ -65,7 +66,7 @@ pub fn expand_file(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
 
 pub fn expand_stringify(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
-    let s = pprust::tts_to_str(tts, cx.parse_sess().interner);
+    let s = pprust::tts_to_str(tts, get_ident_interner());
     base::MRExpr(cx.expr_str(sp, s))
 }
 
diff --git a/src/libsyntax/ext/trace_macros.rs b/src/libsyntax/ext/trace_macros.rs
index 111e176d4c5..3515041c9b6 100644
--- a/src/libsyntax/ext/trace_macros.rs
+++ b/src/libsyntax/ext/trace_macros.rs
@@ -17,6 +17,7 @@ use ext::base;
 use parse::lexer::{new_tt_reader, reader};
 use parse::parser::Parser;
 use parse::token::keywords;
+use parse::token::{get_ident_interner};
 
 use core::vec;
 
@@ -28,7 +29,7 @@ pub fn expand_trace_macros(cx: @ExtCtxt,
     let cfg = cx.cfg();
     let tt_rdr = new_tt_reader(
         copy cx.parse_sess().span_diagnostic,
-        cx.parse_sess().interner,
+        get_ident_interner(),
         None,
         vec::to_owned(tt)
     );
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index ec63b5a7f74..1b23b96a732 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -19,7 +19,7 @@ use codemap;
 use parse::lexer::*; //resolve bug?
 use parse::ParseSess;
 use parse::parser::Parser;
-use parse::token::{Token, EOF, to_str, nonterminal};
+use parse::token::{Token, EOF, to_str, nonterminal, get_ident_interner};
 use parse::token;
 
 use core::hashmap::HashMap;
@@ -205,7 +205,7 @@ pub fn nameize(p_s: @mut ParseSess, ms: &[matcher], res: &[@named_match])
           } => {
             if ret_val.contains_key(&bind_name) {
                 p_s.span_diagnostic.span_fatal(sp, ~"Duplicated bind name: "+
-                                               *p_s.interner.get(bind_name))
+                                               *get_ident_interner().get(bind_name))
             }
             ret_val.insert(bind_name, res[idx]);
           }
@@ -373,8 +373,8 @@ pub fn parse(
                 let nts = str::connect(vec::map(bb_eis, |ei| {
                     match ei.elts[ei.idx].node {
                       match_nonterminal(bind,name,_) => {
-                        fmt!("%s ('%s')", *sess.interner.get(name),
-                             *sess.interner.get(bind))
+                        fmt!("%s ('%s')", *get_ident_interner().get(name),
+                             *get_ident_interner().get(bind))
                       }
                       _ => fail!()
                     } }), " or ");
@@ -384,7 +384,7 @@ pub fn parse(
                     nts, next_eis.len()));
             } else if (bb_eis.len() == 0u && next_eis.len() == 0u) {
                 return failure(sp, ~"No rules expected the token: "
-                            + to_str(rdr.interner(), &tok));
+                            + to_str(get_ident_interner(), &tok));
             } else if (next_eis.len() > 0u) {
                 /* Now process the next token */
                 while(next_eis.len() > 0u) {
@@ -398,7 +398,7 @@ pub fn parse(
                 match ei.elts[ei.idx].node {
                   match_nonterminal(_, name, idx) => {
                     ei.matches[idx].push(@matched_nonterminal(
-                        parse_nt(&rust_parser, *sess.interner.get(name))));
+                        parse_nt(&rust_parser, *get_ident_interner().get(name))));
                     ei.idx += 1u;
                   }
                   _ => fail!()
@@ -430,7 +430,7 @@ pub fn parse_nt(p: &Parser, name: &str) -> nonterminal {
       "ident" => match *p.token {
         token::IDENT(sn,b) => { p.bump(); token::nt_ident(sn,b) }
         _ => p.fatal(~"expected ident, found "
-                     + token::to_str(p.reader.interner(), &copy *p.token))
+                     + token::to_str(get_ident_interner(), &copy *p.token))
       },
       "path" => token::nt_path(p.parse_path_with_tps(false)),
       "tt" => {
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 261943132b3..13393b76663 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -21,7 +21,7 @@ use ext::tt::macro_parser::{named_match, matched_seq, matched_nonterminal};
 use ext::tt::macro_parser::{parse, parse_or_else, success, failure};
 use parse::lexer::{new_tt_reader, reader};
 use parse::parser::Parser;
-use parse::token::special_idents;
+use parse::token::{get_ident_interner, special_idents};
 use parse::token::{FAT_ARROW, SEMI, nt_matchers, nt_tt};
 use print;
 
@@ -38,8 +38,8 @@ pub fn add_new_extension(cx: @ExtCtxt,
         spanned { node: copy m, span: dummy_sp() }
     }
 
-    let lhs_nm =  cx.parse_sess().interner.gensym("lhs");
-    let rhs_nm =  cx.parse_sess().interner.gensym("rhs");
+    let lhs_nm =  get_ident_interner().gensym("lhs");
+    let rhs_nm =  get_ident_interner().gensym("rhs");
 
     // The grammar for macro_rules! is:
     // $( $lhs:mtcs => $rhs:tt );+
@@ -57,7 +57,7 @@ pub fn add_new_extension(cx: @ExtCtxt,
 
     // Parse the macro_rules! invocation (`none` is for no interpolations):
     let arg_reader = new_tt_reader(copy cx.parse_sess().span_diagnostic,
-                                   cx.parse_sess().interner, None, copy arg);
+                                   get_ident_interner(), None, copy arg);
     let argument_map = parse_or_else(cx.parse_sess(),
                                      cx.cfg(),
                                      arg_reader as @reader,
@@ -85,7 +85,7 @@ pub fn add_new_extension(cx: @ExtCtxt,
                              cx.str_of(name),
                              print::pprust::tt_to_str(
                                  ast::tt_delim(vec::to_owned(arg)),
-                                 cx.parse_sess().interner)));
+                                 get_ident_interner())));
         }
 
         // Which arm's failure should we report? (the one furthest along)
@@ -93,7 +93,7 @@ pub fn add_new_extension(cx: @ExtCtxt,
         let mut best_fail_msg = ~"internal error: ran no matchers";
 
         let s_d = cx.parse_sess().span_diagnostic;
-        let itr = cx.parse_sess().interner;
+        let itr = get_ident_interner();
 
         for lhses.eachi |i, lhs| { // try each arm's matchers
             match *lhs {
@@ -151,7 +151,7 @@ pub fn add_new_extension(cx: @ExtCtxt,
         |cx, sp, arg| generic_extension(cx, sp, name, arg, *lhses, *rhses);
 
     return MRDef(MacroDef{
-        name: copy *cx.parse_sess().interner.get(name),
+        name: copy *get_ident_interner().get(name),
         ext: NormalTT(base::SyntaxExpanderTT{expander: exp, span: Some(sp)})
     });
 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 4a6a070df50..b508b342478 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -15,7 +15,7 @@ use ast::{token_tree, tt_delim, tt_tok, tt_seq, tt_nonterminal,ident};
 use codemap::{span, dummy_sp};
 use diagnostic::span_handler;
 use ext::tt::macro_parser::{named_match, matched_seq, matched_nonterminal};
-use parse::token::{EOF, INTERPOLATED, IDENT, Token, nt_ident, ident_interner};
+use parse::token::{EOF, INTERPOLATED, IDENT, Token, nt_ident, ident_interner, get_ident_interner};
 use parse::lexer::TokenAndSpan;
 
 use core::hashmap::HashMap;
@@ -93,7 +93,7 @@ fn dup_tt_frame(f: @mut TtFrame) -> @mut TtFrame {
 pub fn dup_tt_reader(r: @mut TtReader) -> @mut TtReader {
     @mut TtReader {
         sp_diag: r.sp_diag,
-        interner: r.interner,
+        interner: get_ident_interner(),
         stack: dup_tt_frame(r.stack),
         repeat_idx: copy r.repeat_idx,
         repeat_len: copy r.repeat_len,
@@ -144,8 +144,8 @@ fn lockstep_iter_size(t: &token_tree, r: &mut TtReader) -> lis {
             lis_contradiction(_) => copy rhs,
             lis_constraint(r_len, _) if l_len == r_len => copy lhs,
             lis_constraint(r_len, r_id) => {
-                let l_n = copy *r.interner.get(l_id);
-                let r_n = copy *r.interner.get(r_id);
+                let l_n = copy *get_ident_interner().get(l_id);
+                let r_n = copy *get_ident_interner().get(r_id);
                 lis_contradiction(fmt!("Inconsistent lockstep iteration: \
                                        '%s' has %u items, but '%s' has %u",
                                         l_n, l_len, r_n, r_len))
@@ -295,7 +295,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                 r.sp_diag.span_fatal(
                     copy r.cur_span, /* blame the macro writer */
                     fmt!("variable '%s' is still repeating at this depth",
-                         *r.interner.get(ident)));
+                         *get_ident_interner().get(ident)));
               }
             }
           }
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 2f166ae89ef..00fe8cf545a 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -18,6 +18,7 @@ use parse::lexer::{StringReader, bump, is_eof, nextch, TokenAndSpan};
 use parse::lexer::{is_line_non_doc_comment, is_block_non_doc_comment};
 use parse::lexer;
 use parse::token;
+use parse::token::{get_ident_interner};
 use parse;
 
 use core::io;
@@ -358,7 +359,7 @@ pub fn gather_comments_and_literals(span_diagnostic:
             debug!("tok lit: %s", s);
             literals.push(lit {lit: s, pos: sp.lo});
         } else {
-            debug!("tok: %s", token::to_str(rdr.interner, &tok));
+            debug!("tok: %s", token::to_str(get_ident_interner(), &tok));
         }
         first_read = false;
     }
diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs
index 4914aa3fceb..9fb69821953 100644
--- a/src/libsyntax/parse/common.rs
+++ b/src/libsyntax/parse/common.rs
@@ -16,6 +16,7 @@ use parse::lexer::reader;
 use parse::parser::Parser;
 use parse::token::keywords;
 use parse::token;
+use parse::token::{get_ident_interner};
 
 use opt_vec;
 use opt_vec::OptVec;
@@ -49,13 +50,13 @@ pub fn seq_sep_none() -> SeqSep {
 // maps any token back to a string. not necessary if you know it's
 // an identifier....
 pub fn token_to_str(reader: @reader, token: &token::Token) -> ~str {
-    token::to_str(reader.interner(), token)
+    token::to_str(get_ident_interner(), token)
 }
 
 impl Parser {
     // convert a token to a string using self's reader
     pub fn token_to_str(&self, token: &token::Token) -> ~str {
-        token::to_str(self.reader.interner(), token)
+        token::to_str(get_ident_interner(), token)
     }
 
     // convert the current token to a string using self's reader
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 0eb933e6c3a..f98d0f3dea8 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -17,6 +17,7 @@ use diagnostic::span_handler;
 use ext::tt::transcribe::{tt_next_token};
 use ext::tt::transcribe::{dup_tt_reader};
 use parse::token;
+use parse::token::{get_ident_interner};
 
 use core::char;
 use core::either;
@@ -100,7 +101,7 @@ fn dup_string_reader(r: @mut StringReader) -> @mut StringReader {
         col: r.col,
         curr: r.curr,
         filemap: r.filemap,
-        interner: r.interner,
+        interner: get_ident_interner(),
         peek_tok: copy r.peek_tok,
         peek_span: copy r.peek_span
     }
@@ -121,7 +122,7 @@ impl reader for StringReader {
         self.span_diagnostic.span_fatal(copy self.peek_span, m)
     }
     fn span_diag(@mut self) -> @span_handler { self.span_diagnostic }
-    fn interner(@mut self) -> @token::ident_interner { self.interner }
+    fn interner(@mut self) -> @token::ident_interner { get_ident_interner() }
     fn peek(@mut self) -> TokenAndSpan {
         TokenAndSpan {
             tok: copy self.peek_tok,
@@ -138,7 +139,7 @@ impl reader for TtReader {
         self.sp_diag.span_fatal(copy self.cur_span, m);
     }
     fn span_diag(@mut self) -> @span_handler { self.sp_diag }
-    fn interner(@mut self) -> @token::ident_interner { self.interner }
+    fn interner(@mut self) -> @token::ident_interner { get_ident_interner() }
     fn peek(@mut self) -> TokenAndSpan {
         TokenAndSpan {
             tok: copy self.cur_tok,
@@ -277,7 +278,7 @@ fn consume_any_line_comment(rdr: @mut StringReader)
                 // but comments with only more "/"s are not
                 if !is_line_non_doc_comment(acc) {
                     return Some(TokenAndSpan{
-                        tok: token::DOC_COMMENT(rdr.interner.intern(acc)),
+                        tok: token::DOC_COMMENT(get_ident_interner().intern(acc)),
                         sp: codemap::mk_sp(start_bpos, rdr.pos)
                     });
                 }
@@ -331,7 +332,7 @@ fn consume_block_comment(rdr: @mut StringReader)
             // but comments with only "*"s between two "/"s are not
             if !is_block_non_doc_comment(acc) {
                 return Some(TokenAndSpan{
-                    tok: token::DOC_COMMENT(rdr.interner.intern(acc)),
+                    tok: token::DOC_COMMENT(get_ident_interner().intern(acc)),
                     sp: codemap::mk_sp(start_bpos, rdr.pos)
                 });
             }
@@ -477,12 +478,12 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
         if c == '3' && n == '2' {
             bump(rdr);
             bump(rdr);
-            return token::LIT_FLOAT(rdr.interner.intern(num_str),
+            return token::LIT_FLOAT(get_ident_interner().intern(num_str),
                                  ast::ty_f32);
         } else if c == '6' && n == '4' {
             bump(rdr);
             bump(rdr);
-            return token::LIT_FLOAT(rdr.interner.intern(num_str),
+            return token::LIT_FLOAT(get_ident_interner().intern(num_str),
                                  ast::ty_f64);
             /* FIXME (#2252): if this is out of range for either a
             32-bit or 64-bit float, it won't be noticed till the
@@ -494,9 +495,9 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
     }
     if is_float {
         if is_machine_float {
-            return token::LIT_FLOAT(rdr.interner.intern(num_str), ast::ty_f);
+            return token::LIT_FLOAT(get_ident_interner().intern(num_str), ast::ty_f);
         }
-        return token::LIT_FLOAT_UNSUFFIXED(rdr.interner.intern(num_str));
+        return token::LIT_FLOAT_UNSUFFIXED(get_ident_interner().intern(num_str));
     } else {
         if str::len(num_str) == 0u {
             rdr.fatal(~"no valid digits found for number");
@@ -559,7 +560,7 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
         let is_mod_name = c == ':' && nextch(rdr) == ':';
 
         // FIXME: perform NFKC normalization here. (Issue #2253)
-        return token::IDENT(rdr.interner.intern(accum_str), is_mod_name);
+        return token::IDENT(get_ident_interner().intern(accum_str), is_mod_name);
     }
     if is_dec_digit(c) {
         return scan_number(c, rdr);
@@ -669,7 +670,7 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
                 lifetime_name.push_char(rdr.curr);
                 bump(rdr);
             }
-            return token::LIFETIME(rdr.interner.intern(lifetime_name));
+            return token::LIFETIME(get_ident_interner().intern(lifetime_name));
         }
 
         // Otherwise it is a character constant:
@@ -742,7 +743,7 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
             }
         }
         bump(rdr);
-        return token::LIT_STR(rdr.interner.intern(accum_str));
+        return token::LIT_STR(get_ident_interner().intern(accum_str));
       }
       '-' => {
         if nextch(rdr) == '>' {
@@ -786,6 +787,7 @@ mod test {
     use core::option::None;
     use diagnostic;
     use parse::token;
+    use parse::token::{get_ident_interner};
 
     // represents a testing reader (incl. both reader and interner)
     struct Env {
@@ -840,7 +842,7 @@ mod test {
 
     // make the identifier by looking up the string in the interner
     fn mk_ident (env: Env, id: &str, is_mod_name: bool) -> token::Token {
-        token::IDENT (env.interner.intern(id),is_mod_name)
+        token::IDENT (get_ident_interner().intern(id),is_mod_name)
     }
 
     #[test] fn doublecolonparsing () {
@@ -899,7 +901,7 @@ mod test {
         let env = setup(~"'abc");
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
-        let id = env.interner.intern("abc");
+        let id = get_ident_interner().intern("abc");
         assert_eq!(tok, token::LIFETIME(id));
     }
 
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 8306b0ff1a9..46a76e4572d 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -314,7 +314,7 @@ pub fn filemap_to_tts(sess: @mut ParseSess, filemap: @FileMap)
     let cfg = ~[];
     let srdr = lexer::new_string_reader(copy sess.span_diagnostic,
                                         filemap,
-                                        sess.interner);
+                                        get_ident_interner());
     let p1 = Parser(sess, cfg, srdr as @reader);
     p1.parse_all_token_trees()
 }
@@ -325,7 +325,7 @@ pub fn tts_to_parser(sess: @mut ParseSess,
                      cfg: ast::crate_cfg) -> Parser {
     let trdr = lexer::new_tt_reader(
         copy sess.span_diagnostic,
-        sess.interner,
+        get_ident_interner(),
         None,
         tts
     );
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 4635db0e10f..6260e7c460c 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -85,7 +85,7 @@ use parse::obsolete::{ObsoleteLifetimeNotation, ObsoleteConstManagedPointer};
 use parse::obsolete::{ObsoletePurity, ObsoleteStaticMethod};
 use parse::obsolete::{ObsoleteConstItem, ObsoleteFixedLengthVectorType};
 use parse::obsolete::{ObsoleteNamedExternModule, ObsoleteMultipleLocalDecl};
-use parse::token::{can_begin_expr, is_ident, is_ident_or_path};
+use parse::token::{can_begin_expr, get_ident_interner, is_ident, is_ident_or_path};
 use parse::token::{is_plain_ident, INTERPOLATED, keywords, special_idents, token_to_binop};
 use parse::token;
 use parse::{new_sub_parser_from_file, next_node_id, ParseSess};
@@ -219,7 +219,7 @@ pub fn Parser(sess: @mut ParseSess,
               rdr: @reader)
            -> Parser {
     let tok0 = copy rdr.next_token();
-    let interner = rdr.interner();
+    let interner = get_ident_interner();
 
     Parser {
         reader: rdr,
@@ -333,7 +333,7 @@ impl Parser {
     pub fn get_id(&self) -> node_id { next_node_id(self.sess) }
 
     pub fn id_to_str(&self, id: ident) -> @~str {
-        self.sess.interner.get(id)
+        get_ident_interner().get(id)
     }
 
     // is this one of the keywords that signals a closure type?
@@ -3370,7 +3370,7 @@ impl Parser {
             }
             if fields.len() == 0 {
                 self.fatal(fmt!("Unit-like struct should be written as `struct %s;`",
-                                *self.interner.get(class_name)));
+                                *get_ident_interner().get(class_name)));
             }
             self.bump();
         } else if *self.token == token::LPAREN {
@@ -3582,7 +3582,7 @@ impl Parser {
     }
 
     fn push_mod_path(&self, id: ident, attrs: ~[ast::attribute]) {
-        let default_path = self.sess.interner.get(id);
+        let default_path = get_ident_interner().get(id);
         let file_path = match ::attr::first_attr_value_str_by_name(
             attrs, "path") {
 
@@ -3605,7 +3605,7 @@ impl Parser {
         let prefix = prefix.dir_path();
         let mod_path_stack = &*self.mod_path_stack;
         let mod_path = Path(".").push_many(*mod_path_stack);
-        let default_path = *self.sess.interner.get(id) + ".rs";
+        let default_path = *get_ident_interner().get(id) + ".rs";
         let file_path = match ::attr::first_attr_value_str_by_name(
             outer_attrs, "path") {
             Some(d) => {