Add `Ident::as_str` helper

diff --git a/src/doc/unstable-book/src/language-features/plugin.md b/src/doc/unstable-book/src/language-features/plugin.md
index 1cece930eeaa56bfe65e6dd657fa88d944ff01ce..2f645cf0470c0bc7488aaf394286ce8d89fb5107 100644 (file)
--- a/src/doc/unstable-book/src/language-features/plugin.md
+++ b/src/doc/unstable-book/src/language-features/plugin.md
@@ -208,7 +208,7 @@ impl LintPass for Pass {
 
 impl EarlyLintPass for Pass {
     fn check_item(&mut self, cx: &EarlyContext, it: &ast::Item) {
-        if it.ident.name.as_str() == "lintme" {
+        if it.ident.as_str() == "lintme" {
             cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'");
         }
     }

diff --git a/src/libproc_macro/lib.rs b/src/libproc_macro/lib.rs
index bcab61680965afc3aa1b381216e5ac4d1aebaf30..0229bad6973261f9a7c65862a83d365174689864 100644 (file)
--- a/src/libproc_macro/lib.rs
+++ b/src/libproc_macro/lib.rs
@@ -1214,14 +1214,14 @@ macro_rules! op {
             SingleQuote => op!('\''),
 
             Ident(ident, false) => {
-                tt!(self::Ident::new(&ident.name.as_str(), Span(span)))
+                tt!(self::Ident::new(&ident.as_str(), Span(span)))
             }
             Ident(ident, true) => {
-                tt!(self::Ident::new_raw(&ident.name.as_str(), Span(span)))
+                tt!(self::Ident::new_raw(&ident.as_str(), Span(span)))
             }
             Lifetime(ident) => {
                 let ident = ident.without_first_quote();
-                stack.push(tt!(self::Ident::new(&ident.name.as_str(), Span(span))));
+                stack.push(tt!(self::Ident::new(&ident.as_str(), Span(span))));
                 tt!(Punct::new('\'', Spacing::Joint))
             }
             Literal(lit, suffix) => tt!(self::Literal { lit, suffix, span: Span(span) }),

diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
index 254b77c11d803aa2f5b5e2db2e44295e83efd046..ebc59964172ac340fb21a79375ab2df9f3c60727 100644 (file)
--- a/src/librustc/hir/mod.rs
+++ b/src/librustc/hir/mod.rs
@@ -1983,7 +1983,7 @@ pub struct StructField {
 impl StructField {
     // Still necessary in couple of places
     pub fn is_positional(&self) -> bool {
-        let first = self.ident.name.as_str().as_bytes()[0];
+        let first = self.ident.as_str().as_bytes()[0];
         first >= b'0' && first <= b'9'
     }
 }

diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
index 9ad427ab5b1c28e04d889c4451dee203548bb20a..4bee4f9add025136d7a8a8268ba5e03ab07d2776 100644 (file)
--- a/src/librustc/hir/print.rs
+++ b/src/librustc/hir/print.rs
@@ -1565,7 +1565,7 @@ pub fn print_ident(&mut self, ident: ast::Ident) -> io::Result<()> {
         if ident.is_raw_guess() {
             self.s.word(&format!("r#{}", ident.name))?;
         } else {
-            self.s.word(&ident.name.as_str())?;
+            self.s.word(&ident.as_str())?;
         }
         self.ann.post(self, NodeName(&ident.name))
     }

diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
index 774d83648854dc3e7d1909bb6a9dab57f8f094ed..d35884ec78a82b5a37a4289ecc22eddc7fd1c377 100644 (file)
--- a/src/librustc/mir/mod.rs
+++ b/src/librustc/mir/mod.rs
@@ -1774,7 +1774,7 @@ fn fmt_tuple(fmt: &mut Formatter, places: &[Operand]) -> fmt::Result {
                             CtorKind::Fictive => {
                                 let mut struct_fmt = fmt.debug_struct("");
                                 for (field, place) in variant_def.fields.iter().zip(places) {
-                                    struct_fmt.field(&field.ident.name.as_str(), place);
+                                    struct_fmt.field(&field.ident.as_str(), place);
                                 }
                                 struct_fmt.finish()
                             }

diff --git a/src/librustc_codegen_utils/symbol_names.rs b/src/librustc_codegen_utils/symbol_names.rs
index 2063db6dc533103ece971c98f1372aadb6d10447..123816c1f97dfc8ef9fa000ee81a23ff19d40dfd 100644 (file)
--- a/src/librustc_codegen_utils/symbol_names.rs
+++ b/src/librustc_codegen_utils/symbol_names.rs
@@ -363,7 +363,7 @@ fn from_interned(symbol: ty::SymbolName) -> Self {
             result: String::with_capacity(64),
             temp_buf: String::with_capacity(16),
         };
-        result.result.push_str(&symbol.name.as_str());
+        result.result.push_str(&symbol.as_str());
         result
     }
 

diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs
index 3deff82d35b9fcf9d79b5941fef9fa803c5d499f..dbf756f80ca3853bb492549b8213171dd29139bb 100644 (file)
--- a/src/librustc_lint/bad_style.rs
+++ b/src/librustc_lint/bad_style.rs
@@ -324,7 +324,7 @@ fn check_struct_def(&mut self,
                         _: &hir::Generics,
                         _: ast::NodeId) {
         for sf in s.fields() {
-            self.check_snake_case(cx, "structure field", &sf.ident.name.as_str(), Some(sf.span));
+            self.check_snake_case(cx, "structure field", &sf.ident.as_str(), Some(sf.span));
         }
     }
 }

diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs
index 9607a84124af5f7ac4ef45b25cd91a7a8e0e4802..f83ea6fa13b5284b1fb1cb349f181d2f987fe127 100644 (file)
--- a/src/librustc_mir/monomorphize/partitioning.rs
+++ b/src/librustc_mir/monomorphize/partitioning.rs
@@ -772,7 +772,7 @@ fn debug_dump<'a, 'b, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             debug!("CodegenUnit {}:", cgu.name());
 
             for (mono_item, linkage) in cgu.items() {
-                let symbol_name = mono_item.symbol_name(tcx).name.as_str();
+                let symbol_name = mono_item.symbol_name(tcx).as_str();
                 let symbol_hash_start = symbol_name.rfind('h');
                 let symbol_hash = symbol_hash_start.map(|i| &symbol_name[i ..])
                                                    .unwrap_or("<no hash>");

diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 84b17f155a0e97ed2ac73a7448d71b0a1e4f3443..41b44f717c944bf8e4e541bb44f243662d82a33f 100644 (file)
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -1060,7 +1060,7 @@ fn for_each_child<F: FnMut(Ident, Namespace, &'a NameBinding<'a>)>(&self, mut f:
     fn for_each_child_stable<F: FnMut(Ident, Namespace, &'a NameBinding<'a>)>(&self, mut f: F) {
         let resolutions = self.resolutions.borrow();
         let mut resolutions = resolutions.iter().collect::<Vec<_>>();
-        resolutions.sort_by_cached_key(|&(&(ident, ns), _)| (ident.name.as_str(), ns));
+        resolutions.sort_by_cached_key(|&(&(ident, ns), _)| (ident.as_str(), ns));
         for &(&(ident, ns), &resolution) in resolutions.iter() {
             resolution.borrow().binding.map(|binding| f(ident, ns, binding));
         }
@@ -2608,7 +2608,7 @@ fn fresh_binding(&mut self,
                     self,
                     ident.span,
                     ResolutionError::IdentifierBoundMoreThanOnceInSamePattern(
-                        &ident.name.as_str())
+                        &ident.as_str())
                 );
             }
             Some(..) if pat_src == PatternSource::FnParam => {
@@ -2617,7 +2617,7 @@ fn fresh_binding(&mut self,
                     self,
                     ident.span,
                     ResolutionError::IdentifierBoundMoreThanOnceInParameterList(
-                        &ident.name.as_str())
+                        &ident.as_str())
                 );
             }
             Some(..) if pat_src == PatternSource::Match ||
@@ -3765,12 +3765,12 @@ fn resolve_expr(&mut self, expr: &Expr, parent: Option<&Expr>) {
                         // the closest match
                         let close_match = self.search_label(label.ident, |rib, ident| {
                             let names = rib.bindings.iter().map(|(id, _)| &id.name);
-                            find_best_match_for_name(names, &*ident.name.as_str(), None)
+                            find_best_match_for_name(names, &*ident.as_str(), None)
                         });
                         self.record_def(expr.id, err_path_resolution());
                         resolve_error(self,
                                       label.ident.span,
-                                      ResolutionError::UndeclaredLabel(&label.ident.name.as_str(),
+                                      ResolutionError::UndeclaredLabel(&label.ident.as_str(),
                                                                        close_match));
                     }
                     Some(Def::Label(id)) => {
@@ -4380,7 +4380,7 @@ fn names_to_string(idents: &[Ident]) -> String {
         if i > 0 {
             result.push_str("::");
         }
-        result.push_str(&ident.name.as_str());
+        result.push_str(&ident.as_str());
     }
     result
 }

diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
index d6d00b3183e1a3292aac536ac6feb9482ae31d84..297c42f961599c9d2712330520c4a5daf79b0e85 100644 (file)
--- a/src/librustc_resolve/macros.rs
+++ b/src/librustc_resolve/macros.rs
@@ -649,7 +649,7 @@ pub fn finalize_current_module_macro_resolutions(&mut self) {
                             format!("cannot find derive macro `{}` in this scope", ident),
                     };
                     let mut err = self.session.struct_span_err(span, &msg);
-                    self.suggest_macro_name(&ident.name.as_str(), kind, &mut err, span);
+                    self.suggest_macro_name(&ident.as_str(), kind, &mut err, span);
                     err.emit();
                 },
                 _ => {},

diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs
index 91de3a34cc84abc48c837bb8a10690809dfce2cf..34f84597adfc52fed487351dcd4ec0614f4fa28b 100644 (file)
--- a/src/librustc_resolve/resolve_imports.rs
+++ b/src/librustc_resolve/resolve_imports.rs
@@ -831,7 +831,7 @@ fn finalize_import(&mut self, directive: &'b ImportDirective<'b>) -> Option<(Spa
                     }
                 });
                 let lev_suggestion =
-                    match find_best_match_for_name(names, &ident.name.as_str(), None) {
+                    match find_best_match_for_name(names, &ident.as_str(), None) {
                         Some(name) => format!(". Did you mean to use `{}`?", name),
                         None => "".to_owned(),
                     };

diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 474a83a6d6ccfe0862007d61ff8ae40467fa2ca6..9a994e0e1de8b2afbc1849fd60eddc82cad5a03c 100644 (file)
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -3076,7 +3076,7 @@ fn check_field(&self,
                     }
                 }
                 ty::TyTuple(ref tys) => {
-                    let fstr = field.name.as_str();
+                    let fstr = field.as_str();
                     if let Ok(index) = fstr.parse::<usize>() {
                         if fstr == index.to_string() {
                             if let Some(field_ty) = tys.get(index) {
@@ -3123,7 +3123,7 @@ fn check_field(&self,
                     ty::TyAdt(def, _) if !def.is_enum() => {
                         if let Some(suggested_field_name) =
                             Self::suggest_field_name(def.non_enum_variant(),
-                                                     &field.name.as_str(), vec![]) {
+                                                     &field.as_str(), vec![]) {
                                 err.span_label(field.span,
                                                format!("did you mean `{}`?", suggested_field_name));
                             } else {
@@ -3161,7 +3161,7 @@ fn suggest_field_name(variant: &'tcx ty::VariantDef,
                           -> Option<Symbol> {
         let names = variant.fields.iter().filter_map(|field| {
             // ignore already set fields and private fields from non-local crates
-            if skip.iter().any(|x| *x == field.ident.name.as_str()) ||
+            if skip.iter().any(|x| *x == field.ident.as_str()) ||
                (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
                 None
             } else {
@@ -3223,9 +3223,9 @@ fn report_unknown_field(&self,
             },
             ty);
         // prevent all specified fields from being suggested
-        let skip_fields = skip_fields.iter().map(|ref x| x.ident.name.as_str());
+        let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
         if let Some(field_name) = Self::suggest_field_name(variant,
-                                                           &field.ident.name.as_str(),
+                                                           &field.ident.as_str(),
                                                            skip_fields.collect()) {
             err.span_label(field.ident.span,
                            format!("field does not exist - did you mean `{}`?", field_name));
@@ -3334,7 +3334,7 @@ fn check_expr_struct_fields(&self,
 
             let mut displayable_field_names = remaining_fields
                                               .keys()
-                                              .map(|ident| ident.name.as_str())
+                                              .map(|ident| ident.as_str())
                                               .collect::<Vec<_>>();
 
             displayable_field_names.sort();

diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 3d3d46555c37bcceb5fa188ec9f85947daa568dd..5939d5341e324a5cc28f3d222b021c1a2607eacf 100644 (file)
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -324,7 +324,7 @@ fn write_token<W: Writer>(&mut self,
 
             // Keywords are also included in the identifier set.
             token::Ident(ident, is_raw) => {
-                match &*ident.name.as_str() {
+                match &*ident.as_str() {
                     "ref" | "mut" if !is_raw => Class::RefKeyWord,
 
                     "self" | "Self" => Class::Self_,

diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs
index 6c3117b963fed8ad00884384f74cb027e619495d..ca0293aca6e77ad0e22631172568c78247c14c4b 100644 (file)
--- a/src/libsyntax/diagnostics/plugin.rs
+++ b/src/libsyntax/diagnostics/plugin.rs
@@ -162,7 +162,7 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
         ecx.parse_sess.registered_diagnostics.with_lock(|diagnostics| {
             if let Err(e) = output_metadata(ecx,
                                             &target_triple,
-                                            &crate_name.name.as_str(),
+                                            &crate_name.as_str(),
                                             diagnostics) {
                 ecx.span_bug(span, &format!(
                     "error writing metadata for triple `{}` and crate `{}`, error: {}, \

diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 146db632c07bae6c12b33bc92db529764843be34..667105a534aa3b704805de078d20376d1d4b6162 100644 (file)
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -178,7 +178,7 @@ fn macro_bang_format(path: &ast::Path) -> ExpnFormat {
         if segment.ident.name != keywords::CrateRoot.name() &&
             segment.ident.name != keywords::DollarCrate.name()
         {
-            path_str.push_str(&segment.ident.name.as_str())
+            path_str.push_str(&segment.ident.as_str())
         }
     }
 
@@ -1266,7 +1266,7 @@ fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> {
                             DirectoryOwnership::Owned { relative: None };
                         module.directory.push(&*path.as_str());
                     } else {
-                        module.directory.push(&*item.ident.name.as_str());
+                        module.directory.push(&*item.ident.as_str());
                     }
                 } else {
                     let path = self.cx.parse_sess.codemap().span_to_unmapped_path(inner);

diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index faf7e06c9f38f5eed691675f20fe8864d36e3d53..058317e05c7f7faab0b0abe5ddb297f1dca612f9 100644 (file)
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -573,7 +573,7 @@ fn inner_parse_loop<'a>(
                 TokenTree::MetaVarDecl(_, _, id) => {
                     // Built-in nonterminals never start with these tokens,
                     // so we can eliminate them from consideration.
-                    if may_begin_with(&*id.name.as_str(), token) {
+                    if may_begin_with(&*id.as_str(), token) {
                         bb_items.push(item);
                     }
                 }
@@ -742,7 +742,7 @@ pub fn parse(
                 let match_cur = item.match_cur;
                 item.push_match(
                     match_cur,
-                    MatchedNonterminal(Rc::new(parse_nt(&mut parser, span, &ident.name.as_str()))),
+                    MatchedNonterminal(Rc::new(parse_nt(&mut parser, span, &ident.as_str()))),
                 );
                 item.idx += 1;
                 item.match_cur += 1;

diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 8fc1d363914104cedf85f1ae1532e313f2157997..2e6d590c333cf562ae1bbc187258012e6ffb2a05 100644 (file)
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -148,7 +148,7 @@ fn generic_extension<'cx>(cx: &'cx mut ExtCtxt,
                 };
                 let mut p = Parser::new(cx.parse_sess(), tts, Some(directory), true, false);
                 p.root_module_name = cx.current_expansion.module.mod_path.last()
-                    .map(|id| id.name.as_str().to_string());
+                    .map(|id| id.as_str().to_string());
 
                 p.process_potential_macro_variable();
                 // Let the context choose how to interpret the result.
@@ -730,7 +730,7 @@ fn check_matcher_core(sess: &ParseSess,
         'each_last: for token in &last.tokens {
             if let TokenTree::MetaVarDecl(_, ref name, ref frag_spec) = *token {
                 for next_token in &suffix_first.tokens {
-                    match is_in_follow(next_token, &frag_spec.name.as_str()) {
+                    match is_in_follow(next_token, &frag_spec.as_str()) {
                         Err((msg, help)) => {
                             sess.span_diagnostic.struct_span_err(next_token.span(), &msg)
                                 .help(help).emit();
@@ -768,7 +768,7 @@ fn check_matcher_core(sess: &ParseSess,
 
 fn token_can_be_followed_by_any(tok: &quoted::TokenTree) -> bool {
     if let quoted::TokenTree::MetaVarDecl(_, _, frag_spec) = *tok {
-        frag_can_be_followed_by_any(&frag_spec.name.as_str())
+        frag_can_be_followed_by_any(&frag_spec.as_str())
     } else {
         // (Non NT's can always be followed by anthing in matchers.)
         true
@@ -893,7 +893,7 @@ fn has_legal_fragment_specifier(sess: &ParseSess,
                                 tok: &quoted::TokenTree) -> Result<(), String> {
     debug!("has_legal_fragment_specifier({:?})", tok);
     if let quoted::TokenTree::MetaVarDecl(_, _, ref frag_spec) = *tok {
-        let frag_name = frag_spec.name.as_str();
+        let frag_name = frag_spec.as_str();
         let frag_span = tok.span();
         if !is_legal_fragment_specifier(sess, features, attrs, &frag_name, frag_span) {
             return Err(frag_name.to_string());

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 5a3e5586495cfd1b155a5ab6782a37b87fdf64cb..4d38d29287662ae27aa008daa1c16703dacb5604 100644 (file)
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -6054,7 +6054,7 @@ fn push_directory(&mut self, id: Ident, attrs: &[Attribute]) {
             self.directory.path.to_mut().push(&path.as_str());
             self.directory.ownership = DirectoryOwnership::Owned { relative: None };
         } else {
-            self.directory.path.to_mut().push(&id.name.as_str());
+            self.directory.path.to_mut().push(&id.as_str());
         }
     }
 
@@ -6075,7 +6075,7 @@ pub fn default_submod_path(
         // `./<id>.rs` and `./<id>/mod.rs`.
         let relative_prefix_string;
         let relative_prefix = if let Some(ident) = relative {
-            relative_prefix_string = format!("{}{}", ident.name.as_str(), path::MAIN_SEPARATOR);
+            relative_prefix_string = format!("{}{}", ident.as_str(), path::MAIN_SEPARATOR);
             &relative_prefix_string
         } else {
             ""

diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index ed28d5f33b92134e19ffa7d0ee0965cc4f768b09..9770fbca8f86cfab0e8500d4933bc5c2208e7be7 100644 (file)
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -341,7 +341,7 @@ pub fn is_lifetime(&self) -> bool {
     /// string slice.
     pub fn is_ident_named(&self, name: &str) -> bool {
         match self.ident() {
-            Some((ident, _)) => ident.name.as_str() == name,
+            Some((ident, _)) => ident.as_str() == name,
             None => false
         }
     }

diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 585d49d7076c48b297fba5c5afa4b4ed52ab606b..d8e70a9045c9d483d7d1baa9bdf5c184623bb14e 100644 (file)
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -724,7 +724,7 @@ fn print_attribute_path(&mut self, path: &ast::Path) -> io::Result<()> {
             if segment.ident.name != keywords::CrateRoot.name() &&
                segment.ident.name != keywords::DollarCrate.name()
             {
-                self.writer().word(&segment.ident.name.as_str())?;
+                self.writer().word(&segment.ident.as_str())?;
             } else if segment.ident.name == keywords::DollarCrate.name() {
                 self.print_dollar_crate(segment.ident.span.ctxt())?;
             }
@@ -2373,7 +2373,7 @@ pub fn print_ident(&mut self, ident: ast::Ident) -> io::Result<()> {
         if ident.is_raw_guess() {
             self.s.word(&format!("r#{}", ident))?;
         } else {
-            self.s.word(&ident.name.as_str())?;
+            self.s.word(&ident.as_str())?;
         }
         self.ann.post(self, NodeIdent(&ident))
     }

diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
index 1dfd48a24c3bfbb4009052492346d2220ec4e73d..e63a3d47a828fdfde53e4e649b0c61e43e7261b3 100644 (file)
--- a/src/libsyntax/test.rs
+++ b/src/libsyntax/test.rs
@@ -647,7 +647,7 @@ fn path_name_i(idents: &[Ident]) -> String {
     let mut path_name = "".to_string();
     let mut idents_iter = idents.iter().peekable();
     while let Some(ident) = idents_iter.next() {
-        path_name.push_str(&ident.name.as_str());
+        path_name.push_str(&ident.as_str());
         if let Some(_) = idents_iter.peek() {
             path_name.push_str("::")
         }

diff --git a/src/libsyntax_ext/concat_idents.rs b/src/libsyntax_ext/concat_idents.rs
index b8345e7cf40c109431a740ab8aea7b19efb46a24..828c24708416732e2708a77c8e5284b4fa2be032 100644 (file)
--- a/src/libsyntax_ext/concat_idents.rs
+++ b/src/libsyntax_ext/concat_idents.rs
@@ -49,7 +49,7 @@ pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt,
         } else {
             match *e {
                 TokenTree::Token(_, token::Ident(ident, _)) =>
-                    res_str.push_str(&ident.name.as_str()),
+                    res_str.push_str(&ident.as_str()),
                 _ => {
                     cx.span_err(sp, "concat_idents! requires ident args.");
                     return DummyResult::expr(sp);

diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs
index 0dd55f8d77738a4d53fa6d74844822a9bfeedd93..a5b348a661a78a5ed78e2f7f24022a945d79753a 100644 (file)
--- a/src/libsyntax_ext/deriving/mod.rs
+++ b/src/libsyntax_ext/deriving/mod.rs
@@ -136,7 +136,7 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String {
             ast::ItemKind::Enum(_, ast::Generics { ref params, .. }) => {
                 for param in params.iter() {
                     if let ast::GenericParam::Type(ref ty) = *param{
-                        typaram.push_str(&ty.ident.name.as_str());
+                        typaram.push_str(&ty.ident.as_str());
                     }
                 }
             }

diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs
index b22098408a332f06623bc2e29aeede2c28b3fa8e..4bf764b1101fa6f1ffae26c15a65f5aaff2a31c7 100644 (file)
--- a/src/libsyntax_ext/format.rs
+++ b/src/libsyntax_ext/format.rs
@@ -166,7 +166,7 @@ fn parse_args(ecx: &mut ExtCtxt,
                     return None;
                 }
             };
-            let name: &str = &ident.name.as_str();
+            let name: &str = &ident.as_str();
 
             panictry!(p.expect(&token::Eq));
             let e = panictry!(p.parse_expr());

diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs
index a08f9b2e54a7c63065584879539da96a273cf8fe..a4b2d9de932a71194994202cfa4fc548b29dcce1 100644 (file)
--- a/src/libsyntax_pos/symbol.rs
+++ b/src/libsyntax_pos/symbol.rs
@@ -56,7 +56,7 @@ pub fn with_span_pos(self, span: Span) -> Ident {
     }
 
     pub fn without_first_quote(self) -> Ident {
-        Ident::new(Symbol::intern(self.name.as_str().trim_left_matches('\'')), self.span)
+        Ident::new(Symbol::intern(self.as_str().trim_left_matches('\'')), self.span)
     }
 
     pub fn modern(self) -> Ident {
@@ -66,6 +66,10 @@ pub fn modern(self) -> Ident {
     pub fn gensym(self) -> Ident {
         Ident::new(self.name.gensymed(), self.span)
     }
+
+    pub fn as_str(self) -> LocalInternedString {
+        self.name.as_str()
+    }
 }
 
 impl PartialEq for Ident {
@@ -96,10 +100,10 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 impl Encodable for Ident {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         if self.span.ctxt().modern() == SyntaxContext::empty() {
-            s.emit_str(&self.name.as_str())
+            s.emit_str(&self.as_str())
         } else { // FIXME(jseyfried) intercrate hygiene
             let mut string = "#".to_owned();
-            string.push_str(&self.name.as_str());
+            string.push_str(&self.as_str());
             s.emit_str(&string)
         }
     }