bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

just use TLS interner

Browse source
This commit is contained in:
John Clements 2013-05-17 10:18:35 -07:00
parent 22d21ab4c2
commit 1537056982
19 changed files with 84 additions and 75 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/libsyntax/ast.rs
View file

@ -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())
}
}

6
src/libsyntax/ext/base.rs
View file

@ -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)
}
}

3
src/libsyntax/ext/concat_idents.rs
View file

@ -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(),

1
src/libsyntax/ext/expand.rs
View file

@ -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};

13
src/libsyntax/ext/fmt.rs
View file

@ -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

3
src/libsyntax/ext/log_syntax.rs
View file

@ -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 {

4
src/libsyntax/ext/pipes/mod.rs
View file

@ -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;

9
src/libsyntax/ext/pipes/parse_proto.rs
View file

@ -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,

16
src/libsyntax/ext/quote.rs
View file

@ -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.

3
src/libsyntax/ext/source_util.rs
View file

@ -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))
}

3
src/libsyntax/ext/trace_macros.rs
View file

@ -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)
);

14
src/libsyntax/ext/tt/macro_parser.rs
View file

@ -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" => {

14
src/libsyntax/ext/tt/macro_rules.rs
View file

@ -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)})
});
}

10
src/libsyntax/ext/tt/transcribe.rs
View file

@ -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)));
}
}
}

3
src/libsyntax/parse/comments.rs
View file

@ -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;
}

5
src/libsyntax/parse/common.rs
View file

@ -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

30
src/libsyntax/parse/lexer.rs
View file

@ -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));
}

4
src/libsyntax/parse/mod.rs
View file

@ -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
);

12
src/libsyntax/parse/parser.rs
View file

@ -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) => {