about summary refs log tree commit diff
path: root/src/libsyntax/ext
diff options
context:
space:
mode:
Diffstat (limited to 'src/libsyntax/ext')
-rw-r--r--src/libsyntax/ext/base.rs3
-rw-r--r--src/libsyntax/ext/concat_idents.rs3
-rw-r--r--src/libsyntax/ext/deriving/decodable.rs11
-rw-r--r--src/libsyntax/ext/deriving/encodable.rs11
-rw-r--r--src/libsyntax/ext/deriving/generic.rs8
-rw-r--r--src/libsyntax/ext/deriving/show.rs4
-rw-r--r--src/libsyntax/ext/deriving/to_str.rs6
-rw-r--r--src/libsyntax/ext/expand.rs51
-rw-r--r--src/libsyntax/ext/format.rs2
-rw-r--r--src/libsyntax/ext/log_syntax.rs6
-rw-r--r--src/libsyntax/ext/quote.rs15
-rw-r--r--src/libsyntax/ext/source_util.rs8
-rw-r--r--src/libsyntax/ext/tt/macro_parser.rs29
-rw-r--r--src/libsyntax/ext/tt/macro_rules.rs10
-rw-r--r--src/libsyntax/ext/tt/transcribe.rs21
15 files changed, 77 insertions, 111 deletions
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 7ac66ecaa37..0900eca1ad1 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -440,8 +440,7 @@ pub fn get_single_str_from_tts(cx: &ExtCtxt,
         match tts[0] {
             ast::TTTok(_, token::LIT_STR(ident))
             | ast::TTTok(_, token::LIT_STR_RAW(ident, _)) => {
-                let interned_str = token::get_ident(ident.name);
-                return Some(interned_str.get().to_str())
+                return Some(token::get_ident(ident).get().to_str())
             }
             _ => cx.span_err(sp, format!("{} requires a string.", name)),
         }
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index e0d53add648..15e9d31daa0 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -31,8 +31,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
         } else {
             match *e {
                 ast::TTTok(_, token::IDENT(ident,_)) => {
-                    let interned_str = token::get_ident(ident.name);
-                    res_str.push_str(interned_str.get())
+                    res_str.push_str(token::get_ident(ident).get())
                 }
                 _ => {
                     cx.span_err(sp, "concat_idents! requires ident args.");
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index fdf1ef17d53..c1a6b41db9d 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -86,8 +86,7 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                                 decoder,
                                 cx.ident_of("read_struct"),
                                 ~[
-                cx.expr_str(trait_span,
-                            token::get_ident(substr.type_ident.name)),
+                cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
                 cx.expr_uint(trait_span, nfields),
                 cx.lambda_expr_1(trait_span, result, blkarg)
             ])
@@ -100,8 +99,7 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
             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.name)));
+                variants.push(cx.expr_str(v_span, token::get_ident(name)));
 
                 let decoded = decode_static_fields(cx,
                                                    v_span,
@@ -130,8 +128,7 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                                 decoder,
                                 cx.ident_of("read_enum"),
                                 ~[
-                cx.expr_str(trait_span,
-                            token::get_ident(substr.type_ident.name)),
+                cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
                 cx.lambda_expr_1(trait_span, result, blkarg)
             ])
         }
@@ -166,7 +163,7 @@ 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.name), i);
+                let arg = getarg(cx, span, token::get_ident(name), i);
                 cx.field_imm(span, name, arg)
             }).collect();
             cx.expr_struct_ident(trait_span, outer_pat_ident, fields)
diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs
index 43edf6006b4..f35cdab972c 100644
--- a/src/libsyntax/ext/deriving/encodable.rs
+++ b/src/libsyntax/ext/deriving/encodable.rs
@@ -132,7 +132,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                     ..
                 }) in fields.iter().enumerate() {
                 let name = match name {
-                    Some(id) => token::get_ident(id.name),
+                    Some(id) => token::get_ident(id),
                     None => {
                         token::intern_and_get_ident(format!("_field{}", i))
                     }
@@ -152,8 +152,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                                 encoder,
                                 cx.ident_of("emit_struct"),
                                 ~[
-                cx.expr_str(trait_span,
-                            token::get_ident(substr.type_ident.name)),
+                cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
                 cx.expr_uint(trait_span, fields.len()),
                 blk
             ])
@@ -179,8 +178,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.name));
+            let name = cx.expr_str(trait_span, token::get_ident(variant.node.name));
             let call = cx.expr_method_call(trait_span, blkencoder,
                                            cx.ident_of("emit_enum_variant"),
                                            ~[name,
@@ -192,8 +190,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                                           encoder,
                                           cx.ident_of("emit_enum"),
                                           ~[
-                cx.expr_str(trait_span,
-                            token::get_ident(substr.type_ident.name)),
+                cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
                 blk
             ]);
             cx.expr_block(cx.block(trait_span, ~[me], Some(ret)))
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index 9d290c93c64..a9fdb15fdd4 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -178,7 +178,7 @@ StaticEnum(<ast::EnumDef of C>, ~[(<ident of C0>, <span of C0>, Unnamed(~[<span
 
 use ast;
 use ast::{P, EnumDef, Expr, Ident, Generics, StructDef};
-
+use ast_util;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use codemap;
@@ -405,11 +405,13 @@ impl<'a> TraitDef<'a> {
                                ast::LitStr(token::intern_and_get_ident(
                                                "Automatically derived."),
                                            ast::CookedStr)));
+        let opt_trait_ref = Some(trait_ref);
+        let ident = ast_util::impl_pretty_name(&opt_trait_ref, self_type);
         cx.item(
             self.span,
-            ::parse::token::special_idents::clownshoes_extensions,
+            ident,
             ~[doc_attr],
-            ast::ItemImpl(trait_generics, Some(trait_ref),
+            ast::ItemImpl(trait_generics, opt_trait_ref,
                           self_type, methods.map(|x| *x)))
     }
 
diff --git a/src/libsyntax/ext/deriving/show.rs b/src/libsyntax/ext/deriving/show.rs
index e2d507f3035..68fad460a34 100644
--- a/src/libsyntax/ext/deriving/show.rs
+++ b/src/libsyntax/ext/deriving/show.rs
@@ -67,7 +67,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span,
         }
     };
 
-    let mut format_string = token::get_ident(name.name).get().to_owned();
+    let mut format_string = token::get_ident(name).get().to_owned();
     // the internal fields we're actually formatting
     let mut exprs = ~[];
 
@@ -99,7 +99,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span,
                 for (i, field) in fields.iter().enumerate() {
                     if i != 0 { format_string.push_str(","); }
 
-                    let name = token::get_ident(field.name.unwrap().name);
+                    let name = token::get_ident(field.name.unwrap());
                     format_string.push_str(" ");
                     format_string.push_str(name.get());
                     format_string.push_str(": {}");
diff --git a/src/libsyntax/ext/deriving/to_str.rs b/src/libsyntax/ext/deriving/to_str.rs
index e5145fb15f7..8453d0f0312 100644
--- a/src/libsyntax/ext/deriving/to_str.rs
+++ b/src/libsyntax/ext/deriving/to_str.rs
@@ -57,10 +57,10 @@ fn to_str_substructure(cx: &mut ExtCtxt, span: Span, substr: &Substructure)
                 name: ast::Ident,
                 fields: &[FieldInfo]| {
         if fields.len() == 0 {
-            cx.expr_str_uniq(span, token::get_ident(name.name))
+            cx.expr_str_uniq(span, token::get_ident(name))
         } else {
             let buf = cx.ident_of("buf");
-            let interned_str = token::get_ident(name.name);
+            let interned_str = token::get_ident(name);
             let start =
                 token::intern_and_get_ident(interned_str.get() + start);
             let init = cx.expr_str_uniq(span, start);
@@ -81,7 +81,7 @@ fn to_str_substructure(cx: &mut ExtCtxt, span: Span, substr: &Substructure)
                     match name {
                         None => {}
                         Some(id) => {
-                            let interned_id = token::get_ident(id.name);
+                            let interned_id = token::get_ident(id);
                             let name = interned_id.get() + ": ";
                             push(cx.expr_str(span,
                                              token::intern_and_get_ident(name)));
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index d96fc27f3dd..380178191b7 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -54,8 +54,8 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr {
                         // let compilation continue
                         return e;
                     }
-                    let extname = &pth.segments[0].identifier;
-                    let extnamestr = token::get_ident(extname.name);
+                    let extname = pth.segments[0].identifier;
+                    let extnamestr = token::get_ident(extname);
                     // leaving explicit deref here to highlight unbox op:
                     let marked_after = match fld.extsbox.find(&extname.name) {
                         None => {
@@ -297,26 +297,25 @@ pub fn expand_item_mac(it: @ast::Item, fld: &mut MacroExpander)
         _ => fld.cx.span_bug(it.span, "invalid item macro invocation")
     };
 
-    let extname = &pth.segments[0].identifier;
-    let extnamestr = token::get_ident(extname.name);
+    let extname = pth.segments[0].identifier;
+    let extnamestr = token::get_ident(extname);
     let fm = fresh_mark();
     let expanded = match fld.extsbox.find(&extname.name) {
         None => {
             fld.cx.span_err(pth.span,
                             format!("macro undefined: '{}!'",
-                                    extnamestr.get()));
+                                    extnamestr));
             // let compilation continue
             return SmallVector::zero();
         }
 
         Some(&NormalTT(ref expander, span)) => {
             if it.ident.name != parse::token::special_idents::invalid.name {
-                let string = token::get_ident(it.ident.name);
                 fld.cx.span_err(pth.span,
                                 format!("macro {}! expects no ident argument, \
                                         given '{}'",
-                                        extnamestr.get(),
-                                        string.get()));
+                                        extnamestr,
+                                        token::get_ident(it.ident)));
                 return SmallVector::zero();
             }
             fld.cx.bt_push(ExpnInfo {
@@ -418,13 +417,10 @@ fn load_extern_macros(krate: &ast::ViewItem, fld: &mut MacroExpander) {
     let MacroCrate { lib, cnum } = fld.cx.loader.load_crate(krate);
 
     let crate_name = match krate.node {
-        ast::ViewItemExternMod(ref name, _, _) => {
-            let string = token::get_ident(name.name);
-            string.get().to_str()
-        },
-        _ => unreachable!(),
+        ast::ViewItemExternMod(name, _, _) => name,
+        _ => unreachable!()
     };
-    let name = format!("<{} macros>", crate_name);
+    let name = format!("<{} macros>", token::get_ident(crate_name));
 
     let exported_macros = fld.cx.loader.get_exported_macros(cnum);
     for source in exported_macros.iter() {
@@ -496,12 +492,11 @@ pub fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector<@Stmt> {
         fld.cx.span_err(pth.span, "expected macro name without module separators");
         return SmallVector::zero();
     }
-    let extname = &pth.segments[0].identifier;
-    let extnamestr = token::get_ident(extname.name);
+    let extname = pth.segments[0].identifier;
+    let extnamestr = token::get_ident(extname);
     let marked_after = match fld.extsbox.find(&extname.name) {
         None => {
-            fld.cx.span_err(pth.span, format!("macro undefined: '{}'",
-                                              extnamestr.get()));
+            fld.cx.span_err(pth.span, format!("macro undefined: '{}'", extnamestr));
             return SmallVector::zero();
         }
 
@@ -535,7 +530,7 @@ pub fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector<@Stmt> {
                 _ => {
                     fld.cx.span_err(pth.span,
                                     format!("non-stmt macro in stmt pos: {}",
-                                            extnamestr.get()));
+                                            extnamestr));
                     return SmallVector::zero();
                 }
             };
@@ -545,7 +540,7 @@ pub fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector<@Stmt> {
 
         _ => {
             fld.cx.span_err(pth.span, format!("'{}' is not a tt-style macro",
-                                              extnamestr.get()));
+                                              extnamestr));
             return SmallVector::zero();
         }
     };
@@ -1186,9 +1181,7 @@ mod test {
                         println!("uh oh, matches but shouldn't:");
                         println!("varref: {:?}",varref);
                         // good lord, you can't make a path with 0 segments, can you?
-                        let string = token::get_ident(varref.segments[0]
-                                                            .identifier
-                                                            .name);
+                        let string = token::get_ident(varref.segments[0].identifier);
                         println!("varref's first segment's uint: {}, and string: \"{}\"",
                                  varref.segments[0].identifier.name,
                                  string.get());
@@ -1213,10 +1206,7 @@ foo_module!()
         let bindings = name_finder.ident_accumulator;
 
         let cxbinds: ~[&ast::Ident] =
-            bindings.iter().filter(|b| {
-                let string = token::get_ident(b.name);
-                "xx" == string.get()
-            }).collect();
+            bindings.iter().filter(|b| "xx" == token::get_ident(**b).get()).collect();
         let cxbind = match cxbinds {
             [b] => b,
             _ => fail!("expected just one binding for ext_cx")
@@ -1228,12 +1218,9 @@ foo_module!()
         let varrefs = path_finder.path_accumulator;
 
         // the xx binding should bind all of the xx varrefs:
-        for (idx,v) in varrefs.iter().filter(|p|{
+        for (idx,v) in varrefs.iter().filter(|p| {
             p.segments.len() == 1
-            && {
-                let string = token::get_ident(p.segments[0].identifier.name);
-                "xx" == string.get()
-            }
+            && "xx" == token::get_ident(p.segments[0].identifier).get()
         }).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 3eacce5eb1d..01d348595b8 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -112,7 +112,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span,
                     return (extra, None);
                 }
             };
-            let interned_name = token::get_ident(ident.name);
+            let interned_name = token::get_ident(ident);
             let name = interned_name.get();
             p.expect(&token::EQ);
             let e = p.parse_expr();
diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs
index 947e8271f88..5ee4084d207 100644
--- a/src/libsyntax/ext/log_syntax.rs
+++ b/src/libsyntax/ext/log_syntax.rs
@@ -13,7 +13,6 @@ use codemap;
 use ext::base::*;
 use ext::base;
 use print;
-use parse::token::{get_ident_interner};
 
 pub fn expand_syntax_ext(cx: &mut ExtCtxt,
                          sp: codemap::Span,
@@ -21,10 +20,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt,
                       -> base::MacResult {
 
     cx.print_backtrace();
-    println!("{}",
-        print::pprust::tt_to_str(
-            &ast::TTDelim(@tt.to_owned()),
-            get_ident_interner()));
+    println!("{}", print::pprust::tt_to_str(&ast::TTDelim(@tt.to_owned())));
 
     //trivial expression
     MRExpr(@ast::Expr {
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index e9832209904..35a5cbd235a 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -71,14 +71,13 @@ pub mod rt {
 
     impl ToSource for ast::Ident {
         fn to_source(&self) -> ~str {
-            let this = get_ident(self.name);
-            this.get().to_owned()
+            get_ident(*self).get().to_str()
         }
     }
 
     impl ToSource for @ast::Item {
         fn to_source(&self) -> ~str {
-            pprust::item_to_str(*self, get_ident_interner())
+            pprust::item_to_str(*self)
         }
     }
 
@@ -90,7 +89,7 @@ pub mod rt {
 
     impl ToSource for ast::Ty {
         fn to_source(&self) -> ~str {
-            pprust::ty_to_str(self, get_ident_interner())
+            pprust::ty_to_str(self)
         }
     }
 
@@ -102,19 +101,19 @@ pub mod rt {
 
     impl ToSource for Generics {
         fn to_source(&self) -> ~str {
-            pprust::generics_to_str(self, get_ident_interner())
+            pprust::generics_to_str(self)
         }
     }
 
     impl ToSource for @ast::Expr {
         fn to_source(&self) -> ~str {
-            pprust::expr_to_str(*self, get_ident_interner())
+            pprust::expr_to_str(*self)
         }
     }
 
     impl ToSource for ast::Block {
         fn to_source(&self) -> ~str {
-            pprust::block_to_str(self, get_ident_interner())
+            pprust::block_to_str(self)
         }
     }
 
@@ -349,7 +348,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) -> @ast::Expr {
-    let e_str = cx.expr_str(sp, token::get_ident(ident.name));
+    let e_str = cx.expr_str(sp, token::get_ident(ident));
     cx.expr_method_call(sp,
                         cx.expr_ident(sp, id_ext("ext_cx")),
                         id_ext("ident_of"),
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 52010b39a54..150f054b2af 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -16,7 +16,6 @@ use ext::base::*;
 use ext::base;
 use ext::build::AstBuilder;
 use parse;
-use parse::token::get_ident_interner;
 use parse::token;
 use print::pprust;
 
@@ -64,7 +63,7 @@ pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 
 pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     -> base::MacResult {
-    let s = pprust::tts_to_str(tts, get_ident_interner());
+    let s = pprust::tts_to_str(tts);
     base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(s)))
 }
 
@@ -72,10 +71,7 @@ pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "module_path!");
     let string = cx.mod_path()
-                   .map(|x| {
-                        let interned_str = token::get_ident(x.name);
-                        interned_str.get().to_str()
-                    })
+                   .map(|x| token::get_ident(*x).get().to_str())
                    .connect("::");
     base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(string)))
 }
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 92bc204e2c1..c2d005da74e 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -18,7 +18,7 @@ use parse::lexer::*; //resolve bug?
 use parse::ParseSess;
 use parse::attr::ParserAttr;
 use parse::parser::{LifetimeAndTypesWithoutColons, Parser};
-use parse::token::{Token, EOF, to_str, Nonterminal, get_ident_interner};
+use parse::token::{Token, EOF, Nonterminal};
 use parse::token;
 
 use std::hashmap::HashMap;
@@ -180,14 +180,15 @@ pub fn nameize(p_s: @ParseSess, ms: &[Matcher], res: &[@NamedMatch])
             };
           }
           codemap::Spanned {
-                node: MatchNonterminal(ref bind_name, _, idx), span: sp
+                node: MatchNonterminal(bind_name, _, idx),
+                span
           } => {
-            if ret_val.contains_key(bind_name) {
-                let string = token::get_ident(bind_name.name);
+            if ret_val.contains_key(&bind_name) {
+                let string = token::get_ident(bind_name);
                 p_s.span_diagnostic
-                   .span_fatal(sp, "duplicated bind name: " + string.get())
+                   .span_fatal(span, "duplicated bind name: " + string.get())
             }
-            ret_val.insert(*bind_name, res[idx]);
+            ret_val.insert(bind_name, res[idx]);
           }
         }
     }
@@ -364,12 +365,10 @@ pub fn parse<R: Reader>(sess: @ParseSess,
                 || bb_eis.len() > 1u {
                 let nts = bb_eis.map(|ei| {
                     match ei.elts[ei.idx].node {
-                      MatchNonterminal(ref bind,ref name,_) => {
-                        let bind_string = token::get_ident(bind.name);
-                        let name_string = token::get_ident(name.name);
+                      MatchNonterminal(bind, name, _) => {
                         format!("{} ('{}')",
-                                name_string.get(),
-                                bind_string.get())
+                                token::get_ident(name),
+                                token::get_ident(bind))
                       }
                       _ => fail!()
                     } }).connect(" or ");
@@ -379,7 +378,7 @@ pub fn parse<R: Reader>(sess: @ParseSess,
                     nts, next_eis.len()));
             } else if bb_eis.len() == 0u && next_eis.len() == 0u {
                 return Failure(sp, format!("no rules expected the token `{}`",
-                            to_str(get_ident_interner(), &tok)));
+                            token::to_str(&tok)));
             } else if next_eis.len() > 0u {
                 /* Now process the next token */
                 while next_eis.len() > 0u {
@@ -391,8 +390,8 @@ pub fn parse<R: Reader>(sess: @ParseSess,
 
                 let mut ei = bb_eis.pop().unwrap();
                 match ei.elts[ei.idx].node {
-                  MatchNonterminal(_, ref name, idx) => {
-                    let name_string = token::get_ident(name.name);
+                  MatchNonterminal(_, name, idx) => {
+                    let name_string = token::get_ident(name);
                     ei.matches[idx].push(@MatchedNonterminal(
                         parse_nt(&mut rust_parser, name_string.get())));
                     ei.idx += 1u;
@@ -426,7 +425,7 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
       "ident" => match p.token {
         token::IDENT(sn,b) => { p.bump(); token::NtIdent(~sn,b) }
         _ => {
-            let token_str = token::to_str(get_ident_interner(), &p.token);
+            let token_str = token::to_str(&p.token);
             p.fatal(~"expected ident, found " + token_str)
         }
       },
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index e196bdccfe3..45fe24ebf68 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::{parse, parse_or_else};
 use parse::lexer::new_tt_reader;
 use parse::parser::Parser;
 use parse::attr::ParserAttr;
-use parse::token::{get_ident_interner, special_idents, gensym_ident};
+use parse::token::{special_idents, gensym_ident};
 use parse::token::{FAT_ARROW, SEMI, NtMatchers, NtTT, EOF};
 use parse::token;
 use print;
@@ -113,11 +113,9 @@ fn generic_extension(cx: &ExtCtxt,
                      rhses: &[@NamedMatch])
                      -> MacResult {
     if cx.trace_macros() {
-        let interned_name = token::get_ident(name.name);
         println!("{}! \\{ {} \\}",
-                 interned_name.get(),
-                 print::pprust::tt_to_str(&TTDelim(@arg.to_owned()),
-                                          get_ident_interner()));
+                 token::get_ident(name),
+                 print::pprust::tt_to_str(&TTDelim(@arg.to_owned())));
     }
 
     // Which arm's failure should we report? (the one furthest along)
@@ -231,7 +229,7 @@ pub fn add_new_extension(cx: &mut ExtCtxt,
     };
 
     return MRDef(MacroDef {
-        name: token::get_ident(name.name).get().to_str(),
+        name: token::get_ident(name).get().to_str(),
         ext: NormalTT(exp, Some(sp))
     });
 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index fccbc57f12c..fb2aae9b8c1 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -19,7 +19,6 @@ use parse::lexer::TokenAndSpan;
 
 use std::cell::{Cell, RefCell};
 use std::hashmap::HashMap;
-use std::option;
 
 ///an unzipping of `TokenTree`s
 struct TtFrame {
@@ -57,7 +56,7 @@ pub fn new_tt_reader(sp_diag: @SpanHandler,
             idx: Cell::new(0u),
             dotdotdoted: false,
             sep: None,
-            up: option::None
+            up: None
         }),
         interpolations: match interp { /* just a convienience */
             None => RefCell::new(HashMap::new()),
@@ -122,10 +121,9 @@ fn lookup_cur_matched(r: &TtReader, name: Ident) -> @NamedMatch {
     match matched_opt {
         Some(s) => lookup_cur_matched_by_matched(r, s),
         None => {
-            let name_string = token::get_ident(name.name);
             r.sp_diag.span_fatal(r.cur_span.get(),
                                  format!("unknown macro variable `{}`",
-                                         name_string.get()));
+                                         token::get_ident(name)));
         }
     }
 }
@@ -141,16 +139,16 @@ fn lis_merge(lhs: LockstepIterSize, rhs: LockstepIterSize) -> LockstepIterSize {
     match lhs {
         LisUnconstrained => rhs.clone(),
         LisContradiction(_) => lhs.clone(),
-        LisConstraint(l_len, ref l_id) => match rhs {
+        LisConstraint(l_len, l_id) => match rhs {
             LisUnconstrained => lhs.clone(),
             LisContradiction(_) => rhs.clone(),
             LisConstraint(r_len, _) if l_len == r_len => lhs.clone(),
-            LisConstraint(r_len, ref r_id) => {
-                let l_n = token::get_ident(l_id.name);
-                let r_n = token::get_ident(r_id.name);
+            LisConstraint(r_len, r_id) => {
+                let l_n = token::get_ident(l_id);
+                let r_n = token::get_ident(r_id);
                 LisContradiction(format!("inconsistent lockstep iteration: \
                                           '{}' has {} items, but '{}' has {}",
-                                          l_n.get(), l_len, r_n.get(), r_len))
+                                          l_n, l_len, r_n, r_len))
             }
         }
     }
@@ -240,7 +238,7 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
                 idx: Cell::new(0u),
                 dotdotdoted: false,
                 sep: None,
-                up: option::Some(r.stack.get())
+                up: Some(r.stack.get())
             });
             // if this could be 0-length, we'd need to potentially recur here
           }
@@ -314,11 +312,10 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
                 return ret_val;
               }
               MatchedSeq(..) => {
-                let string = token::get_ident(ident.name);
                 r.sp_diag.span_fatal(
                     r.cur_span.get(), /* blame the macro writer */
                     format!("variable '{}' is still repeating at this depth",
-                            string.get()));
+                            token::get_ident(ident)));
               }
             }
           }
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-28 08:21:47 +0000