OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use `Ident`s in a number of structures in HIR 

Namely: labels, type parameters, bindings in patterns, parameter names in functions without body.
All of these do not need hygiene after lowering to HIR, only span locations.
This commit is contained in:
Vadim Petrochenkov 2018-06-10 19:33:30 +03:00
parent e8215a4f6f
commit c6ca1e4abd
24 changed files with 125 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/librustc/hir/intravisit.rs
View File

@ -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 &param_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 &param_name in param_names {
visitor.visit_ident(param_name);
}
}
TraitItemKind::Method(ref sig, TraitMethod::Provided(body_id)) => {

18
src/librustc/hir/lowering.rs
View File

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

4
src/librustc/hir/map/mod.rs
View File

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

14
src/librustc/hir/mod.rs
View File

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

23
src/librustc/hir/pat_util.rs
View File

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

28
src/librustc/hir/print.rs
View File

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

4
src/librustc/ich/impls_hir.rs
View File

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

4
src/librustc/infer/error_reporting/need_type_info.rs
View File

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

8
src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs
View File

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

6
src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs
View File

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

21
src/librustc/middle/liveness.rs
View File

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

45
src/librustc/middle/resolve_lifetime.rs
View File

@ -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(&param_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(&param),
);
return;

4
src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs
View File

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

8
src/librustc_borrowck/borrowck/unused.rs
View File

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

12
src/librustc_lint/bad_style.rs
View File

@ -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", &param_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));
}
}

12
src/librustc_lint/builtin.rs
View File

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

12
src/librustc_metadata/encoder.rs
View File

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

8
src/librustc_mir/build/mod.rs
View File

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

6
src/librustc_mir/hair/pattern/check_match.rs
View File

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

6
src/librustc_mir/hair/pattern/mod.rs
View File

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

6
src/librustc_typeck/check/mod.rs
View File

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

6
src/librustc_typeck/collect.rs
View File

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

6
src/librustdoc/clean/mod.rs
View File

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

2
src/libsyntax/parse/parser.rs
View File

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