From 00a5e66f818ad9d79cc4425f5564c7b07e3213a6 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 28 Jul 2015 18:07:20 +0200 Subject: remove `get_ident` and `get_name`, make `as_str` sound --- src/libsyntax/ast.rs | 34 +++++++++---------- src/libsyntax/ast_util.rs | 4 +-- src/libsyntax/diagnostics/plugin.rs | 25 ++++++++------ src/libsyntax/ext/build.rs | 3 +- src/libsyntax/ext/concat_idents.rs | 4 +-- src/libsyntax/ext/deriving/decodable.rs | 16 ++++----- src/libsyntax/ext/deriving/encodable.rs | 8 ++--- src/libsyntax/ext/deriving/show.rs | 6 ++-- src/libsyntax/ext/expand.rs | 60 ++++++++++++++------------------- src/libsyntax/ext/format.rs | 3 +- src/libsyntax/ext/quote.rs | 4 +-- src/libsyntax/ext/source_util.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 12 +++---- src/libsyntax/ext/tt/macro_rules.rs | 19 +++++------ src/libsyntax/ext/tt/transcribe.rs | 10 +++--- src/libsyntax/feature_gate.rs | 2 +- src/libsyntax/parse/mod.rs | 39 +++++++++++---------- src/libsyntax/parse/obsolete.rs | 6 ++-- src/libsyntax/parse/parser.rs | 38 ++++++++++----------- src/libsyntax/parse/token.rs | 26 +++++--------- src/libsyntax/print/pprust.rs | 32 +++++++++--------- src/libsyntax/std_inject.rs | 3 +- 22 files changed, 164 insertions(+), 192 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 72711f2ed18..db173d08308 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -87,10 +87,6 @@ pub struct Ident { impl Ident { /// Construct an identifier with the given name and an empty context: pub fn new(name: Name) -> Ident { Ident {name: name, ctxt: EMPTY_CTXT}} - - pub fn as_str<'a>(&'a self) -> &'a str { - self.name.as_str() - } } impl fmt::Debug for Ident { @@ -108,13 +104,13 @@ impl fmt::Display for Ident { impl fmt::Debug for Name { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let Name(nm) = *self; - write!(f, "{:?}({})", token::get_name(*self), nm) + write!(f, "{}({})", self, nm) } } impl fmt::Display for Name { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&token::get_name(*self), f) + fmt::Display::fmt(&self.as_str(), f) } } @@ -134,13 +130,10 @@ impl PartialEq for Ident { // one example and its non-hygienic counterpart would be: // syntax::parse::token::Token::mtwt_eq // syntax::ext::tt::macro_parser::token_name_eq - panic!("not allowed to compare these idents: {}, {}. \ + panic!("not allowed to compare these idents: {:?}, {:?}. \ Probably related to issue \\#6993", self, other); } } - fn ne(&self, other: &Ident) -> bool { - ! self.eq(other) - } } /// A SyntaxContext represents a chain of macro-expandings @@ -166,12 +159,15 @@ pub const ILLEGAL_CTXT : SyntaxContext = 1; RustcEncodable, RustcDecodable, Clone, Copy)] pub struct Name(pub u32); +impl> PartialEq for Name { + fn eq(&self, other: &T) -> bool { + self.as_str() == other.as_ref() + } +} + impl Name { - pub fn as_str<'a>(&'a self) -> &'a str { - unsafe { - // FIXME #12938: can't use copy_lifetime since &str isn't a &T - ::std::mem::transmute::<&str,&str>(&token::get_name(*self)) - } + pub fn as_str(&self) -> token::InternedString { + token::InternedString::new_from_name(*self) } pub fn usize(&self) -> usize { @@ -189,7 +185,7 @@ pub type Mrk = u32; impl Encodable for Ident { fn encode(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_str(&token::get_ident(*self)) + s.emit_str(&self.name.as_str()) } } @@ -1073,7 +1069,7 @@ impl TokenTree { pub fn len(&self) -> usize { match *self { TtToken(_, token::DocComment(name)) => { - match doc_comment_style(name.as_str()) { + match doc_comment_style(&name.as_str()) { AttrOuter => 2, AttrInner => 3 } @@ -1096,11 +1092,11 @@ impl TokenTree { TtToken(sp, token::Pound) } (&TtToken(sp, token::DocComment(name)), 1) - if doc_comment_style(name.as_str()) == AttrInner => { + if doc_comment_style(&name.as_str()) == AttrInner => { TtToken(sp, token::Not) } (&TtToken(sp, token::DocComment(name)), _) => { - let stripped = strip_doc_comment_decoration(name.as_str()); + let stripped = strip_doc_comment_decoration(&name.as_str()); TtDelimited(sp, Rc::new(Delimited { delim: token::Bracket, open_span: sp, diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 6b38762316c..83d3c9c4ec5 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -25,9 +25,7 @@ use std::u32; pub fn path_name_i(idents: &[Ident]) -> String { // FIXME: Bad copies (#2543 -- same for everything else that says "bad") - idents.iter().map(|i| { - token::get_ident(*i).to_string() - }).collect::>().join("::") + idents.iter().map(|i| i.to_string()).collect::>().join("::") } pub fn local_def(id: NodeId) -> DefId { diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs index aee066807f4..48fd05a7550 100644 --- a/src/libsyntax/diagnostics/plugin.rs +++ b/src/libsyntax/diagnostics/plugin.rs @@ -63,7 +63,7 @@ pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt, // Previously used errors. Some(&mut ErrorInfo { description: _, use_site: Some(previous_span) }) => { ecx.span_warn(span, &format!( - "diagnostic code {} already used", &token::get_ident(code) + "diagnostic code {} already used", code )); ecx.span_note(previous_span, "previous invocation"); } @@ -74,7 +74,7 @@ pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt, // Unregistered errors. None => { ecx.span_err(span, &format!( - "used diagnostic code {} not registered", &token::get_ident(code) + "used diagnostic code {} not registered", code )); } } @@ -110,7 +110,7 @@ pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt, if !msg.starts_with("\n") || !msg.ends_with("\n") { ecx.span_err(span, &format!( "description for error code {} doesn't start and end with a newline", - token::get_ident(*code) + code )); } @@ -122,7 +122,7 @@ pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt, ecx.span_err(span, &format!( "description for error code {} contains a line longer than {} characters.\n\ if you're inserting a long URL use the footnote style to bypass this check.", - token::get_ident(*code), MAX_DESCRIPTION_WIDTH + code, MAX_DESCRIPTION_WIDTH )); } }); @@ -134,12 +134,12 @@ pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt, }; if diagnostics.insert(code.name, info).is_some() { ecx.span_err(span, &format!( - "diagnostic code {} already registered", &token::get_ident(*code) + "diagnostic code {} already registered", code )); } }); - let sym = Ident::new(token::gensym(&( - "__register_diagnostic_".to_string() + &token::get_ident(*code) + let sym = Ident::new(token::gensym(&format!( + "__register_diagnostic_{}", code ))); MacEager::items(SmallVector::many(vec![ ecx.item_mod( @@ -163,7 +163,7 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt, &ast::TtToken(_, token::Ident(ref crate_name, _)), // DIAGNOSTICS ident. &ast::TtToken(_, token::Ident(ref name, _)) - ) => (crate_name.as_str(), name), + ) => (*&crate_name, name), _ => unreachable!() }; @@ -172,7 +172,10 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt, .ok().expect("unable to determine target arch from $CFG_COMPILER_HOST_TRIPLE"); with_registered_diagnostics(|diagnostics| { - if let Err(e) = output_metadata(ecx, &target_triple, crate_name, &diagnostics) { + if let Err(e) = output_metadata(ecx, + &target_triple, + &crate_name.name.as_str(), + &diagnostics) { ecx.span_bug(span, &format!( "error writing metadata for triple `{}` and crate `{}`, error: {}, cause: {:?}", target_triple, crate_name, e.description(), e.cause() @@ -187,8 +190,8 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt, diagnostics.iter().filter_map(|(code, info)| { info.description.map(|description| { ecx.expr_tuple(span, vec![ - ecx.expr_str(span, token::get_name(*code)), - ecx.expr_str(span, token::get_name(description)) + ecx.expr_str(span, code.as_str()), + ecx.expr_str(span, description.as_str()) ]) }) }).collect(); diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 79210cb3260..b91c54ae972 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -629,9 +629,8 @@ impl<'a> AstBuilder for ExtCtxt<'a> { } fn expr_field_access(&self, sp: Span, expr: P, ident: ast::Ident) -> P { - let field_name = token::get_ident(ident); let field_span = Span { - lo: sp.lo - Pos::from_usize(field_name.len()), + lo: sp.lo - Pos::from_usize(ident.name.as_str().len()), hi: sp.hi, expn_id: sp.expn_id, }; diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs index 5d07c36c929..24436c4520d 100644 --- a/src/libsyntax/ext/concat_idents.rs +++ b/src/libsyntax/ext/concat_idents.rs @@ -40,7 +40,7 @@ pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree] } else { match *e { ast::TtToken(_, token::Ident(ident, _)) => { - res_str.push_str(&token::get_ident(ident)) + res_str.push_str(&ident.name.as_str()) }, _ => { cx.span_err(sp, "concat_idents! requires ident args."); @@ -49,7 +49,7 @@ pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree] } } } - let res = str_to_ident(&res_str[..]); + let res = str_to_ident(&res_str); let e = P(ast::Expr { id: ast::DUMMY_NODE_ID, diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index 99f217a419a..085d9d60937 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -128,7 +128,7 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span, decoder, cx.ident_of("read_struct"), vec!( - cx.expr_str(trait_span, token::get_ident(substr.type_ident)), + cx.expr_str(trait_span, substr.type_ident.name.as_str()), cx.expr_usize(trait_span, nfields), cx.lambda_expr_1(trait_span, result, blkarg) )) @@ -140,10 +140,10 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span, let mut variants = Vec::new(); let rvariant_arg = cx.ident_of("read_enum_variant_arg"); - for (i, &(name, v_span, ref parts)) in fields.iter().enumerate() { - variants.push(cx.expr_str(v_span, token::get_ident(name))); + for (i, &(ident, v_span, ref parts)) in fields.iter().enumerate() { + variants.push(cx.expr_str(v_span, ident.name.as_str())); - let path = cx.path(trait_span, vec![substr.type_ident, name]); + let path = cx.path(trait_span, vec![substr.type_ident, ident]); let decoded = decode_static_fields(cx, v_span, path, @@ -175,7 +175,7 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span, decoder, cx.ident_of("read_enum"), vec!( - cx.expr_str(trait_span, token::get_ident(substr.type_ident)), + cx.expr_str(trait_span, substr.type_ident.name.as_str()), cx.lambda_expr_1(trait_span, result, blkarg) )) } @@ -211,9 +211,9 @@ fn decode_static_fields(cx: &mut ExtCtxt, } Named(ref fields) => { // use the field's span to get nicer error messages. - let fields = fields.iter().enumerate().map(|(i, &(name, span))| { - let arg = getarg(cx, span, token::get_ident(name), i); - cx.field_imm(span, name, arg) + let fields = fields.iter().enumerate().map(|(i, &(ident, span))| { + let arg = getarg(cx, span, ident.name.as_str(), i); + cx.field_imm(span, ident, arg) }).collect(); cx.expr_struct(trait_span, outer_pat_path, fields) } diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index 0ef23705f95..ae4d337b9f6 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -186,7 +186,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, .. }) in fields.iter().enumerate() { let name = match name { - Some(id) => token::get_ident(id), + Some(id) => id.name.as_str(), None => { token::intern_and_get_ident(&format!("_field{}", i)) } @@ -223,7 +223,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, encoder, cx.ident_of("emit_struct"), vec!( - cx.expr_str(trait_span, token::get_ident(substr.type_ident)), + cx.expr_str(trait_span, substr.type_ident.name.as_str()), cx.expr_usize(trait_span, fields.len()), blk )) @@ -263,7 +263,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, } let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg); - let name = cx.expr_str(trait_span, token::get_ident(variant.node.name)); + let name = cx.expr_str(trait_span, variant.node.name.name.as_str()); let call = cx.expr_method_call(trait_span, blkencoder, cx.ident_of("emit_enum_variant"), vec!(name, @@ -275,7 +275,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, encoder, cx.ident_of("emit_enum"), vec!( - cx.expr_str(trait_span, token::get_ident(substr.type_ident)), + cx.expr_str(trait_span, substr.type_ident.name.as_str()), blk )); cx.expr_block(cx.block(trait_span, vec!(me), Some(ret))) diff --git a/src/libsyntax/ext/deriving/show.rs b/src/libsyntax/ext/deriving/show.rs index dbde963bda9..3a478884c6a 100644 --- a/src/libsyntax/ext/deriving/show.rs +++ b/src/libsyntax/ext/deriving/show.rs @@ -59,7 +59,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, // build fmt.debug_struct().field(, &)....build() // or fmt.debug_tuple().field(&)....build() // based on the "shape". - let name = match *substr.fields { + let ident = match *substr.fields { Struct(_) => substr.type_ident, EnumMatching(_, v, _) => v.node.name, EnumNonMatchingCollapsed(..) | StaticStruct(..) | StaticEnum(..) => { @@ -69,7 +69,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, // We want to make sure we have the expn_id set so that we can use unstable methods let span = Span { expn_id: cx.backtrace(), .. span }; - let name = cx.expr_lit(span, ast::Lit_::LitStr(token::get_ident(name), + let name = cx.expr_lit(span, ast::Lit_::LitStr(ident.name.as_str(), ast::StrStyle::CookedStr)); let mut expr = substr.nonself_args[0].clone(); @@ -102,7 +102,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, for field in fields { let name = cx.expr_lit(field.span, ast::Lit_::LitStr( - token::get_ident(field.name.clone().unwrap()), + field.name.unwrap().name.as_str(), ast::StrStyle::CookedStr)); // Use double indirection to make sure this works for unsized types diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 286dc91299f..6e49b190f7c 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -545,14 +545,13 @@ fn expand_mac_invoc(mac: ast::Mac, // let compilation continue return None; } - let extname = pth.segments[0].identifier; - let extnamestr = token::get_ident(extname); - match fld.cx.syntax_env.find(&extname.name) { + let extname = pth.segments[0].identifier.name; + match fld.cx.syntax_env.find(&extname) { None => { fld.cx.span_err( pth.span, &format!("macro undefined: '{}!'", - &extnamestr)); + &extname)); // let compilation continue None @@ -562,7 +561,7 @@ fn expand_mac_invoc(mac: ast::Mac, fld.cx.bt_push(ExpnInfo { call_site: span, callee: NameAndSpan { - name: extnamestr.to_string(), + name: extname.to_string(), format: MacroBang, span: exp_span, allow_internal_unstable: allow_internal_unstable, @@ -589,7 +588,7 @@ fn expand_mac_invoc(mac: ast::Mac, fld.cx.span_err( pth.span, &format!("non-expression macro in expression position: {}", - &extnamestr[..] + extname )); return None; } @@ -600,7 +599,7 @@ fn expand_mac_invoc(mac: ast::Mac, fld.cx.span_err( pth.span, &format!("'{}' is not a tt-style macro", - &extnamestr)); + extname)); None } } @@ -712,19 +711,18 @@ pub fn expand_item_mac(it: P, node: MacInvocTT(ref pth, ref tts, _), .. }) => { - (pth.segments[0].identifier, pth.span, (*tts).clone()) + (pth.segments[0].identifier.name, pth.span, (*tts).clone()) } _ => fld.cx.span_bug(it.span, "invalid item macro invocation") }; - let extnamestr = token::get_ident(extname); let fm = fresh_mark(); let items = { - let expanded = match fld.cx.syntax_env.find(&extname.name) { + let expanded = match fld.cx.syntax_env.find(&extname) { None => { fld.cx.span_err(path_span, &format!("macro undefined: '{}!'", - extnamestr)); + extname)); // let compilation continue return SmallVector::zero(); } @@ -735,14 +733,14 @@ pub fn expand_item_mac(it: P, fld.cx .span_err(path_span, &format!("macro {}! expects no ident argument, given '{}'", - extnamestr, - token::get_ident(it.ident))); + extname, + it.ident)); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { call_site: it.span, callee: NameAndSpan { - name: extnamestr.to_string(), + name: extname.to_string(), format: MacroBang, span: span, allow_internal_unstable: allow_internal_unstable, @@ -756,13 +754,13 @@ pub fn expand_item_mac(it: P, if it.ident.name == parse::token::special_idents::invalid.name { fld.cx.span_err(path_span, &format!("macro {}! expects an ident argument", - &extnamestr)); + extname)); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { call_site: it.span, callee: NameAndSpan { - name: extnamestr.to_string(), + name: extname.to_string(), format: MacroBang, span: span, allow_internal_unstable: allow_internal_unstable, @@ -783,7 +781,7 @@ pub fn expand_item_mac(it: P, fld.cx.bt_push(ExpnInfo { call_site: it.span, callee: NameAndSpan { - name: extnamestr.to_string(), + name: extname.to_string(), format: MacroBang, span: None, // `macro_rules!` doesn't directly allow @@ -828,7 +826,7 @@ pub fn expand_item_mac(it: P, _ => { fld.cx.span_err(it.span, &format!("{}! is not legal in item position", - &extnamestr)); + extname)); return SmallVector::zero(); } } @@ -847,7 +845,7 @@ pub fn expand_item_mac(it: P, None => { fld.cx.span_err(path_span, &format!("non-item macro in item position: {}", - &extnamestr)); + extname)); return SmallVector::zero(); } }; @@ -1096,13 +1094,12 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { fld.cx.span_err(pth.span, "expected macro name without module separators"); return DummyResult::raw_pat(span); } - let extname = pth.segments[0].identifier; - let extnamestr = token::get_ident(extname); - let marked_after = match fld.cx.syntax_env.find(&extname.name) { + let extname = pth.segments[0].identifier.name; + let marked_after = match fld.cx.syntax_env.find(&extname) { None => { fld.cx.span_err(pth.span, &format!("macro undefined: '{}!'", - extnamestr)); + extname)); // let compilation continue return DummyResult::raw_pat(span); } @@ -1112,7 +1109,7 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { fld.cx.bt_push(ExpnInfo { call_site: span, callee: NameAndSpan { - name: extnamestr.to_string(), + name: extname.to_string(), format: MacroBang, span: tt_span, allow_internal_unstable: allow_internal_unstable, @@ -1132,7 +1129,7 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { pth.span, &format!( "non-pattern macro in pattern position: {}", - &extnamestr + extname ) ); return DummyResult::raw_pat(span); @@ -1145,7 +1142,7 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { _ => { fld.cx.span_err(span, &format!("{}! is not legal in pattern position", - &extnamestr)); + extname)); return DummyResult::raw_pat(span); } } @@ -2121,8 +2118,7 @@ mod tests { = varref.segments.iter().map(|s| s.identifier) .collect(); println!("varref #{}: {:?}, resolves to {}",idx, varref_idents, varref_name); - let string = token::get_ident(final_varref_ident); - println!("varref's first segment's string: \"{}\"", &string[..]); + println!("varref's first segment's string: \"{}\"", final_varref_ident); println!("binding #{}: {}, resolves to {}", binding_idx, bindings[binding_idx], binding_name); mtwt::with_sctable(|x| mtwt::display_sctable(x)); @@ -2174,11 +2170,7 @@ foo_module!(); // find the xx binding let bindings = crate_bindings(&cr); let cxbinds: Vec<&ast::Ident> = - bindings.iter().filter(|b| { - let ident = token::get_ident(**b); - let string = &ident[..]; - "xx" == string - }).collect(); + bindings.iter().filter(|b| b.name == "xx").collect(); let cxbinds: &[&ast::Ident] = &cxbinds[..]; let cxbind = match (cxbinds.len(), cxbinds.get(0)) { (1, Some(b)) => *b, @@ -2190,7 +2182,7 @@ foo_module!(); // the xx binding should bind all of the xx varrefs: for (idx,v) in varrefs.iter().filter(|p| { p.segments.len() == 1 - && "xx" == &*token::get_ident(p.segments[0].identifier) + && p.segments[0].identifier.name == "xx" }).enumerate() { if mtwt::resolve(v.segments[0].identifier) != resolved_binding { println!("uh oh, xx binding didn't match xx varref:"); diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index 5b972b464c9..5a2b9c0eea4 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -121,8 +121,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) return None; } }; - let interned_name = token::get_ident(ident); - let name = &interned_name[..]; + let name: &str = &ident.name.as_str(); panictry!(p.expect(&token::Eq)); let e = p.parse_expr(); diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 82c249d2585..b8168297190 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -407,7 +407,7 @@ fn id_ext(str: &str) -> ast::Ident { // Lift an ident to the expr that evaluates to that ident. fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P { - let e_str = cx.expr_str(sp, token::get_ident(ident)); + let e_str = cx.expr_str(sp, ident.name.as_str()); cx.expr_method_call(sp, cx.expr_ident(sp, id_ext("ext_cx")), id_ext("ident_of"), @@ -416,7 +416,7 @@ fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P { // Lift a name to the expr that evaluates to that name fn mk_name(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P { - let e_str = cx.expr_str(sp, token::get_ident(ident)); + let e_str = cx.expr_str(sp, ident.name.as_str()); cx.expr_method_call(sp, cx.expr_ident(sp, id_ext("ext_cx")), id_ext("name_of"), diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 22517dc5f1b..8da36b2c1e1 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -76,7 +76,7 @@ pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) base::check_zero_tts(cx, sp, tts, "module_path!"); let string = cx.mod_path() .iter() - .map(|x| token::get_ident(*x).to_string()) + .map(|x| x.to_string()) .collect::>() .join("::"); base::MacEager::expr(cx.expr_str( diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 5b3887e76b4..4556bd5f8e5 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -223,11 +223,10 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc]) *idx += 1; } Occupied(..) => { - let string = token::get_ident(bind_name); panic!(p_s.span_diagnostic .span_fatal(sp, &format!("duplicated bind name: {}", - &string))) + bind_name))) } } } @@ -460,9 +459,7 @@ pub fn parse(sess: &ParseSess, let nts = bb_eis.iter().map(|ei| { match ei.top_elts.get_tt(ei.idx) { TtToken(_, MatchNt(bind, name, _, _)) => { - (format!("{} ('{}')", - token::get_ident(name), - token::get_ident(bind))).to_string() + format!("{} ('{}')", name, bind) } _ => panic!() } }).collect::>().join(" or "); @@ -484,11 +481,10 @@ pub fn parse(sess: &ParseSess, let mut ei = bb_eis.pop().unwrap(); match ei.top_elts.get_tt(ei.idx) { - TtToken(span, MatchNt(_, name, _, _)) => { - let name_string = token::get_ident(name); + TtToken(span, MatchNt(_, ident, _, _)) => { let match_cur = ei.match_cur; (&mut ei.matches[match_cur]).push(Rc::new(MatchedNonterminal( - parse_nt(&mut rust_parser, span, &name_string)))); + parse_nt(&mut rust_parser, span, &ident.name.as_str())))); ei.idx += 1; ei.match_cur += 1; } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index e29e0ab54d1..adc88c329a3 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -56,10 +56,9 @@ impl<'a> ParserAnyMacro<'a> { let span = parser.span; parser.span_err(span, &msg[..]); - let name = token::get_ident(self.macro_ident); let msg = format!("caused by the macro expansion here; the usage \ of `{}` is likely invalid in this context", - name); + self.macro_ident); parser.span_note(self.site_span, &msg[..]); } } @@ -154,7 +153,7 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt, -> Box { if cx.trace_macros() { println!("{}! {{ {} }}", - token::get_ident(name), + name, print::pprust::tts_to_string(arg)); } @@ -326,7 +325,7 @@ fn check_matcher<'a, I>(cx: &mut ExtCtxt, matcher: I, follow: &Token) TtToken(sp, MatchNt(ref name, ref frag_spec, _, _)) => { // ii. If T is a simple NT, look ahead to the next token T' in // M. If T' is in the set FOLLOW(NT), continue. Else; reject. - if can_be_followed_by_any(frag_spec.as_str()) { + if can_be_followed_by_any(&frag_spec.name.as_str()) { continue } else { let next_token = match tokens.peek() { @@ -340,13 +339,13 @@ fn check_matcher<'a, I>(cx: &mut ExtCtxt, matcher: I, follow: &Token) // possibility that the sequence occurred // zero times (in which case we need to // look at the token that follows the - // sequence, which may itself a sequence, + // sequence, which may itself be a sequence, // and so on). cx.span_err(sp, &format!("`${0}:{1}` is followed by a \ sequence repetition, which is not \ allowed for `{1}` fragments", - name.as_str(), frag_spec.as_str()) + name, frag_spec) ); Eof }, @@ -359,7 +358,7 @@ fn check_matcher<'a, I>(cx: &mut ExtCtxt, matcher: I, follow: &Token) let tok = if let TtToken(_, ref tok) = *token { tok } else { unreachable!() }; // If T' is in the set FOLLOW(NT), continue. Else, reject. - match (&next_token, is_in_follow(cx, &next_token, frag_spec.as_str())) { + match (&next_token, is_in_follow(cx, &next_token, &frag_spec.name.as_str())) { (_, Err(msg)) => { cx.span_err(sp, &msg); continue @@ -369,7 +368,7 @@ fn check_matcher<'a, I>(cx: &mut ExtCtxt, matcher: I, follow: &Token) (next, Ok(false)) => { cx.span_err(sp, &format!("`${0}:{1}` is followed by `{2}`, which \ is not allowed for `{1}` fragments", - name.as_str(), frag_spec.as_str(), + name, frag_spec, token_to_string(next))); continue }, @@ -495,14 +494,14 @@ fn is_in_follow(_: &ExtCtxt, tok: &Token, frag: &str) -> Result { "pat" => { match *tok { FatArrow | Comma | Eq => Ok(true), - Ident(i, _) if i.as_str() == "if" || i.as_str() == "in" => Ok(true), + Ident(i, _) if i.name == "if" || i.name == "in" => Ok(true), _ => Ok(false) } }, "path" | "ty" => { match *tok { Comma | FatArrow | Colon | Eq | Gt | Semi => Ok(true), - Ident(i, _) if i.as_str() == "as" => Ok(true), + Ident(i, _) if i.name == "as" => Ok(true), _ => Ok(false) } }, diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 368a9f0c27e..0ca755c97b1 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -140,11 +140,9 @@ impl Add for LockstepIterSize { LisContradiction(_) => other, LisConstraint(r_len, _) if l_len == r_len => self.clone(), LisConstraint(r_len, r_id) => { - let l_n = token::get_ident(l_id.clone()); - let r_n = token::get_ident(r_id); LisContradiction(format!("inconsistent lockstep iteration: \ - '{:?}' has {} items, but '{:?}' has {}", - l_n, l_len, r_n, r_len).to_string()) + '{}' has {} items, but '{}' has {}", + l_id, l_len, r_id, r_len)) } }, } @@ -308,8 +306,8 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { MatchedSeq(..) => { panic!(r.sp_diag.span_fatal( r.cur_span, /* blame the macro writer */ - &format!("variable '{:?}' is still repeating at this depth", - token::get_ident(ident)))); + &format!("variable '{}' is still repeating at this depth", + ident))); } } } diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index c3338f02ee4..53b57cdfaa1 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -582,7 +582,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } fn visit_name(&mut self, sp: Span, name: ast::Name) { - if !token::get_name(name).is_ascii() { + if !name.as_str().is_ascii() { self.gate_feature("non_ascii_idents", sp, "non-ascii idents are not fully supported."); } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 34a63fc92fe..70da512e898 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -15,6 +15,7 @@ use codemap::{self, Span, CodeMap, FileMap}; use diagnostic::{SpanHandler, Handler, Auto, FatalError}; use parse::attr::ParserAttr; use parse::parser::Parser; +use parse::token::InternedString; use ptr::P; use str::char_at; @@ -439,7 +440,7 @@ fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool { fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> ast::Lit_ { debug!("filtered_float_lit: {}, {:?}", data, suffix); - match suffix { + match suffix.as_ref().map(|s| &**s) { Some("f32") => ast::LitFloat(data, ast::TyF32), Some("f64") => ast::LitFloat(data, ast::TyF64), Some(suf) => { @@ -457,12 +458,13 @@ fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>, None => ast::LitFloatUnsuffixed(data) } } -pub fn float_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> ast::Lit_ { +pub fn float_lit(s: &str, suffix: Option, + sd: &SpanHandler, sp: Span) -> ast::Lit_ { debug!("float_lit: {:?}, {:?}", s, suffix); // FIXME #2252: bounds checking float literals is deferred until trans let s = s.chars().filter(|&c| c != '_').collect::(); - let data = token::intern_and_get_ident(&*s); - filtered_float_lit(data, suffix, sd, sp) + let data = token::intern_and_get_ident(&s); + filtered_float_lit(data, suffix.as_ref().map(|s| &**s), sd, sp) } /// Parse a string representing a byte literal into its final form. Similar to `char_lit` @@ -557,7 +559,11 @@ pub fn binary_lit(lit: &str) -> Rc> { Rc::new(res) } -pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> ast::Lit_ { +pub fn integer_lit(s: &str, + suffix: Option, + sd: &SpanHandler, + sp: Span) + -> ast::Lit_ { // s can only be ascii, byte indexing is fine let s2 = s.chars().filter(|&c| c != '_').collect::(); @@ -579,8 +585,8 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> } // 1f64 and 2f32 etc. are valid float literals. - match suffix { - Some(suf) if looks_like_width_suffix(&['f'], suf) => { + if let Some(ref suf) = suffix { + if looks_like_width_suffix(&['f'], suf) { match base { 16 => sd.span_err(sp, "hexadecimal float literal is not supported"), 8 => sd.span_err(sp, "octal float literal is not supported"), @@ -588,18 +594,17 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> _ => () } let ident = token::intern_and_get_ident(&*s); - return filtered_float_lit(ident, suffix, sd, sp) + return filtered_float_lit(ident, Some(&**suf), sd, sp) } - _ => {} } if base != 10 { s = &s[2..]; } - if let Some(suf) = suffix { + if let Some(ref suf) = suffix { if suf.is_empty() { sd.span_bug(sp, "found empty literal suffix in Some")} - ty = match suf { + ty = match &**suf { "isize" => ast::SignedIntLit(ast::TyIs, ast::Plus), "i8" => ast::SignedIntLit(ast::TyI8, ast::Plus), "i16" => ast::SignedIntLit(ast::TyI16, ast::Plus), @@ -739,8 +744,8 @@ mod tests { Some(&ast::TtToken(_, token::Ident(name_zip, token::Plain))), Some(&ast::TtDelimited(_, ref macro_delimed)), ) - if name_macro_rules.as_str() == "macro_rules" - && name_zip.as_str() == "zip" => { + if name_macro_rules.name == "macro_rules" + && name_zip.name == "zip" => { let tts = ¯o_delimed.tts[..]; match (tts.len(), tts.get(0), tts.get(1), tts.get(2)) { ( @@ -755,10 +760,10 @@ mod tests { ( 2, Some(&ast::TtToken(_, token::Dollar)), - Some(&ast::TtToken(_, token::Ident(name, token::Plain))), + Some(&ast::TtToken(_, token::Ident(ident, token::Plain))), ) if first_delimed.delim == token::Paren - && name.as_str() == "a" => {}, + && ident.name == "a" => {}, _ => panic!("value 3: {:?}", **first_delimed), } let tts = &second_delimed.tts[..]; @@ -766,10 +771,10 @@ mod tests { ( 2, Some(&ast::TtToken(_, token::Dollar)), - Some(&ast::TtToken(_, token::Ident(name, token::Plain))), + Some(&ast::TtToken(_, token::Ident(ident, token::Plain))), ) if second_delimed.delim == token::Paren - && name.as_str() == "a" => {}, + && ident.name == "a" => {}, _ => panic!("value 4: {:?}", **second_delimed), } }, diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 00d9b7f4ea6..5a72477d4ac 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -92,10 +92,8 @@ impl<'a> ParserObsoleteMethods for parser::Parser<'a> { fn is_obsolete_ident(&mut self, ident: &str) -> bool { match self.token { - token::Ident(sid, _) => { - token::get_ident(sid) == ident - } - _ => false + token::Ident(sid, _) => sid.name == ident, + _ => false, } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 04665140e2f..10b89a530c0 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -288,7 +288,7 @@ impl TokenType { match *self { TokenType::Token(ref t) => format!("`{}`", Parser::token_to_string(t)), TokenType::Operator => "an operator".to_string(), - TokenType::Keyword(kw) => format!("`{}`", token::get_name(kw.to_name())), + TokenType::Keyword(kw) => format!("`{}`", kw.to_name()), } } } @@ -1023,7 +1023,7 @@ impl<'a> Parser<'a> { } pub fn id_to_interned_str(&mut self, id: Ident) -> InternedString { - token::get_ident(id) + id.name.as_str() } /// Is the current token one of the keywords that signals a bare function @@ -1498,20 +1498,20 @@ impl<'a> Parser<'a> { } token::Literal(lit, suf) => { let (suffix_illegal, out) = match lit { - token::Byte(i) => (true, LitByte(parse::byte_lit(i.as_str()).0)), - token::Char(i) => (true, LitChar(parse::char_lit(i.as_str()).0)), + token::Byte(i) => (true, LitByte(parse::byte_lit(&i.as_str()).0)), + token::Char(i) => (true, LitChar(parse::char_lit(&i.as_str()).0)), // there are some valid suffixes for integer and // float literals, so all the handling is done // internally. token::Integer(s) => { - (false, parse::integer_lit(s.as_str(), + (false, parse::integer_lit(&s.as_str(), suf.as_ref().map(|s| s.as_str()), &self.sess.span_diagnostic, self.last_span)) } token::Float(s) => { - (false, parse::float_lit(s.as_str(), + (false, parse::float_lit(&s.as_str(), suf.as_ref().map(|s| s.as_str()), &self.sess.span_diagnostic, self.last_span)) @@ -1519,20 +1519,20 @@ impl<'a> Parser<'a> { token::Str_(s) => { (true, - LitStr(token::intern_and_get_ident(&parse::str_lit(s.as_str())), + LitStr(token::intern_and_get_ident(&parse::str_lit(&s.as_str())), ast::CookedStr)) } token::StrRaw(s, n) => { (true, LitStr( - token::intern_and_get_ident(&parse::raw_str_lit(s.as_str())), + token::intern_and_get_ident(&parse::raw_str_lit(&s.as_str())), ast::RawStr(n))) } token::Binary(i) => - (true, LitBinary(parse::binary_lit(i.as_str()))), + (true, LitBinary(parse::binary_lit(&i.as_str()))), token::BinaryRaw(i, _) => (true, - LitBinary(Rc::new(i.as_str().as_bytes().iter().cloned().collect()))), + LitBinary(Rc::new(i.to_string().into_bytes()))), }; if suffix_illegal { @@ -2448,7 +2448,7 @@ impl<'a> Parser<'a> { match self.token { token::SubstNt(name, _) => return Err(self.fatal(&format!("unknown macro variable `{}`", - token::get_ident(name)))), + name))), _ => {} } } @@ -4740,7 +4740,7 @@ impl<'a> Parser<'a> { if fields.is_empty() { return Err(self.fatal(&format!("unit-like struct definition should be \ written as `struct {};`", - token::get_ident(class_name.clone())))); + class_name))); } try!(self.bump()); @@ -4779,7 +4779,7 @@ impl<'a> Parser<'a> { if fields.is_empty() { return Err(self.fatal(&format!("unit-like struct definition should be \ written as `struct {};`", - token::get_ident(class_name.clone())))); + class_name))); } generics.where_clause = try!(self.parse_where_clause()); @@ -4924,8 +4924,7 @@ impl<'a> Parser<'a> { /// Returns either a path to a module, or . pub fn default_submod_path(id: ast::Ident, dir_path: &Path, codemap: &CodeMap) -> ModulePath { - let mod_string = token::get_ident(id); - let mod_name = mod_string.to_string(); + let mod_name = id.to_string(); let default_path_str = format!("{}.rs", mod_name); let secondary_path_str = format!("{}/mod.rs", mod_name); let default_path = dir_path.join(&default_path_str); @@ -5013,7 +5012,7 @@ impl<'a> Parser<'a> { self.eval_src_mod_from_path(path, owns_directory, - token::get_ident(id).to_string(), + id.to_string(), id_sp) } @@ -5217,7 +5216,7 @@ impl<'a> Parser<'a> { self.span_err(start_span, &format!("unit-like struct variant should be written \ without braces, as `{},`", - token::get_ident(ident))); + ident)); } kind = StructVariantKind(struct_def); } else if self.check(&token::OpenDelim(token::Paren)) { @@ -5285,8 +5284,7 @@ impl<'a> Parser<'a> { let sp = self.span; self.expect_no_suffix(sp, "ABI spec", suf); try!(self.bump()); - let the_string = s.as_str(); - match abi::lookup(the_string) { + match abi::lookup(&s.as_str()) { Some(abi) => Ok(Some(abi)), None => { let last_span = self.last_span; @@ -5295,7 +5293,7 @@ impl<'a> Parser<'a> { &format!("illegal ABI: expected one of [{}], \ found `{}`", abi::all_names().join(", "), - the_string)); + s)); Ok(None) } } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 832fec40199..bd479255438 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -647,6 +647,12 @@ impl InternedString { string: string, } } + + #[inline] + pub fn new_from_name(name: ast::Name) -> InternedString { + let interner = get_ident_interner(); + InternedString::new_from_rc_str(interner.get(name)) + } } impl Deref for InternedString { @@ -678,7 +684,7 @@ impl<'a> PartialEq<&'a str> for InternedString { } } -impl<'a> PartialEq for &'a str { +impl<'a> PartialEq for &'a str { #[inline(always)] fn eq(&self, other: &InternedString) -> bool { PartialEq::eq(*self, &other.string[..]) @@ -691,7 +697,7 @@ impl<'a> PartialEq for &'a str { impl Decodable for InternedString { fn decode(d: &mut D) -> Result { - Ok(get_name(get_ident_interner().intern(&try!(d.read_str())[..]))) + Ok(intern(try!(d.read_str()).as_ref()).as_str()) } } @@ -701,25 +707,11 @@ impl Encodable for InternedString { } } -/// Returns the string contents of a name, using the thread-local interner. -#[inline] -pub fn get_name(name: ast::Name) -> InternedString { - let interner = get_ident_interner(); - InternedString::new_from_rc_str(interner.get(name)) -} - -/// Returns the string contents of an identifier, using the thread-local -/// interner. -#[inline] -pub fn get_ident(ident: ast::Ident) -> InternedString { - get_name(ident.name) -} - /// Interns and returns the string contents of an identifier, using the /// thread-local interner. #[inline] pub fn intern_and_get_ident(s: &str) -> InternedString { - get_name(intern(s)) + intern(s).as_str() } /// Maps a string to its interned representation. diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 448857389da..6cfe85bc37e 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -251,40 +251,40 @@ pub fn token_to_string(tok: &Token) -> String { /* Literals */ token::Literal(lit, suf) => { let mut out = match lit { - token::Byte(b) => format!("b'{}'", b.as_str()), - token::Char(c) => format!("'{}'", c.as_str()), - token::Float(c) => c.as_str().to_string(), - token::Integer(c) => c.as_str().to_string(), - token::Str_(s) => format!("\"{}\"", s.as_str()), + token::Byte(b) => format!("b'{}'", b), + token::Char(c) => format!("'{}'", c), + token::Float(c) => c.to_string(), + token::Integer(c) => c.to_string(), + token::Str_(s) => format!("\"{}\"", s), token::StrRaw(s, n) => format!("r{delim}\"{string}\"{delim}", delim=repeat("#", n), - string=s.as_str()), - token::Binary(v) => format!("b\"{}\"", v.as_str()), + string=s), + token::Binary(v) => format!("b\"{}\"", v), token::BinaryRaw(s, n) => format!("br{delim}\"{string}\"{delim}", delim=repeat("#", n), - string=s.as_str()), + string=s), }; if let Some(s) = suf { - out.push_str(s.as_str()) + out.push_str(&s.as_str()) } out } /* Name components */ - token::Ident(s, _) => token::get_ident(s).to_string(), - token::Lifetime(s) => format!("{}", token::get_ident(s)), + token::Ident(s, _) => s.to_string(), + token::Lifetime(s) => s.to_string(), token::Underscore => "_".to_string(), /* Other */ - token::DocComment(s) => s.as_str().to_string(), + token::DocComment(s) => s.to_string(), token::SubstNt(s, _) => format!("${}", s), token::MatchNt(s, t, _, _) => format!("${}:{}", s, t), token::Eof => "".to_string(), token::Whitespace => " ".to_string(), token::Comment => "/* */".to_string(), - token::Shebang(s) => format!("/* shebang: {}*/", s.as_str()), + token::Shebang(s) => format!("/* shebang: {}*/", s), token::SpecialVarNt(var) => format!("${}", var.as_str()), @@ -819,7 +819,7 @@ impl<'a> State<'a> { try!(self.head(&visibility_qualified(item.vis, "extern crate"))); if let Some(p) = *optional_path { - let val = token::get_name(p); + let val = p.as_str(); if val.contains("-") { try!(self.print_string(&val, ast::CookedStr)); } else { @@ -2009,7 +2009,7 @@ impl<'a> State<'a> { } pub fn print_ident(&mut self, ident: ast::Ident) -> io::Result<()> { - try!(word(&mut self.s, &token::get_ident(ident))); + try!(word(&mut self.s, &ident.name.as_str())); self.ann.post(self, NodeIdent(&ident)) } @@ -2018,7 +2018,7 @@ impl<'a> State<'a> { } pub fn print_name(&mut self, name: ast::Name) -> io::Result<()> { - try!(word(&mut self.s, &token::get_name(name))); + try!(word(&mut self.s, &name.as_str())); self.ann.post(self, NodeName(&name)) } diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs index 36550586531..9787f2537c6 100644 --- a/src/libsyntax/std_inject.rs +++ b/src/libsyntax/std_inject.rs @@ -160,8 +160,7 @@ impl fold::Folder for PreludeInjector { style: ast::AttrOuter, value: P(ast::MetaItem { span: self.span, - node: ast::MetaWord(token::get_name( - special_idents::prelude_import.name)), + node: ast::MetaWord(special_idents::prelude_import.name.as_str()), }), is_sugared_doc: false, }, -- cgit 1.4.1-3-g733a5