bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add Ident::as_str helper

Browse source
This commit is contained in:
Vadim Petrochenkov 2018-05-26 15:12:38 +03:00
parent 189c0a1297
commit 1e4269cb83
25 changed files with 50 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/doc/unstable-book/src/language-features/plugin.md
View file

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

6
src/libproc_macro/lib.rs
View file

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

2
src/librustc/hir/mod.rs
View file

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

2
src/librustc/hir/print.rs
View file

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

2
src/librustc/mir/mod.rs
View file

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

2
src/librustc_codegen_utils/symbol_names.rs
View file

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

2
src/librustc_lint/bad_style.rs
View file

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

2
src/librustc_mir/monomorphize/partitioning.rs
View file

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

12
src/librustc_resolve/lib.rs
View file

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

2
src/librustc_resolve/macros.rs
View file

@ -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();
},
_ => {},

2
src/librustc_resolve/resolve_imports.rs
View file

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

12
src/librustc_typeck/check/mod.rs
View file

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

2
src/librustdoc/html/highlight.rs
View file

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

2
src/libsyntax/diagnostics/plugin.rs
View file

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

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

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

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

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

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

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

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

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

2
src/libsyntax/parse/token.rs
View file

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

4
src/libsyntax/print/pprust.rs
View file

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

2
src/libsyntax/test.rs
View file

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

2
src/libsyntax_ext/concat_idents.rs
View file

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

2
src/libsyntax_ext/deriving/mod.rs
View file

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

2
src/libsyntax_ext/format.rs
View file

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

10
src/libsyntax_pos/symbol.rs
View file

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