diff options
24 files changed, 125 insertions, 156 deletions
diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index 29507474aa1..61583d99894 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -426,7 +426,7 @@ pub fn walk_ident<'v, V: Visitor<'v>>(visitor: &mut V, ident: Ident) { } pub fn walk_label<'v, V: Visitor<'v>>(visitor: &mut V, label: &'v Label) { - visitor.visit_name(label.span, label.name); + visitor.visit_ident(label.ident); } pub fn walk_lifetime<'v, V: Visitor<'v>>(visitor: &mut V, lifetime: &'v Lifetime) { @@ -689,9 +689,9 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) { PatKind::Ref(ref subpattern, _) => { visitor.visit_pat(subpattern) } - PatKind::Binding(_, canonical_id, ref pth1, ref optional_subpattern) => { + PatKind::Binding(_, canonical_id, ident, ref optional_subpattern) => { visitor.visit_def_mention(Def::Local(canonical_id)); - visitor.visit_name(pth1.span, pth1.node); + visitor.visit_ident(ident); walk_list!(visitor, visit_pat, optional_subpattern); } PatKind::Lit(ref expression) => visitor.visit_expr(expression), @@ -714,11 +714,11 @@ pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V, foreign_item: &'v visitor.visit_name(foreign_item.span, foreign_item.name); match foreign_item.node { - ForeignItemFn(ref function_declaration, ref names, ref generics) => { + ForeignItemFn(ref function_declaration, ref param_names, ref generics) => { visitor.visit_generics(generics); visitor.visit_fn_decl(function_declaration); - for name in names { - visitor.visit_name(name.span, name.node); + for ¶m_name in param_names { + visitor.visit_ident(param_name); } } ForeignItemStatic(ref typ, _) => visitor.visit_ty(typ), @@ -832,11 +832,11 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai visitor.visit_ty(ty); walk_list!(visitor, visit_nested_body, default); } - TraitItemKind::Method(ref sig, TraitMethod::Required(ref names)) => { + TraitItemKind::Method(ref sig, TraitMethod::Required(ref param_names)) => { visitor.visit_id(trait_item.id); visitor.visit_fn_decl(&sig.decl); - for name in names { - visitor.visit_name(name.span, name.node); + for ¶m_name in param_names { + visitor.visit_ident(param_name); } } TraitItemKind::Method(ref sig, TraitMethod::Provided(body_id)) => { diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 5a0e9c36b91..49675f6dc08 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -969,8 +969,7 @@ impl<'a> LoweringContext<'a> { fn lower_label(&mut self, label: Option<Label>) -> Option<hir::Label> { label.map(|label| hir::Label { - name: label.ident.name, - span: label.ident.span, + ident: label.ident, }) } @@ -1195,11 +1194,10 @@ impl<'a> LoweringContext<'a> { let hir_bounds = self.lower_param_bounds(bounds, itctx); // Set the name to `impl Bound1 + Bound2` - let ident = Ident::from_str(&pprust::ty_to_string(t)); + let ident = Ident::from_str(&pprust::ty_to_string(t)).with_span_pos(span); self.in_band_ty_params.push(hir::GenericParam { id: def_node_id, - name: ParamName::Plain(name), - span, + ident: ParamName::Plain(ident), pure_wrt_drop: false, attrs: hir_vec![], bounds: hir_bounds, @@ -1868,12 +1866,12 @@ impl<'a> LoweringContext<'a> { } } - fn lower_fn_args_to_names(&mut self, decl: &FnDecl) -> hir::HirVec<Spanned<Name>> { + fn lower_fn_args_to_names(&mut self, decl: &FnDecl) -> hir::HirVec<Ident> { decl.inputs .iter() .map(|arg| match arg.pat.node { - PatKind::Ident(_, ident, None) => respan(ident.span, ident.name), - _ => respan(arg.pat.span, keywords::Invalid.name()), + PatKind::Ident(_, ident, _) => ident, + _ => Ident::new(keywords::Invalid.name(), arg.pat.span), }) .collect() } @@ -3298,7 +3296,7 @@ impl<'a> LoweringContext<'a> { hir::PatKind::Binding( self.lower_binding_mode(binding_mode), canonical_id, - respan(ident.span, ident.name), + ident, sub.as_ref().map(|x| self.lower_pat(x)), ) } @@ -4524,7 +4522,7 @@ impl<'a> LoweringContext<'a> { P(hir::Pat { id: node_id, hir_id, - node: hir::PatKind::Binding(bm, node_id, Spanned { span, node: ident.name }, None), + node: hir::PatKind::Binding(bm, node_id, ident.with_span_pos(span), None), span, }) } diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 8c2f4e89352..2c21d15f7ec 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -616,7 +616,7 @@ impl<'hir> Map<'hir> { NodeItem(&Item { node: ItemTrait(..), .. }) => { keywords::SelfType.name() } - NodeGenericParam(param) => param.name.name(), + NodeGenericParam(param) => param.name.ident(), _ => bug!("ty_param_name: {} not a type parameter", self.node_to_string(id)), } } @@ -1021,7 +1021,7 @@ impl<'hir> Map<'hir> { Some(EntryBlock(_, _, block)) => block.span, Some(EntryStructCtor(_, _, _)) => self.expect_item(self.get_parent(id)).span, Some(EntryLifetime(_, _, lifetime)) => lifetime.span, - Some(EntryGenericParam(_, _, param)) => param.span, + Some(EntryGenericParam(_, _, param)) => param.ident.span, Some(EntryVisibility(_, _, &Visibility::Restricted { ref path, .. })) => path.span, Some(EntryVisibility(_, _, v)) => bug!("unexpected Visibility {:?}", v), Some(EntryLocal(_, _, local)) => local.span, diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 44c67b6e89a..47150d3d2c5 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -175,13 +175,12 @@ pub const DUMMY_ITEM_LOCAL_ID: ItemLocalId = ItemLocalId(!0); #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] pub struct Label { - pub name: Name, - pub span: Span, + pub ident: Ident, } impl fmt::Debug for Label { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "label({:?})", self.name) + write!(f, "label({:?})", self.ident) } } @@ -493,7 +492,6 @@ pub struct GenericParam { pub name: ParamName, pub attrs: HirVec<Attribute>, pub bounds: GenericBounds, - pub span: Span, pub pure_wrt_drop: bool, pub kind: GenericParamKind, @@ -872,7 +870,7 @@ pub enum PatKind { /// The `NodeId` is the canonical ID for the variable being bound, /// e.g. in `Ok(x) | Err(x)`, both `x` use the same canonical ID, /// which is the pattern ID of the first `x`. - Binding(BindingAnnotation, NodeId, Spanned<Name>, Option<P<Pat>>), + Binding(BindingAnnotation, NodeId, Ident, Option<P<Pat>>), /// A struct or struct variant pattern, e.g. `Variant {x, y, ..}`. /// The `bool` is `true` in the presence of a `..`. @@ -1550,7 +1548,7 @@ pub struct TraitItem { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum TraitMethod { /// No default body in the trait, just a signature. - Required(HirVec<Spanned<Name>>), + Required(HirVec<Ident>), /// Both signature and body are provided in the trait. Provided(BodyId), @@ -1645,7 +1643,7 @@ pub struct BareFnTy { pub abi: Abi, pub generic_params: HirVec<GenericParam>, pub decl: P<FnDecl>, - pub arg_names: HirVec<Spanned<Name>>, + pub arg_names: HirVec<Ident>, } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] @@ -2185,7 +2183,7 @@ pub struct ForeignItem { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum ForeignItem_ { /// A foreign function - ForeignItemFn(P<FnDecl>, HirVec<Spanned<Name>>, Generics), + ForeignItemFn(P<FnDecl>, HirVec<Ident>, Generics), /// A foreign static item (`static ext: u8`), with optional mutability /// (the boolean is true when mutable) ForeignItemStatic(P<Ty>, bool), diff --git a/src/librustc/hir/pat_util.rs b/src/librustc/hir/pat_util.rs index 5a059b6a219..14989f1ff7d 100644 --- a/src/librustc/hir/pat_util.rs +++ b/src/librustc/hir/pat_util.rs @@ -12,7 +12,6 @@ use hir::def::Def; use hir::def_id::DefId; use hir::{self, HirId, PatKind}; use syntax::ast; -use syntax::codemap::Spanned; use syntax_pos::Span; use std::iter::{Enumerate, ExactSizeIterator}; @@ -91,11 +90,11 @@ impl hir::Pat { /// Call `f` on every "binding" in a pattern, e.g., on `a` in /// `match foo() { Some(a) => (), None => () }` pub fn each_binding<F>(&self, mut f: F) - where F: FnMut(hir::BindingAnnotation, HirId, Span, &Spanned<ast::Name>), + where F: FnMut(hir::BindingAnnotation, HirId, Span, ast::Ident), { self.walk(|p| { - if let PatKind::Binding(binding_mode, _, ref pth, _) = p.node { - f(binding_mode, p.hir_id, p.span, pth); + if let PatKind::Binding(binding_mode, _, ident, _) = p.node { + f(binding_mode, p.hir_id, p.span, ident); } true }); @@ -132,20 +131,10 @@ impl hir::Pat { contains_bindings } - pub fn simple_name(&self) -> Option<ast::Name> { + pub fn simple_ident(&self) -> Option<ast::Ident> { match self.node { - PatKind::Binding(hir::BindingAnnotation::Unannotated, _, ref path1, None) | - PatKind::Binding(hir::BindingAnnotation::Mutable, _, ref path1, None) => - Some(path1.node), - _ => None, - } - } - - pub fn simple_span(&self) -> Option<Span> { - match self.node { - PatKind::Binding(hir::BindingAnnotation::Unannotated, _, ref path1, None) | - PatKind::Binding(hir::BindingAnnotation::Mutable, _, ref path1, None) => - Some(path1.span), + PatKind::Binding(hir::BindingAnnotation::Unannotated, _, ident, None) | + PatKind::Binding(hir::BindingAnnotation::Mutable, _, ident, None) => Some(ident), _ => None, } } diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index dc1883aebd5..81f10b1be7f 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -12,7 +12,7 @@ pub use self::AnnNode::*; use rustc_target::spec::abi::Abi; use syntax::ast; -use syntax::codemap::{CodeMap, Spanned}; +use syntax::codemap::CodeMap; use syntax::parse::ParseSess; use syntax::parse::lexer::comments; use syntax::print::pp::{self, Breaks}; @@ -933,7 +933,7 @@ impl<'a> State<'a> { m: &hir::MethodSig, generics: &hir::Generics, vis: &hir::Visibility, - arg_names: &[Spanned<ast::Name>], + arg_names: &[ast::Ident], body_id: Option<hir::BodyId>) -> io::Result<()> { self.print_fn(&m.decl, @@ -1380,7 +1380,7 @@ impl<'a> State<'a> { } hir::ExprWhile(ref test, ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_name(label.name)?; + self.print_ident(label.ident)?; self.word_space(":")?; } self.head("while")?; @@ -1390,7 +1390,7 @@ impl<'a> State<'a> { } hir::ExprLoop(ref blk, opt_label, _) => { if let Some(label) = opt_label { - self.print_name(label.name)?; + self.print_ident(label.ident)?; self.word_space(":")?; } self.head("loop")?; @@ -1426,7 +1426,7 @@ impl<'a> State<'a> { } hir::ExprBlock(ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_name(label.name)?; + self.print_ident(label.ident)?; self.word_space(":")?; } // containing cbox, will be closed by print-block at } @@ -1468,7 +1468,7 @@ impl<'a> State<'a> { self.s.word("break")?; self.s.space()?; if let Some(label) = destination.label { - self.print_name(label.name)?; + self.print_ident(label.ident)?; self.s.space()?; } if let Some(ref expr) = *opt_expr { @@ -1480,7 +1480,7 @@ impl<'a> State<'a> { self.s.word("continue")?; self.s.space()?; if let Some(label) = destination.label { - self.print_name(label.name)?; + self.print_ident(label.ident)?; self.s.space()? } } @@ -1784,7 +1784,7 @@ impl<'a> State<'a> { // is that it doesn't matter match pat.node { PatKind::Wild => self.s.word("_")?, - PatKind::Binding(binding_mode, _, ref path1, ref sub) => { + PatKind::Binding(binding_mode, _, ident, ref sub) => { match binding_mode { hir::BindingAnnotation::Ref => { self.word_nbsp("ref")?; @@ -1799,7 +1799,7 @@ impl<'a> State<'a> { self.word_nbsp("mut")?; } } - self.print_name(path1.node)?; + self.print_ident(ident)?; if let Some(ref p) = *sub { self.s.word("@")?; self.print_pat(&p)?; @@ -1964,7 +1964,7 @@ impl<'a> State<'a> { match arm.body.node { hir::ExprBlock(ref blk, opt_label) => { if let Some(label) = opt_label { - self.print_name(label.name)?; + self.print_ident(label.ident)?; self.word_space(":")?; } // the block will close the pattern's ibox @@ -1990,7 +1990,7 @@ impl<'a> State<'a> { name: Option<ast::Name>, generics: &hir::Generics, vis: &hir::Visibility, - arg_names: &[Spanned<ast::Name>], + arg_names: &[ast::Ident], body_id: Option<hir::BodyId>) -> io::Result<()> { self.print_fn_header_info(header, vis)?; @@ -2007,8 +2007,8 @@ impl<'a> State<'a> { assert!(arg_names.is_empty() || body_id.is_none()); self.commasep(Inconsistent, &decl.inputs, |s, ty| { s.ibox(indent_unit)?; - if let Some(name) = arg_names.get(i) { - s.s.word(&name.node.as_str())?; + if let Some(arg_name) = arg_names.get(i) { + s.s.word(&arg_name.as_str())?; s.s.word(":")?; s.s.space()?; } else if let Some(body_id) = body_id { @@ -2242,7 +2242,7 @@ impl<'a> State<'a> { decl: &hir::FnDecl, name: Option<ast::Name>, generic_params: &[hir::GenericParam], - arg_names: &[Spanned<ast::Name>]) + arg_names: &[ast::Ident]) -> io::Result<()> { self.ibox(indent_unit)?; if !generic_params.is_empty() { diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index feff4a5c271..94fda3e2874 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -155,8 +155,7 @@ impl_stable_hash_for!(enum hir::LifetimeName { }); impl_stable_hash_for!(struct hir::Label { - span, - name + ident }); impl_stable_hash_for!(struct hir::Lifetime { @@ -201,7 +200,6 @@ impl_stable_hash_for!(enum hir::TraitBoundModifier { impl_stable_hash_for!(struct hir::GenericParam { id, name, - span, pure_wrt_drop, attrs, bounds, diff --git a/src/librustc/infer/error_reporting/need_type_info.rs b/src/librustc/infer/error_reporting/need_type_info.rs index 7352c14490d..773de8912ce 100644 --- a/src/librustc/infer/error_reporting/need_type_info.rs +++ b/src/librustc/infer/error_reporting/need_type_info.rs @@ -131,8 +131,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { labels.clear(); labels.push((pattern.span, format!("consider giving this closure parameter a type"))); } else if let Some(pattern) = local_visitor.found_local_pattern { - if let Some(simple_name) = pattern.simple_name() { - labels.push((pattern.span, format!("consider giving `{}` a type", simple_name))); + if let Some(simple_ident) = pattern.simple_ident() { + labels.push((pattern.span, format!("consider giving `{}` a type", simple_ident))); } else { labels.push((pattern.span, format!("consider giving the pattern a type"))); } diff --git a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs index 7b0f2933580..a2b89475210 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs @@ -96,14 +96,14 @@ impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> { let sub_is_ret_type = self.is_return_type_anon(scope_def_id_sub, bregion_sub, ty_fndecl_sub); - let span_label_var1 = if let Some(simple_name) = anon_arg_sup.pat.simple_name() { - format!(" from `{}`", simple_name) + let span_label_var1 = if let Some(simple_ident) = anon_arg_sup.pat.simple_ident() { + format!(" from `{}`", simple_ident) } else { format!("") }; - let span_label_var2 = if let Some(simple_name) = anon_arg_sub.pat.simple_name() { - format!(" into `{}`", simple_name) + let span_label_var2 = if let Some(simple_ident) = anon_arg_sub.pat.simple_ident() { + format!(" into `{}`", simple_ident) } else { format!("") }; diff --git a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs index c106fd0c3d2..51abfa2505a 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs @@ -95,10 +95,10 @@ impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> { } } - let (error_var, span_label_var) = if let Some(simple_name) = arg.pat.simple_name() { + let (error_var, span_label_var) = if let Some(simple_ident) = arg.pat.simple_ident() { ( - format!("the type of `{}`", simple_name), - format!("the type of `{}`", simple_name), + format!("the type of `{}`", simple_ident), + format!("the type of `{}`", simple_ident), ) } else { ("parameter type".to_owned(), "type".to_owned()) diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index b98a4416d21..07a9dd75d4c 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -374,10 +374,9 @@ fn visit_fn<'a, 'tcx: 'a>(ir: &mut IrMaps<'a, 'tcx>, let body = ir.tcx.hir.body(body_id); for arg in &body.arguments { - arg.pat.each_binding(|_bm, hir_id, _x, path1| { + arg.pat.each_binding(|_bm, hir_id, _x, ident| { debug!("adding argument {:?}", hir_id); - let name = path1.node; - fn_maps.add_variable(Arg(hir_id, name)); + fn_maps.add_variable(Arg(hir_id, ident.name)); }) }; @@ -430,12 +429,11 @@ fn add_from_pat<'a, 'tcx>(ir: &mut IrMaps<'a, 'tcx>, pat: &P<hir::Pat>) { } } - pat.each_binding(|_bm, hir_id, _sp, path1| { - let name = path1.node; - ir.add_live_node_for_node(hir_id, VarDefNode(path1.span)); + pat.each_binding(|_bm, hir_id, _sp, ident| { + ir.add_live_node_for_node(hir_id, VarDefNode(ident.span)); ir.add_variable(Local(LocalInfo { id: hir_id, - name, + name: ident.name, is_shorthand: shorthand_field_ids.contains(&hir_id) })); }); @@ -1374,7 +1372,7 @@ fn check_local<'a, 'tcx>(this: &mut Liveness<'a, 'tcx>, local: &'tcx hir::Local) }, None => { this.pat_bindings(&local.pat, |this, ln, var, sp, id| { - let span = local.pat.simple_span().unwrap_or(sp); + let span = local.pat.simple_ident().map_or(sp, |ident| ident.span); this.warn_about_unused(span, id, ln, var); }) } @@ -1475,12 +1473,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { fn warn_about_unused_args(&self, body: &hir::Body, entry_ln: LiveNode) { for arg in &body.arguments { - arg.pat.each_binding(|_bm, hir_id, _, path1| { - let sp = path1.span; + arg.pat.each_binding(|_bm, hir_id, _, ident| { + let sp = ident.span; let var = self.variable(hir_id, sp); // Ignore unused self. - let name = path1.node; - if name != keywords::SelfValue.name() { + if ident.name != keywords::SelfValue.name() { if !self.warn_about_unused(sp, hir_id, entry_ln, var) { if self.live_on_entry(entry_ln, var).is_none() { self.report_dead_assign(hir_id, sp, var, true); diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 1d9345dbae2..5d5ada7b91e 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -254,7 +254,7 @@ struct LifetimeContext<'a, 'tcx: 'a> { is_in_fn_syntax: bool, /// List of labels in the function/method currently under analysis. - labels_in_fn: Vec<(ast::Name, Span)>, + labels_in_fn: Vec<ast::Ident>, /// Cache for cross-crate per-definition object lifetime defaults. xcrate_object_lifetime_defaults: DefIdMap<Vec<ObjectLifetimeDefault>>, @@ -1109,7 +1109,7 @@ fn extract_labels(ctxt: &mut LifetimeContext<'_, '_>, body: &hir::Body) { struct GatherLabels<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx>, scope: ScopeRef<'a>, - labels_in_fn: &'a mut Vec<(ast::Name, Span)>, + labels_in_fn: &'a mut Vec<ast::Ident>, } let mut gather = GatherLabels { @@ -1125,32 +1125,31 @@ fn extract_labels(ctxt: &mut LifetimeContext<'_, '_>, body: &hir::Body) { } fn visit_expr(&mut self, ex: &hir::Expr) { - if let Some((label, label_span)) = expression_label(ex) { - for &(prior, prior_span) in &self.labels_in_fn[..] { + if let Some(label) = expression_label(ex) { + for prior_label in &self.labels_in_fn[..] { // FIXME (#24278): non-hygienic comparison - if label == prior { + if label.name == prior_label.name { signal_shadowing_problem( self.tcx, - label, - original_label(prior_span), - shadower_label(label_span), + label.name, + original_label(prior_label.span), + shadower_label(label.span), ); } } - check_if_label_shadows_lifetime(self.tcx, self.scope, label, label_span); + check_if_label_shadows_lifetime(self.tcx, self.scope, label); - self.labels_in_fn.push((label, label_span)); + self.labels_in_fn.push(label); } intravisit::walk_expr(self, ex) } } - fn expression_label(ex: &hir::Expr) -> Option<(ast::Name, Span)> { + fn expression_label(ex: &hir::Expr) -> Option<ast::Ident> { match ex.node { - hir::ExprWhile(.., Some(label)) | hir::ExprLoop(_, Some(label), _) => { - Some((label.name, label.span)) - } + hir::ExprWhile(.., Some(label)) | + hir::ExprLoop(_, Some(label), _) => Some(label.ident), _ => None, } } @@ -1158,8 +1157,7 @@ fn extract_labels(ctxt: &mut LifetimeContext<'_, '_>, body: &hir::Body) { fn check_if_label_shadows_lifetime( tcx: TyCtxt<'_, '_, '_>, mut scope: ScopeRef<'_>, - label: ast::Name, - label_span: Span, + label: ast::Ident, ) { loop { match *scope { @@ -1177,15 +1175,14 @@ fn extract_labels(ctxt: &mut LifetimeContext<'_, '_>, body: &hir::Body) { ref lifetimes, s, .. } => { // FIXME (#24278): non-hygienic comparison - let param_name = hir::ParamName::Plain(ast::Ident::with_empty_ctxt(label)); - if let Some(def) = lifetimes.get(¶m_name) { + if let Some(def) = lifetimes.get(&hir::LifetimeName::Ident(label.modern())) { let node_id = tcx.hir.as_local_node_id(def.id().unwrap()).unwrap(); signal_shadowing_problem( tcx, - label, + label.name, original_lifetime(tcx.hir.span(node_id)), - shadower_label(label_span), + shadower_label(label.span), ); return; } @@ -2325,13 +2322,13 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { mut old_scope: ScopeRef, param: &'tcx hir::GenericParam, ) { - for &(label, label_span) in &self.labels_in_fn { + for label in &self.labels_in_fn { // FIXME (#24278): non-hygienic comparison - if param.name.ident().name == label { + if param.name.ident().name == label.name { signal_shadowing_problem( self.tcx, - label, - original_label(label_span), + label.name, + original_label(label.span), shadower_lifetime(¶m), ); return; diff --git a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs index fa9bb57275a..241950fb6bf 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs @@ -109,10 +109,10 @@ pub fn gather_move_from_pat<'a, 'c, 'tcx: 'c>(bccx: &BorrowckCtxt<'a, 'tcx>, cmt: &'c mc::cmt_<'tcx>) { let source = get_pattern_source(bccx.tcx,move_pat); let pat_span_path_opt = match move_pat.node { - PatKind::Binding(_, _, ref path1, _) => { + PatKind::Binding(_, _, ident, _) => { Some(MovePlace { span: move_pat.span, - name: path1.node, + name: ident.name, pat_source: source, }) } diff --git a/src/librustc_borrowck/borrowck/unused.rs b/src/librustc_borrowck/borrowck/unused.rs index b2b4c7d777e..294ae1e63a9 100644 --- a/src/librustc_borrowck/borrowck/unused.rs +++ b/src/librustc_borrowck/borrowck/unused.rs @@ -46,11 +46,9 @@ impl<'a, 'tcx> UnusedMutCx<'a, 'tcx> { let tcx = self.bccx.tcx; let mut mutables = FxHashMap(); for p in pats { - p.each_binding(|_, hir_id, span, path1| { - let name = path1.node; - + p.each_binding(|_, hir_id, span, ident| { // Skip anything that looks like `_foo` - if name.as_str().starts_with("_") { + if ident.as_str().starts_with("_") { return; } @@ -65,7 +63,7 @@ impl<'a, 'tcx> UnusedMutCx<'a, 'tcx> { _ => return, } - mutables.entry(name).or_insert(Vec::new()).push((hir_id, span)); + mutables.entry(ident.name).or_insert(Vec::new()).push((hir_id, span)); }); } diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index 70defbb0215..af34530a548 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -151,7 +151,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCamelCaseTypes { GenericParamKind::Lifetime { .. } => {} GenericParamKind::Type { synthetic, .. } => { if synthetic.is_none() { - self.check_case(cx, "type parameter", param.name.name(), param.span); + self.check_case(cx, "type parameter", param.name.ident().name, param.span); } } } @@ -302,20 +302,20 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { } fn check_trait_item(&mut self, cx: &LateContext, item: &hir::TraitItem) { - if let hir::TraitItemKind::Method(_, hir::TraitMethod::Required(ref names)) = item.node { + if let hir::TraitItemKind::Method(_, hir::TraitMethod::Required(ref pnames)) = item.node { self.check_snake_case(cx, "trait method", &item.name.as_str(), Some(item.span)); - for name in names { - self.check_snake_case(cx, "variable", &name.node.as_str(), Some(name.span)); + for param_name in pnames { + self.check_snake_case(cx, "variable", ¶m_name.as_str(), Some(param_name.span)); } } } fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) { - if let &PatKind::Binding(_, _, ref path1, _) = &p.node { - self.check_snake_case(cx, "variable", &path1.node.as_str(), Some(p.span)); + if let &PatKind::Binding(_, _, ref ident, _) = &p.node { + self.check_snake_case(cx, "variable", &ident.as_str(), Some(p.span)); } } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index dfbfcfccf7c..aa952c5330e 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -182,18 +182,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonShorthandFieldPatterns { // (Issue #49588) continue; } - if let PatKind::Binding(_, _, name, None) = fieldpat.node.pat.node { - let binding_ident = ast::Ident::new(name.node, name.span); - if cx.tcx.find_field_index(binding_ident, &variant) == + if let PatKind::Binding(_, _, ident, None) = fieldpat.node.pat.node { + if cx.tcx.find_field_index(ident, &variant) == Some(cx.tcx.field_index(fieldpat.node.id, cx.tables)) { let mut err = cx.struct_span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat.span, - &format!("the `{}:` in this pattern is redundant", - name.node)); + &format!("the `{}:` in this pattern is redundant", ident)); let subspan = cx.tcx.sess.codemap().span_through_char(fieldpat.span, ':'); - err.span_suggestion_short(subspan, - "remove this", - format!("{}", name.node)); + err.span_suggestion_short(subspan, "remove this", format!("{}", ident)); err.emit(); } } diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index 46c4a3a1abe..d8a224d3bad 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -39,9 +39,8 @@ use std::path::Path; use rustc_data_structures::sync::Lrc; use std::u32; use syntax::ast::{self, CRATE_NODE_ID}; -use syntax::codemap::Spanned; use syntax::attr; -use syntax::symbol::Symbol; +use syntax::symbol::keywords; use syntax_pos::{self, hygiene, FileName, FileMap, Span, DUMMY_SP}; use rustc::hir::{self, PatKind}; @@ -975,16 +974,15 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { let body = self.tcx.hir.body(body_id); self.lazy_seq(body.arguments.iter().map(|arg| { match arg.pat.node { - PatKind::Binding(_, _, name, _) => name.node, - _ => Symbol::intern("") + PatKind::Binding(_, _, ident, _) => ident.name, + _ => keywords::Invalid.name(), } })) }) } - fn encode_fn_arg_names(&mut self, names: &[Spanned<ast::Name>]) - -> LazySeq<ast::Name> { - self.lazy_seq(names.iter().map(|name| name.node)) + fn encode_fn_arg_names(&mut self, param_names: &[ast::Ident]) -> LazySeq<ast::Name> { + self.lazy_seq(param_names.iter().map(|ident| ident.name)) } fn encode_optimized_mir(&mut self, def_id: DefId) -> Option<Lazy<mir::Mir<'tcx>>> { diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs index 85671414618..ab20b7bfea2 100644 --- a/src/librustc_mir/build/mod.rs +++ b/src/librustc_mir/build/mod.rs @@ -538,8 +538,8 @@ fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>, mutability: Mutability::Not, }; if let Some(hir::map::NodeBinding(pat)) = tcx.hir.find(var_id) { - if let hir::PatKind::Binding(_, _, ref name, _) = pat.node { - decl.debug_name = name.node; + if let hir::PatKind::Binding(_, _, ident, _) = pat.node { + decl.debug_name = ident.name; let bm = *hir.tables.pat_binding_modes() .get(pat.hir_id) @@ -675,8 +675,8 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { // If this is a simple binding pattern, give the local a nice name for debuginfo. let mut name = None; if let Some(pat) = pattern { - if let hir::PatKind::Binding(_, _, ref ident, _) = pat.node { - name = Some(ident.node); + if let hir::PatKind::Binding(_, _, ident, _) = pat.node { + name = Some(ident.name); } } diff --git a/src/librustc_mir/hair/pattern/check_match.rs b/src/librustc_mir/hair/pattern/check_match.rs index 24301e970f5..0f4052b6fc8 100644 --- a/src/librustc_mir/hair/pattern/check_match.rs +++ b/src/librustc_mir/hair/pattern/check_match.rs @@ -308,7 +308,7 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> { fn check_for_bindings_named_the_same_as_variants(cx: &MatchVisitor, pat: &Pat) { pat.walk(|p| { - if let PatKind::Binding(_, _, name, None) = p.node { + if let PatKind::Binding(_, _, ident, None) = p.node { let bm = *cx.tables .pat_binding_modes() .get(p.hir_id) @@ -321,13 +321,13 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchVisitor, pat: &Pat) { let pat_ty = cx.tables.pat_ty(p); if let ty::TyAdt(edef, _) = pat_ty.sty { if edef.is_enum() && edef.variants.iter().any(|variant| { - variant.name == name.node && variant.ctor_kind == CtorKind::Const + variant.name == ident.name && variant.ctor_kind == CtorKind::Const }) { let ty_path = cx.tcx.item_path_str(edef.did); let mut err = struct_span_warn!(cx.tcx.sess, p.span, E0170, "pattern binding `{}` is named the same as one \ of the variants of the type `{}`", - name.node, ty_path); + ident, ty_path); err.span_suggestion_with_applicability( p.span, "to match on the variant, qualify the path", diff --git a/src/librustc_mir/hair/pattern/mod.rs b/src/librustc_mir/hair/pattern/mod.rs index 9b92a8b5e78..3f3e29a808a 100644 --- a/src/librustc_mir/hair/pattern/mod.rs +++ b/src/librustc_mir/hair/pattern/mod.rs @@ -461,7 +461,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> { } } - PatKind::Binding(_, id, ref name, ref sub) => { + PatKind::Binding(_, id, ident, ref sub) => { let var_ty = self.tables.node_id_to_type(pat.hir_id); let region = match var_ty.sty { ty::TyRef(r, _, _) => Some(r), @@ -491,14 +491,14 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> { if let ty::TyRef(_, rty, _) = ty.sty { ty = rty; } else { - bug!("`ref {}` has wrong type {}", name.node, ty); + bug!("`ref {}` has wrong type {}", ident, ty); } } PatternKind::Binding { mutability, mode, - name: name.node, + name: ident.name, var: id, ty: var_ty, subpattern: self.lower_opt_pattern(sub), diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 0b590e1110f..1c107e1cdca 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -960,14 +960,14 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> { // Add pattern bindings. fn visit_pat(&mut self, p: &'gcx hir::Pat) { - if let PatKind::Binding(_, _, ref path1, _) = p.node { + if let PatKind::Binding(_, _, ident, _) = p.node { let var_ty = self.assign(p.span, p.id, None); self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.id)); debug!("Pattern binding {} is assigned to {} with type {:?}", - path1.node, + ident, self.fcx.ty_to_string( self.fcx.locals.borrow().get(&p.id).unwrap().clone()), var_ty); @@ -1050,7 +1050,7 @@ fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>, // The check for a non-trivial pattern is a hack to avoid duplicate warnings // for simple cases like `fn foo(x: Trait)`, // where we would error once on the parameter as a whole, and once on the binding `x`. - if arg.pat.simple_name().is_none() { + if arg.pat.simple_ident().is_none() { fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation); } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 28dba08f16a..852603ac51c 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -914,7 +914,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let mut i = 0; params.extend(ast_generics.params.iter().filter_map(|param| match param.kind { GenericParamKind::Type { ref default, synthetic, .. } => { - if param.name.name() == keywords::SelfType.name() { + if param.name.ident().name == keywords::SelfType.name() { span_bug!(param.span, "`Self` should not be the name of a regular parameter"); } @@ -931,7 +931,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let ty_param = ty::GenericParamDef { index: type_start + i as u32, - name: param.name.name().as_interned_str(), + name: param.name.ident().as_interned_str(), def_id: tcx.hir.local_def_id(param.id), pure_wrt_drop: param.pure_wrt_drop, kind: ty::GenericParamDefKind::Type { @@ -1461,7 +1461,7 @@ pub fn explicit_predicates_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, for param in &ast_generics.params { match param.kind { GenericParamKind::Type { .. } => { - let name = param.name.name().as_interned_str(); + let name = param.name.ident().as_interned_str(); let param_ty = ty::ParamTy::new(index, name).to_ty(tcx); index += 1; diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 664a603920c..f63084b3f19 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2150,11 +2150,11 @@ pub struct Arguments { pub values: Vec<Argument>, } -impl<'a> Clean<Arguments> for (&'a [hir::Ty], &'a [Spanned<ast::Name>]) { +impl<'a> Clean<Arguments> for (&'a [hir::Ty], &'a [ast::Ident]) { fn clean(&self, cx: &DocContext) -> Arguments { Arguments { values: self.0.iter().enumerate().map(|(i, ty)| { - let mut name = self.1.get(i).map(|n| n.node.to_string()) + let mut name = self.1.get(i).map(|ident| ident.to_string()) .unwrap_or(String::new()); if name.is_empty() { name = "_".to_string(); @@ -4064,7 +4064,7 @@ fn name_from_pat(p: &hir::Pat) -> String { match p.node { PatKind::Wild => "_".to_string(), - PatKind::Binding(_, _, ref p, _) => p.node.to_string(), + PatKind::Binding(_, _, ident, _) => ident.to_string(), PatKind::TupleStruct(ref p, ..) | PatKind::Path(ref p) => qpath_to_string(p), PatKind::Struct(ref name, ref fields, etc) => { format!("{} {{ {}{} }}", qpath_to_string(name), diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 21bd6c08324..faf2cf64e1d 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -7325,7 +7325,7 @@ impl<'a> Parser<'a> { match self.token { token::Ident(ident, false) if ident.name == keywords::Underscore.name() => { self.bump(); // `_` - Ok(Some(Ident::new(ident.name.gensymed(), ident.span))) + Ok(Some(ident.gensym())) } _ => self.parse_ident().map(Some), } |