diff --git a/src/doc/unstable-book/src/language-features/plugin.md b/src/doc/unstable-book/src/language-features/plugin.md index 1cece930eeaa5..2f645cf0470c0 100644 --- 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 bcab61680965a..0229bad697326 100644 --- a/src/libproc_macro/lib.rs +++ b/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) }), diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index 2ef022cecdf49..5a49ee30d9c70 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -42,7 +42,7 @@ //! example generator inference, and possibly also HIR borrowck. use rustc_target::spec::abi::Abi; -use syntax::ast::{NodeId, CRATE_NODE_ID, Name, Attribute}; +use syntax::ast::{NodeId, CRATE_NODE_ID, Ident, Name, Attribute}; use syntax_pos::Span; use hir::*; use hir::def::Def; @@ -248,6 +248,9 @@ pub trait Visitor<'v> : Sized { fn visit_name(&mut self, _span: Span, _name: Name) { // Nothing to do. } + fn visit_ident(&mut self, ident: Ident) { + walk_ident(self, ident) + } fn visit_mod(&mut self, m: &'v Mod, _s: Span, n: NodeId) { walk_mod(self, m, n) } @@ -413,6 +416,10 @@ pub fn walk_local<'v, V: Visitor<'v>>(visitor: &mut V, local: &'v Local) { walk_list!(visitor, visit_ty, &local.ty); } +pub fn walk_ident<'v, V: Visitor<'v>>(visitor: &mut V, ident: Ident) { + visitor.visit_name(ident.span, ident.name); +} + pub fn walk_label<'v, V: Visitor<'v>>(visitor: &mut V, label: &'v Label) { visitor.visit_name(label.span, label.name); } @@ -662,7 +669,7 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) { visitor.visit_qpath(qpath, pattern.id, pattern.span); for field in fields { visitor.visit_id(field.node.id); - visitor.visit_name(field.span, field.node.name); + visitor.visit_ident(field.node.ident); visitor.visit_pat(&field.node.pat) } } @@ -915,7 +922,7 @@ pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, struct_definition: & pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V, struct_field: &'v StructField) { visitor.visit_id(struct_field.id); visitor.visit_vis(&struct_field.vis); - visitor.visit_name(struct_field.span, struct_field.name); + visitor.visit_ident(struct_field.ident); visitor.visit_ty(&struct_field.ty); walk_list!(visitor, visit_attribute, &struct_field.attrs); } @@ -970,7 +977,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) { visitor.visit_qpath(qpath, expression.id, expression.span); for field in fields { visitor.visit_id(field.id); - visitor.visit_name(field.name.span, field.name.node); + visitor.visit_ident(field.ident); visitor.visit_expr(&field.expr) } walk_list!(visitor, visit_expr, optional_base); @@ -1035,9 +1042,9 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) { visitor.visit_expr(right_expression); visitor.visit_expr(left_expression) } - ExprField(ref subexpression, ref name) => { + ExprField(ref subexpression, ident) => { visitor.visit_expr(subexpression); - visitor.visit_name(name.span, name.node); + visitor.visit_ident(ident); } ExprIndex(ref main_expression, ref index_expression) => { visitor.visit_expr(main_expression); diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index d20cea8331fdd..e9563a8a9e2d6 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -2093,11 +2093,11 @@ impl<'a> LoweringContext<'a> { hir::StructField { span: f.span, id: self.lower_node_id(f.id).node_id, - name: self.lower_ident(match f.ident { + ident: match f.ident { Some(ident) => ident, // FIXME(jseyfried) positional field hygiene None => Ident::new(Symbol::intern(&index.to_string()), f.span), - }), + }, vis: self.lower_visibility(&f.vis, None), ty: self.lower_ty(&f.ty, ImplTraitContext::Disallowed), attrs: self.lower_attrs(&f.attrs), @@ -2107,7 +2107,7 @@ impl<'a> LoweringContext<'a> { fn lower_field(&mut self, f: &Field) -> hir::Field { hir::Field { id: self.next_id().node_id, - name: respan(f.ident.span, self.lower_ident(f.ident)), + ident: f.ident, expr: P(self.lower_expr(&f.expr)), span: f.span, is_shorthand: f.is_shorthand, @@ -2877,7 +2877,7 @@ impl<'a> LoweringContext<'a> { span: f.span, node: hir::FieldPat { id: self.next_id().node_id, - name: self.lower_ident(f.node.ident), + ident: f.node.ident, pat: self.lower_pat(&f.node.pat), is_shorthand: f.node.is_shorthand, }, @@ -3119,10 +3119,7 @@ impl<'a> LoweringContext<'a> { P(self.lower_expr(el)), P(self.lower_expr(er)), ), - ExprKind::Field(ref el, ident) => hir::ExprField( - P(self.lower_expr(el)), - respan(ident.span, self.lower_ident(ident)), - ), + ExprKind::Field(ref el, ident) => hir::ExprField(P(self.lower_expr(el)), ident), ExprKind::Index(ref el, ref er) => { hir::ExprIndex(P(self.lower_expr(el)), P(self.lower_expr(er))) } @@ -3162,7 +3159,8 @@ impl<'a> LoweringContext<'a> { let expr = P(self.lower_expr(&e)); let unstable_span = self.allow_internal_unstable(CompilerDesugaringKind::DotFill, e.span); - self.field(Symbol::intern(s), expr, unstable_span) + let ident = Ident::new(Symbol::intern(s), unstable_span); + self.field(ident, expr, unstable_span) }) .collect::>(); @@ -3777,10 +3775,10 @@ impl<'a> LoweringContext<'a> { } } - fn field(&mut self, name: Name, expr: P, span: Span) -> hir::Field { + fn field(&mut self, ident: Ident, expr: P, span: Span) -> hir::Field { hir::Field { id: self.next_id().node_id, - name: Spanned { node: name, span }, + ident, span, expr, is_shorthand: false, diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 951bb6ad1501b..d6de2f57e9295 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -909,7 +909,7 @@ impl<'hir> Map<'hir> { NodeImplItem(ii) => ii.name, NodeTraitItem(ti) => ti.name, NodeVariant(v) => v.node.name, - NodeField(f) => f.name, + NodeField(f) => f.ident.name, NodeLifetime(lt) => lt.name.name(), NodeTyParam(tp) => tp.name, NodeBinding(&Pat { node: PatKind::Binding(_,_,l,_), .. }) => l.node, @@ -1105,7 +1105,7 @@ impl Named for Spanned { fn name(&self) -> Name { self.node.name() } impl Named for Item { fn name(&self) -> Name { self.name } } impl Named for ForeignItem { fn name(&self) -> Name { self.name } } impl Named for Variant_ { fn name(&self) -> Name { self.name } } -impl Named for StructField { fn name(&self) -> Name { self.name } } +impl Named for StructField { fn name(&self) -> Name { self.ident.name } } impl Named for TraitItem { fn name(&self) -> Name { self.name } } impl Named for ImplItem { fn name(&self) -> Name { self.name } } @@ -1291,7 +1291,7 @@ fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String { } Some(NodeField(ref field)) => { format!("field {} in {}{}", - field.name, + field.ident, path_str(), id_str) } Some(NodeAnonConst(_)) => { diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 7db77a3e4afa5..ebc59964172ac 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -35,7 +35,7 @@ use mir::mono::Linkage; use syntax_pos::{Span, DUMMY_SP}; use syntax::codemap::{self, Spanned}; use rustc_target::spec::abi::Abi; -use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID, AsmDialect}; +use syntax::ast::{self, Ident, Name, NodeId, DUMMY_NODE_ID, AsmDialect}; use syntax::ast::{Attribute, Lit, StrStyle, FloatTy, IntTy, UintTy, MetaItem}; use syntax::attr::InlineAttr; use syntax::ext::hygiene::SyntaxContext; @@ -866,7 +866,7 @@ impl Pat { pub struct FieldPat { pub id: NodeId, /// The identifier for the field - pub name: Name, + pub ident: Ident, /// The pattern the field is destructured to pub pat: P, pub is_shorthand: bool, @@ -1211,7 +1211,7 @@ pub struct Arm { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct Field { pub id: NodeId, - pub name: Spanned, + pub ident: Ident, pub expr: P, pub span: Span, pub is_shorthand: bool, @@ -1414,7 +1414,7 @@ pub enum Expr_ { /// For example, `a += 1`. ExprAssignOp(BinOp, P, P), /// Access of a named (`obj.foo`) or unnamed (`obj.0`) struct or tuple field - ExprField(P, Spanned), + ExprField(P, Ident), /// An indexing operation (`foo[2]`) ExprIndex(P, P), @@ -1973,7 +1973,7 @@ impl Visibility { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct StructField { pub span: Span, - pub name: Name, + pub ident: Ident, pub vis: Visibility, pub id: NodeId, pub ty: P, @@ -1983,7 +1983,7 @@ pub struct StructField { impl StructField { // Still necessary in couple of places pub fn is_positional(&self) -> bool { - let first = self.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 8173ec48045c3..4bee4f9add025 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -857,7 +857,7 @@ impl<'a> State<'a> { self.maybe_print_comment(field.span.lo())?; self.print_outer_attributes(&field.attrs)?; self.print_visibility(&field.vis)?; - self.print_name(field.name)?; + self.print_ident(field.ident)?; self.word_nbsp(":")?; self.print_type(&field.ty)?; self.s.word(",")?; @@ -1166,7 +1166,7 @@ impl<'a> State<'a> { |s, field| { s.ibox(indent_unit)?; if !field.is_shorthand { - s.print_name(field.name.node)?; + s.print_ident(field.ident)?; s.word_space(":")?; } s.print_expr(&field.expr)?; @@ -1406,10 +1406,10 @@ impl<'a> State<'a> { self.word_space("=")?; self.print_expr_maybe_paren(&rhs, prec)?; } - hir::ExprField(ref expr, name) => { + hir::ExprField(ref expr, ident) => { self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX)?; self.s.word(".")?; - self.print_name(name.node)?; + self.print_ident(ident)?; } hir::ExprIndex(ref expr, ref index) => { self.print_expr_maybe_paren(&expr, parser::PREC_POSTFIX)?; @@ -1561,13 +1561,17 @@ impl<'a> State<'a> { self.s.word(&i.to_string()) } - pub fn print_name(&mut self, name: ast::Name) -> io::Result<()> { - if name.to_ident().is_raw_guess() { - self.s.word(&format!("r#{}", name))?; + 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(&name.as_str())?; + self.s.word(&ident.as_str())?; } - self.ann.post(self, NodeName(&name)) + self.ann.post(self, NodeName(&ident.name)) + } + + pub fn print_name(&mut self, name: ast::Name) -> io::Result<()> { + self.print_ident(name.to_ident()) } pub fn print_for_decl(&mut self, loc: &hir::Local, coll: &hir::Expr) -> io::Result<()> { @@ -1773,7 +1777,7 @@ impl<'a> State<'a> { |s, f| { s.cbox(indent_unit)?; if !f.node.is_shorthand { - s.print_name(f.node.name)?; + s.print_ident(f.node.ident)?; s.word_nbsp(":")?; } s.print_pat(&f.node.pat)?; diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index 21c1af919de9a..9b202f55f3c0a 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -427,12 +427,12 @@ impl<'a> HashStable> for hir::FieldPat { hasher: &mut StableHasher) { let hir::FieldPat { id: _, - name, + ident, ref pat, is_shorthand, } = *self; - name.hash_stable(hcx, hasher); + ident.hash_stable(hcx, hasher); pat.hash_stable(hcx, hasher); is_shorthand.hash_stable(hcx, hasher); } @@ -525,13 +525,13 @@ impl<'a> HashStable> for hir::Field { hasher: &mut StableHasher) { let hir::Field { id: _, - name, + ident, ref expr, span, is_shorthand, } = *self; - name.hash_stable(hcx, hasher); + ident.hash_stable(hcx, hasher); expr.hash_stable(hcx, hasher); span.hash_stable(hcx, hasher); is_shorthand.hash_stable(hcx, hasher); @@ -598,7 +598,7 @@ impl_stable_hash_for!(enum hir::Expr_ { ExprBlock(blk, label), ExprAssign(lhs, rhs), ExprAssignOp(op, lhs, rhs), - ExprField(owner, field_name), + ExprField(owner, ident), ExprIndex(lhs, rhs), ExprPath(path), ExprAddrOf(mutability, sub), @@ -835,7 +835,7 @@ impl_stable_hash_for!(enum hir::UseKind { impl_stable_hash_for!(struct hir::StructField { span, - name, + ident, vis, id, ty, diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index 43c9fc0b8fd36..0f8926c6f4401 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -357,11 +357,17 @@ impl_stable_hash_for!(enum ty::VariantDiscr { Relative(distance) }); -impl_stable_hash_for!(struct ty::FieldDef { - did, - name, - vis -}); +impl<'a, 'gcx> HashStable> for ty::FieldDef { + fn hash_stable(&self, + hcx: &mut StableHashingContext<'a>, + hasher: &mut StableHasher) { + let ty::FieldDef { did, ident, vis } = *self; + + did.hash_stable(hcx, hasher); + ident.name.hash_stable(hcx, hasher); + vis.hash_stable(hcx, hasher); + } +} impl<'a, 'gcx> HashStable> for ::middle::const_val::ConstVal<'gcx> { diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 9ec3d2e2460e9..e3b2078971439 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -588,7 +588,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DeadVisitor<'a, 'tcx> { fn visit_struct_field(&mut self, field: &'tcx hir::StructField) { if self.should_warn_about_field(&field) { - self.warn_dead_code(field.id, field.span, field.name, "field", "used"); + self.warn_dead_code(field.id, field.span, field.ident.name, "field", "used"); } intravisit::walk_struct_field(self, field); } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 3ba230fe55a51..fd6c2f652f04b 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -669,7 +669,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> { &*with_expr, with_cmt.clone(), f_index, - with_field.name, + with_field.ident, with_field.ty(self.tcx(), substs) ); self.delegate_consume(with_expr.id, with_expr.span, &cmt_field); diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index e9d27c182a2c9..39c4da08b03a3 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -647,14 +647,14 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> { } } - hir::ExprField(ref base, f_name) => { + hir::ExprField(ref base, f_ident) => { let base_cmt = Rc::new(self.cat_expr(&base)?); debug!("cat_expr(cat_field): id={} expr={:?} base={:?}", expr.id, expr, base_cmt); let f_index = self.tcx.field_index(expr.id, self.tables); - Ok(self.cat_field(expr, base_cmt, f_index, f_name.node, expr_ty)) + Ok(self.cat_field(expr, base_cmt, f_index, f_ident, expr_ty)) } hir::ExprIndex(ref base, _) => { @@ -983,14 +983,15 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> { node: &N, base_cmt: cmt<'tcx>, f_index: usize, - f_name: Name, + f_ident: ast::Ident, f_ty: Ty<'tcx>) -> cmt_<'tcx> { let ret = cmt_ { id: node.id(), span: node.span(), mutbl: base_cmt.mutbl.inherit(), - cat: Categorization::Interior(base_cmt, InteriorField(FieldIndex(f_index, f_name))), + cat: Categorization::Interior(base_cmt, + InteriorField(FieldIndex(f_index, f_ident.name))), ty: f_ty, note: NoteNone }; @@ -1301,8 +1302,8 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> { for fp in field_pats { let field_ty = self.pat_ty(&fp.node.pat)?; // see (*2) let f_index = self.tcx.field_index(fp.node.id, self.tables); - let cmt_field = - Rc::new(self.cat_field(pat, cmt.clone(), f_index, fp.node.name, field_ty)); + let cmt_field = Rc::new(self.cat_field(pat, cmt.clone(), f_index, + fp.node.ident, field_ty)); self.cat_pattern_(cmt_field, &fp.node.pat, op)?; } } diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs index e44b1dc886b5b..d35884ec78a82 100644 --- a/src/librustc/mir/mod.rs +++ b/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.name.as_str(), place); + struct_fmt.field(&field.ident.as_str(), place); } struct_fmt.finish() } diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index 49aee8bcd01fe..aacfbd065558f 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -976,7 +976,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { }) => { (self.tcx.sess.codemap().def_span(span), fields.iter().map(|field| { - ArgKind::Arg(format!("{}", field.name), "_".to_string()) + ArgKind::Arg(format!("{}", field.ident), "_".to_string()) }).collect::>()) } hir::map::NodeStructCtor(ref variant_data) => { diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs index 6169b3bc33fcd..499398abcf996 100644 --- a/src/librustc/ty/layout.rs +++ b/src/librustc/ty/layout.rs @@ -1227,7 +1227,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> { if !adt_def.variants.is_empty() { let variant_def = &adt_def.variants[index]; let fields: Vec<_> = - variant_def.fields.iter().map(|f| f.name).collect(); + variant_def.fields.iter().map(|f| f.ident.name).collect(); record(adt_kind.into(), adt_packed, None, @@ -1248,7 +1248,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> { let variant_infos: Vec<_> = adt_def.variants.iter().enumerate().map(|(i, variant_def)| { let fields: Vec<_> = - variant_def.fields.iter().map(|f| f.name).collect(); + variant_def.fields.iter().map(|f| f.ident.name).collect(); build_variant_info(Some(variant_def.name), &fields, layout.for_variant(self, i)) diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 5ee6329e860e5..115c6442db57d 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -1619,7 +1619,7 @@ pub enum VariantDiscr { #[derive(Debug)] pub struct FieldDef { pub did: DefId, - pub name: Name, + pub ident: Ident, pub vis: Visibility, } @@ -2454,7 +2454,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { pub fn find_field_index(self, ident: Ident, variant: &VariantDef) -> Option { variant.fields.iter().position(|field| { - self.adjust_ident(ident.modern(), variant.did, DUMMY_NODE_ID).0 == field.name.to_ident() + self.adjust_ident(ident, variant.did, DUMMY_NODE_ID).0 == field.ident.modern() }) } @@ -2635,11 +2635,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { // supposed definition name (`def_name`). The method also needs `DefId` of the supposed // definition's parent/scope to perform comparison. pub fn hygienic_eq(self, use_name: Name, def_name: Name, def_parent_def_id: DefId) -> bool { - self.adjust(use_name, def_parent_def_id, DUMMY_NODE_ID).0 == def_name.to_ident() - } - - pub fn adjust(self, name: Name, scope: DefId, block: NodeId) -> (Ident, DefId) { - self.adjust_ident(name.to_ident(), scope, block) + let (use_ident, def_ident) = (use_name.to_ident(), def_name.to_ident()); + self.adjust_ident(use_ident, def_parent_def_id, DUMMY_NODE_ID).0 == def_ident } pub fn adjust_ident(self, mut ident: Ident, scope: DefId, block: NodeId) -> (Ident, DefId) { @@ -2647,6 +2644,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { LOCAL_CRATE => self.hir.definitions().expansion(scope.index), _ => Mark::root(), }; + ident = ident.modern(); let scope = match ident.span.adjust(expansion) { Some(macro_def) => self.hir.definitions().macro_def_scope(macro_def), None if block == DUMMY_NODE_ID => DefId::local(CRATE_DEF_INDEX), // Dummy DefId diff --git a/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs b/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs index 0b90127cc7e1e..408ab44cde62b 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs @@ -108,8 +108,9 @@ impl<'a, 'tcx> RestrictionsContext<'a, 'tcx> { RestrictionResult::Safe => RestrictionResult::Safe, RestrictionResult::SafeIf(base_lp, mut base_vec) => { for (i, field) in adt_def.non_enum_variant().fields.iter().enumerate() { - let field = - InteriorKind::InteriorField(mc::FieldIndex(i, field.name)); + let field = InteriorKind::InteriorField( + mc::FieldIndex(i, field.ident.name) + ); let field_ty = if field == interior { cmt.ty } else { diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs index 1f4050a5b3624..4091ca046f44d 100644 --- a/src/librustc_borrowck/borrowck/move_data.rs +++ b/src/librustc_borrowck/borrowck/move_data.rs @@ -343,7 +343,8 @@ impl<'a, 'tcx> MoveData<'tcx> { = (&base_lp.ty.sty, lp_elem) { if adt_def.is_union() { for (i, field) in adt_def.non_enum_variant().fields.iter().enumerate() { - let field = InteriorKind::InteriorField(mc::FieldIndex(i, field.name)); + let field = + InteriorKind::InteriorField(mc::FieldIndex(i, field.ident.name)); if field != interior { let sibling_lp_kind = LpExtend(base_lp.clone(), mutbl, LpInterior(opt_variant_id, field)); @@ -395,7 +396,8 @@ impl<'a, 'tcx> MoveData<'tcx> { if let ty::TyAdt(adt_def, _) = base_lp.ty.sty { if adt_def.is_union() { for (i, field) in adt_def.non_enum_variant().fields.iter().enumerate() { - let field = InteriorKind::InteriorField(mc::FieldIndex(i, field.name)); + let field = + InteriorKind::InteriorField(mc::FieldIndex(i, field.ident.name)); let field_ty = if field == interior { lp.ty } else { diff --git a/src/librustc_codegen_llvm/debuginfo/metadata.rs b/src/librustc_codegen_llvm/debuginfo/metadata.rs index 99f08540c716c..1eec57c9c877c 100644 --- a/src/librustc_codegen_llvm/debuginfo/metadata.rs +++ b/src/librustc_codegen_llvm/debuginfo/metadata.rs @@ -951,7 +951,7 @@ impl<'tcx> StructMemberDescriptionFactory<'tcx> { let name = if self.variant.ctor_kind == CtorKind::Fn { format!("__{}", i) } else { - f.name.to_string() + f.ident.to_string() }; let field = layout.field(cx, i); let (size, align) = field.size_and_align(); @@ -1072,7 +1072,7 @@ impl<'tcx> UnionMemberDescriptionFactory<'tcx> { let field = self.layout.field(cx, i); let (size, align) = field.size_and_align(); MemberDescription { - name: f.name.to_string(), + name: f.ident.to_string(), type_metadata: type_metadata(cx, field.ty, self.span), offset: Size::ZERO, size, @@ -1338,7 +1338,7 @@ fn describe_enum_variant<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx>, let name = if variant.ctor_kind == CtorKind::Fn { format!("__{}", i) } else { - variant.fields[i].name.to_string() + variant.fields[i].ident.to_string() }; (name, layout.field(cx, i).ty) })).collect(); diff --git a/src/librustc_codegen_utils/symbol_names.rs b/src/librustc_codegen_utils/symbol_names.rs index 2063db6dc5331..123816c1f97df 100644 --- a/src/librustc_codegen_utils/symbol_names.rs +++ b/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 } diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index 651a2e187f6b4..dbf756f80ca38 100644 --- a/src/librustc_lint/bad_style.rs +++ b/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.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_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index 8af4649ed5f40..11c653895fce0 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -542,7 +542,7 @@ impl<'a, 'tcx> CrateMetadata { let f = self.entry(index); ty::FieldDef { did: self.local_def_id(index), - name: self.item_name(index).as_symbol(), + ident: Ident::from_interned_str(self.item_name(index)), vis: f.visibility.decode(self) } }).collect(), diff --git a/src/librustc_mir/borrow_check/error_reporting.rs b/src/librustc_mir/borrow_check/error_reporting.rs index fde740bce3f35..9061af1b68ca4 100644 --- a/src/librustc_mir/borrow_check/error_reporting.rs +++ b/src/librustc_mir/borrow_check/error_reporting.rs @@ -746,7 +746,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { Place::Projection(ref proj) => match proj.elem { ProjectionElem::Deref => self.describe_field(&proj.base, field), ProjectionElem::Downcast(def, variant_index) => { - format!("{}", def.variants[variant_index].fields[field.index()].name) + format!("{}", def.variants[variant_index].fields[field.index()].ident) } ProjectionElem::Field(_, field_type) => { self.describe_field_from_ty(&field_type, field) @@ -770,7 +770,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { ty::TyAdt(def, _) => if def.is_enum() { format!("{}", field.index()) } else { - format!("{}", def.non_enum_variant().fields[field.index()].name) + format!("{}", def.non_enum_variant().fields[field.index()].ident) }, ty::TyTuple(_) => format!("{}", field.index()), ty::TyRef(_, ty, _) | ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => { diff --git a/src/librustc_mir/hair/pattern/mod.rs b/src/librustc_mir/hair/pattern/mod.rs index 32cad88edb037..4cfe74413dfa5 100644 --- a/src/librustc_mir/hair/pattern/mod.rs +++ b/src/librustc_mir/hair/pattern/mod.rs @@ -183,7 +183,7 @@ impl<'tcx> fmt::Display for Pattern<'tcx> { if let PatternKind::Wild = *p.pattern.kind { continue; } - let name = variant.fields[p.field.index()].name; + let name = variant.fields[p.field.index()].ident; write!(f, "{}{}: {}", start_or_continue(), name, p.pattern)?; printed += 1; } diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs index 9607a84124af5..f83ea6fa13b52 100644 --- 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(""); diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 2e887e3d8f097..bfb8c282d377b 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -504,12 +504,12 @@ impl<'a, 'tcx> NamePrivacyVisitor<'a, 'tcx> { span: Span, // Span of the field pattern, e.g. `x: 0` def: &'tcx ty::AdtDef, // Definition of the struct or enum field: &'tcx ty::FieldDef) { // Definition of the field - let ident = Ident::new(keywords::Invalid.name(), use_ctxt.modern()); + let ident = Ident::new(keywords::Invalid.name(), use_ctxt); let def_id = self.tcx.adjust_ident(ident, def.did, self.current_item).1; if !def.is_enum() && !field.vis.is_accessible_from(def_id, self.tcx) { struct_span_err!(self.tcx.sess, span, E0451, "field `{}` of {} `{}` is private", - field.name, def.variant_descr(), self.tcx.item_path_str(def.did)) - .span_label(span, format!("field `{}` is private", field.name)) + field.ident, def.variant_descr(), self.tcx.item_path_str(def.did)) + .span_label(span, format!("field `{}` is private", field.ident)) .emit(); } } @@ -580,14 +580,14 @@ impl<'a, 'tcx> Visitor<'tcx> for NamePrivacyVisitor<'a, 'tcx> { self.tcx.field_index(f.id, self.tables) == vf_index }); let (use_ctxt, span) = match field { - Some(field) => (field.name.node.to_ident().span, field.span), + Some(field) => (field.ident.span, field.span), None => (base.span, base.span), }; self.check_field(use_ctxt, span, adt, variant_field); } } else { for field in fields { - let use_ctxt = field.name.node.to_ident().span; + let use_ctxt = field.ident.span; let index = self.tcx.field_index(field.id, self.tables); self.check_field(use_ctxt, field.span, adt, &variant.fields[index]); } @@ -606,7 +606,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NamePrivacyVisitor<'a, 'tcx> { let adt = self.tables.pat_ty(pat).ty_adt_def().unwrap(); let variant = adt.variant_of_def(def); for field in fields { - let use_ctxt = field.node.name.to_ident().span; + let use_ctxt = field.node.ident.span; let index = self.tcx.field_index(field.node.id, self.tables); self.check_field(use_ctxt, field.span, adt, &variant.fields[index]); } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 84b17f155a0e9..41b44f717c944 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1060,7 +1060,7 @@ impl<'a> ModuleData<'a> { fn for_each_child_stable)>(&self, mut f: F) { let resolutions = self.resolutions.borrow(); let mut resolutions = resolutions.iter().collect::>(); - 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 } diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs index d6d00b3183e1a..297c42f961599 100644 --- a/src/librustc_resolve/macros.rs +++ b/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(); }, _ => {}, diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 91de3a34cc84a..34f84597adfc5 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/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(), }; diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 68587fb8b3c1e..7ef510f41254f 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -557,7 +557,8 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { binding.item_name, binding.span) }?; - let (assoc_ident, def_scope) = tcx.adjust(binding.item_name, candidate.def_id(), ref_id); + let (assoc_ident, def_scope) = + tcx.adjust_ident(binding.item_name.to_ident(), candidate.def_id(), ref_id); let assoc_ty = tcx.associated_items(candidate.def_id()).find(|i| { i.kind == ty::AssociatedKind::Type && i.name.to_ident() == assoc_ident }).expect("missing associated type"); @@ -907,7 +908,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { }; let trait_did = bound.def_id(); - let (assoc_ident, def_scope) = tcx.adjust(assoc_name, trait_did, ref_id); + let (assoc_ident, def_scope) = tcx.adjust_ident(assoc_name.to_ident(), trait_did, ref_id); let item = tcx.associated_items(trait_did).find(|i| { Namespace::from(i.kind) == Namespace::Type && i.name.to_ident() == assoc_ident diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 35cc70b08384c..439c0e2d610fa 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -859,7 +859,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects"); let field_map = variant.fields .iter() .enumerate() - .map(|(i, field)| (field.name.to_ident(), (i, field))) + .map(|(i, field)| (field.ident.modern(), (i, field))) .collect::>(); // Keep track of which fields have already appeared in the pattern. @@ -868,16 +868,16 @@ https://doc.rust-lang.org/reference/types.html#trait-objects"); let mut inexistent_fields = vec![]; // Typecheck each field. for &Spanned { node: ref field, span } in fields { - let ident = tcx.adjust(field.name, variant.did, self.body_id).0; + let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0; let field_ty = match used_fields.entry(ident) { Occupied(occupied) => { struct_span_err!(tcx.sess, span, E0025, "field `{}` bound multiple times \ in the pattern", - field.name) + field.ident) .span_label(span, - format!("multiple uses of `{}` in pattern", field.name)) - .span_label(*occupied.get(), format!("first use of `{}`", field.name)) + format!("multiple uses of `{}` in pattern", field.ident)) + .span_label(*occupied.get(), format!("first use of `{}`", field.ident)) .emit(); tcx.types.err } @@ -890,7 +890,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects"); self.field_ty(span, f, substs) }) .unwrap_or_else(|| { - inexistent_fields.push((span, field.name)); + inexistent_fields.push((span, field.ident)); tcx.types.err }) } @@ -958,7 +958,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects"); } else if !etc { let unmentioned_fields = variant.fields .iter() - .map(|field| field.name.to_ident()) + .map(|field| field.ident.modern()) .filter(|ident| !used_fields.contains_key(&ident)) .collect::>(); if unmentioned_fields.len() > 0 { diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index 49f9ae0e971a9..169caf1f67266 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -114,15 +114,15 @@ pub enum CandidateSource { impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { /// Determines whether the type `self_ty` supports a method name `method_name` or not. pub fn method_exists(&self, - span: Span, - method_name: ast::Name, + method_name: ast::Ident, self_ty: Ty<'tcx>, call_expr_id: ast::NodeId, allow_private: bool) -> bool { let mode = probe::Mode::MethodCall; - match self.probe_for_name(span, mode, method_name, IsSuggestion(false), - self_ty, call_expr_id, ProbeScope::TraitsInScope) { + match self.probe_for_name(method_name.span, mode, method_name.name, + IsSuggestion(false), self_ty, call_expr_id, + ProbeScope::TraitsInScope) { Ok(..) => true, Err(NoMatch(..)) => false, Err(Ambiguity(..)) => true, diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index d129298b35b03..7c51765f0608e 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -422,7 +422,8 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> { { let is_accessible = if let Some(name) = self.method_name { let item = candidate.item; - let def_scope = self.tcx.adjust(name, item.container.id(), self.body_id).1; + let def_scope = + self.tcx.adjust_ident(name.to_ident(), item.container.id(), self.body_id).1; item.vis.is_accessible_from(def_scope, self.tcx) } else { true diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 70d299437a6e9..9a994e0e1de8b 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -120,7 +120,7 @@ use std::ops::{self, Deref}; use rustc_target::spec::abi::Abi; use syntax::ast; use syntax::attr; -use syntax::codemap::{original_sp, Spanned}; +use syntax::codemap::original_sp; use syntax::feature_gate::{GateIssue, emit_feature_err}; use syntax::ptr::P; use syntax::symbol::{Symbol, LocalInternedString, keywords}; @@ -3045,7 +3045,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { expr: &'gcx hir::Expr, needs: Needs, base: &'gcx hir::Expr, - field: &Spanned) -> Ty<'tcx> { + field: ast::Ident) -> Ty<'tcx> { let expr_t = self.check_expr_with_needs(base, needs); let expr_t = self.structurally_resolved_type(base.span, expr_t); @@ -3056,9 +3056,9 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { ty::TyAdt(base_def, substs) if !base_def.is_enum() => { debug!("struct named {:?}", base_t); let (ident, def_scope) = - self.tcx.adjust(field.node, base_def.did, self.body_id); + self.tcx.adjust_ident(field, base_def.did, self.body_id); let fields = &base_def.non_enum_variant().fields; - if let Some(index) = fields.iter().position(|f| f.name.to_ident() == ident) { + if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) { let field = &fields[index]; let field_ty = self.field_ty(expr.span, field, substs); // Save the index of all fields regardless of their visibility in case @@ -3076,7 +3076,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { } } ty::TyTuple(ref tys) => { - let fstr = field.node.as_str(); + let fstr = field.as_str(); if let Ok(index) = fstr.parse::() { if fstr == index.to_string() { if let Some(field_ty) = tys.get(index) { @@ -3099,31 +3099,31 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { let struct_path = self.tcx().item_path_str(did); let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616, "field `{}` of struct `{}` is private", - field.node, struct_path); + field, struct_path); // Also check if an accessible method exists, which is often what is meant. - if self.method_exists(field.span, field.node, expr_t, expr.id, false) { - err.note(&format!("a method `{}` also exists, perhaps you wish to call it", - field.node)); + if self.method_exists(field, expr_t, expr.id, false) { + err.note(&format!("a method `{}` also exists, perhaps you wish to call it", field)); } err.emit(); field_ty - } else if field.node == keywords::Invalid.name() { + } else if field.name == keywords::Invalid.name() { self.tcx().types.err - } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) { + } else if self.method_exists(field, expr_t, expr.id, true) { type_error_struct!(self.tcx().sess, field.span, expr_t, E0615, "attempted to take value of method `{}` on type `{}`", - field.node, expr_t) + field, expr_t) .help("maybe a `()` to call it is missing?") .emit(); self.tcx().types.err } else { if !expr_t.is_primitive_ty() { - let mut err = self.no_such_field_err(field.span, &field.node, expr_t); + let mut err = self.no_such_field_err(field.span, field, expr_t); match expr_t.sty { ty::TyAdt(def, _) if !def.is_enum() => { if let Some(suggested_field_name) = - Self::suggest_field_name(def.non_enum_variant(), field, vec![]) { + Self::suggest_field_name(def.non_enum_variant(), + &field.as_str(), vec![]) { err.span_label(field.span, format!("did you mean `{}`?", suggested_field_name)); } else { @@ -3139,7 +3139,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { ty::TyRawPtr(..) => { let base = self.tcx.hir.node_to_pretty_string(base.id); let msg = format!("`{}` is a native pointer; try dereferencing it", base); - let suggestion = format!("(*{}).{}", base, field.node); + let suggestion = format!("(*{}).{}", base, field); err.span_suggestion(field.span, &msg, suggestion); } _ => {} @@ -3156,29 +3156,28 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // Return an hint about the closest match in field names fn suggest_field_name(variant: &'tcx ty::VariantDef, - field: &Spanned, + field: &str, skip: Vec) -> Option { - let name = field.node.as_str(); 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.name.as_str()) || + if skip.iter().any(|x| *x == field.ident.as_str()) || (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) { None } else { - Some(&field.name) + Some(&field.ident.name) } }); - find_best_match_for_name(names, &name, None) + find_best_match_for_name(names, field, None) } fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec { let mut available = Vec::new(); for field in variant.fields.iter() { - let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id); + let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1; if field.vis.is_accessible_from(def_scope, self.tcx) { - available.push(field.name); + available.push(field.ident.name); } } available @@ -3209,36 +3208,36 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { skip_fields: &[hir::Field], kind_name: &str) { let mut err = self.type_error_struct_with_diag( - field.name.span, + field.ident.span, |actual| match ty.sty { ty::TyAdt(adt, ..) if adt.is_enum() => { - struct_span_err!(self.tcx.sess, field.name.span, E0559, + struct_span_err!(self.tcx.sess, field.ident.span, E0559, "{} `{}::{}` has no field named `{}`", - kind_name, actual, variant.name, field.name.node) + kind_name, actual, variant.name, field.ident) } _ => { - struct_span_err!(self.tcx.sess, field.name.span, E0560, + struct_span_err!(self.tcx.sess, field.ident.span, E0560, "{} `{}` has no field named `{}`", - kind_name, actual, field.name.node) + kind_name, actual, field.ident) } }, ty); // prevent all specified fields from being suggested - let skip_fields = skip_fields.iter().map(|ref x| x.name.node.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.name, + &field.ident.as_str(), skip_fields.collect()) { - err.span_label(field.name.span, + err.span_label(field.ident.span, format!("field does not exist - did you mean `{}`?", field_name)); } else { match ty.sty { ty::TyAdt(adt, ..) => { if adt.is_enum() { - err.span_label(field.name.span, + err.span_label(field.ident.span, format!("`{}::{}` does not have this field", ty, variant.name)); } else { - err.span_label(field.name.span, + err.span_label(field.ident.span, format!("`{}` does not have this field", ty)); } let available_field_names = self.available_field_names(variant); @@ -3278,7 +3277,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { let mut remaining_fields = FxHashMap(); for (i, field) in variant.fields.iter().enumerate() { - remaining_fields.insert(field.name.to_ident(), (i, field)); + remaining_fields.insert(field.ident.modern(), (i, field)); } let mut seen_fields = FxHashMap(); @@ -3287,7 +3286,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // Typecheck each field. for field in ast_fields { - let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0; + let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0; let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) { seen_fields.insert(ident, field.span); self.write_field_index(field.id, i); @@ -3304,12 +3303,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { error_happened = true; if let Some(prev_span) = seen_fields.get(&ident) { let mut err = struct_span_err!(self.tcx.sess, - field.name.span, + field.ident.span, E0062, "field `{}` specified more than once", ident); - err.span_label(field.name.span, "used more than once"); + err.span_label(field.ident.span, "used more than once"); err.span_label(*prev_span, format!("first use of `{}`", ident)); err.emit(); @@ -3335,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::>(); displayable_field_names.sort(); @@ -4054,7 +4053,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { hir::ExprStruct(ref qpath, ref fields, ref base_expr) => { self.check_expr_struct(expr, expected, qpath, fields, base_expr) } - hir::ExprField(ref base, ref field) => { + hir::ExprField(ref base, field) => { self.check_field(expr, needs, &base, field) } hir::ExprIndex(ref base, ref idx) => { diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index 528f81a56126d..dde1368026068 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -354,7 +354,7 @@ pub fn coerce_unsized_info<'a, 'gcx>(gcx: TyCtxt<'a, 'gcx, 'gcx>, diff_fields.len(), diff_fields.iter() .map(|&(i, a, b)| { - format!("{} ({} to {})", fields[i].name, a, b) + format!("{} ({} to {})", fields[i].ident, a, b) }) .collect::>() .join(", "))); diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index d0d147b8e85cd..d0c67c2882cff 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -520,21 +520,21 @@ fn convert_struct_variant<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let node_id = tcx.hir.as_local_node_id(did).unwrap(); let fields = def.fields().iter().map(|f| { let fid = tcx.hir.local_def_id(f.id); - let dup_span = seen_fields.get(&f.name.to_ident()).cloned(); + let dup_span = seen_fields.get(&f.ident.modern()).cloned(); if let Some(prev_span) = dup_span { struct_span_err!(tcx.sess, f.span, E0124, "field `{}` is already declared", - f.name) + f.ident) .span_label(f.span, "field already declared") - .span_label(prev_span, format!("`{}` first declared here", f.name)) + .span_label(prev_span, format!("`{}` first declared here", f.ident)) .emit(); } else { - seen_fields.insert(f.name.to_ident(), f.span); + seen_fields.insert(f.ident.modern(), f.span); } ty::FieldDef { did: fid, - name: f.name, + ident: f.ident, vis: ty::Visibility::from_hir(&f.vis, node_id, tcx) } }).collect(); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index d4c1ba63a8c98..2e3ea3de7b0b7 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1091,19 +1091,19 @@ fn resolve(cx: &DocContext, path_str: &str, is_val: bool) -> Result<(Def, Option _ => false, }; let elem = if is_enum { - cx.tcx.adt_def(did).all_fields().find(|item| item.name == item_name) + cx.tcx.adt_def(did).all_fields().find(|item| item.ident.name == item_name) } else { cx.tcx.adt_def(did) .non_enum_variant() .fields .iter() - .find(|item| item.name == item_name) + .find(|item| item.ident.name == item_name) }; if let Some(item) = elem { Ok((ty.def, Some(format!("{}.{}", if is_enum { "variant" } else { "structfield" }, - item.name)))) + item.ident)))) } else { Err(()) } @@ -2990,7 +2990,7 @@ impl<'tcx> Clean for Ty<'tcx> { impl Clean for hir::StructField { fn clean(&self, cx: &DocContext) -> Item { Item { - name: Some(self.name).clean(cx), + name: Some(self.ident.name).clean(cx), attrs: self.attrs.clean(cx), source: self.span.clean(cx), visibility: self.vis.clean(cx), @@ -3005,7 +3005,7 @@ impl Clean for hir::StructField { impl<'tcx> Clean for ty::FieldDef { fn clean(&self, cx: &DocContext) -> Item { Item { - name: Some(self.name).clean(cx), + name: Some(self.ident.name).clean(cx), attrs: cx.tcx.get_attrs(self.did).clean(cx), source: cx.tcx.def_span(self.did).clean(cx), visibility: self.vis.clean(cx), @@ -3201,7 +3201,7 @@ impl<'tcx> Clean for ty::VariantDef { fields: self.fields.iter().map(|field| { Item { source: cx.tcx.def_span(field.did).clean(cx), - name: Some(field.name.clean(cx)), + name: Some(field.ident.name.clean(cx)), attrs: cx.tcx.get_attrs(field.did).clean(cx), visibility: field.vis.clean(cx), def_id: field.did, @@ -3850,7 +3850,7 @@ fn name_from_pat(p: &hir::Pat) -> String { PatKind::Struct(ref name, ref fields, etc) => { format!("{} {{ {}{} }}", qpath_to_string(name), fields.iter().map(|&Spanned { node: ref fp, .. }| - format!("{}: {}", fp.name, name_from_pat(&*fp.pat))) + format!("{}: {}", fp.ident, name_from_pat(&*fp.pat))) .collect::>().join(", "), if etc { ", ..." } else { "" } ) diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index 3d3d46555c37b..5939d5341e324 100644 --- a/src/librustdoc/html/highlight.rs +++ b/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_, diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index f507d0dc09dab..6086c5a47c78c 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -743,7 +743,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for HirCollector<'a, 'hir> { } fn visit_struct_field(&mut self, f: &'hir hir::StructField) { - self.visit_testable(f.name.to_string(), &f.attrs, |this| { + self.visit_testable(f.ident.to_string(), &f.attrs, |this| { intravisit::walk_struct_field(this, f); }); } diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs index 6c3117b963fed..ca0293aca6e77 100644 --- 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 146db632c07ba..667105a534aa3 100644 --- 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 @@ 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); diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index faf7e06c9f38f..058317e05c7f7 100644 --- 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 8fc1d36391410..2e6d590c333cf 100644 --- 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: "ed::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: "ed::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 5a3e5586495cf..4d38d29287662 100644 --- a/src/libsyntax/parse/parser.rs +++ b/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> { // `./.rs` and `.//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 ed28d5f33b921..9770fbca8f86c 100644 --- a/src/libsyntax/parse/token.rs +++ b/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 } } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 585d49d7076c4..d8e70a9045c9d 100644 --- a/src/libsyntax/print/pprust.rs +++ b/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)) } diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index 1dfd48a24c3bf..e63a3d47a828f 100644 --- 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 b8345e7cf40c1..828c247084167 100644 --- 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 0dd55f8d77738..a5b348a661a78 100644 --- 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 b22098408a332..4bf764b1101fa 100644 --- 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 a08f9b2e54a7c..a4b2d9de932a7 100644 --- a/src/libsyntax_pos/symbol.rs +++ b/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(&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) } }