Add Ident::as_str helper

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'");
         }
     }

src/libproc_macro/lib.rs

@@ -1214,14 +1214,14 @@ impl TokenTree {
             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) }),

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'
     }
 }

src/librustc/hir/print.rs

@@ -1565,7 +1565,7 @@ impl<'a> State<'a> {
         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))
     }

src/librustc/mir/mod.rs

@@ -1774,7 +1774,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                             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()
                             }

src/librustc_codegen_utils/symbol_names.rs

@@ -363,7 +363,7 @@ impl SymbolPathBuffer {
             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
     }
 

src/librustc_lint/bad_style.rs

@@ -324,7 +324,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase {
                         _: &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));
         }
     }
 }

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

src/librustc_resolve/lib.rs

@@ -1060,7 +1060,7 @@ impl<'a> ModuleData<'a> {
     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 @@ impl<'a> Resolver<'a> {
                     self,
                     ident.span,
                     ResolutionError::IdentifierBoundMoreThanOnceInSamePattern(
-                        &ident.name.as_str())
+                        &ident.as_str())
                 );
             }
             Some(..) if pat_src == PatternSource::FnParam => {
@@ -2617,7 +2617,7 @@ impl<'a> Resolver<'a> {
                     self,
                     ident.span,
                     ResolutionError::IdentifierBoundMoreThanOnceInParameterList(
-                        &ident.name.as_str())
+                        &ident.as_str())
                 );
             }
             Some(..) if pat_src == PatternSource::Match ||
@@ -3765,12 +3765,12 @@ impl<'a> Resolver<'a> {
                         // 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
 }

src/librustc_resolve/macros.rs

@@ -649,7 +649,7 @@ impl<'a> Resolver<'a> {
                             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();
                 },
                 _ => {},

src/librustc_resolve/resolve_imports.rs

@@ -831,7 +831,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
                     }
                 });
                 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(),
                     };

src/librustc_typeck/check/mod.rs

@@ -3076,7 +3076,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     }
                 }
                 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 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     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 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                           -> 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 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             },
             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 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
 
             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();

src/librustdoc/html/highlight.rs

@@ -324,7 +324,7 @@ impl<'a> Classifier<'a> {
 
             // 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_,

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: {}, \

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 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> {
                             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);

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;

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

src/libsyntax/parse/parser.rs

@@ -6054,7 +6054,7 @@ impl<'a> Parser<'a> {
             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 @@ impl<'a> Parser<'a> {
         // `./<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 {
             ""

src/libsyntax/parse/token.rs

@@ -341,7 +341,7 @@ impl Token {
     /// 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
         }
     }

src/libsyntax/print/pprust.rs

@@ -724,7 +724,7 @@ pub trait PrintState<'a> {
             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 @@ impl<'a> State<'a> {
         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))
     }

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("::")
         }

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

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

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

src/libsyntax_pos/symbol.rs

@@ -56,7 +56,7 @@ impl 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 @@ impl 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 @@ impl fmt::Display for Ident {
 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)
         }
     }