From aad347c4f781bda18efb3f3cdbaa736e7e458e24 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 6 Mar 2016 15:54:44 +0300 Subject: [PATCH 1/3] Remove hir::Ident --- src/librustc/cfg/construct.rs | 4 +- src/librustc/hir/fold.rs | 30 +++---- src/librustc/hir/intravisit.rs | 31 ++----- src/librustc/hir/lowering.rs | 51 ++++++------ src/librustc/hir/map/def_collector.rs | 4 +- src/librustc/hir/map/mod.rs | 4 +- src/librustc/hir/mod.rs | 83 ++----------------- src/librustc/hir/pat_util.rs | 18 +--- src/librustc/hir/print.rs | 36 ++++---- src/librustc/infer/error_reporting.rs | 2 +- src/librustc/middle/liveness.rs | 4 +- src/librustc/middle/resolve_lifetime.rs | 2 +- src/librustc/ty/mod.rs | 2 +- .../borrowck/gather_loans/gather_moves.rs | 2 +- src/librustc_const_eval/check_match.rs | 8 +- src/librustc_incremental/calculate_svh.rs | 6 +- src/librustc_lint/bad_style.rs | 4 +- src/librustc_lint/builtin.rs | 2 +- src/librustc_metadata/encoder.rs | 2 +- src/librustc_mir/build/mod.rs | 4 +- src/librustc_mir/hair/cx/pattern.rs | 4 +- src/librustc_resolve/lib.rs | 2 +- src/librustc_trans/_match.rs | 8 +- .../debuginfo/create_scope_map.rs | 6 +- src/librustc_trans/debuginfo/metadata.rs | 2 +- src/librustc_trans/expr.rs | 4 +- src/librustc_typeck/astconv.rs | 6 +- src/librustc_typeck/check/_match.rs | 4 +- src/librustc_typeck/check/method/suggest.rs | 2 +- src/librustc_typeck/check/mod.rs | 2 +- src/librustdoc/clean/mod.rs | 6 +- src/libsyntax/ast.rs | 4 + 32 files changed, 123 insertions(+), 226 deletions(-) diff --git a/src/librustc/cfg/construct.rs b/src/librustc/cfg/construct.rs index 64c51c9432853..76699f13959ea 100644 --- a/src/librustc/cfg/construct.rs +++ b/src/librustc/cfg/construct.rs @@ -285,7 +285,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } hir::ExprBreak(label) => { - let loop_scope = self.find_scope(expr, label.map(|l| l.node.name)); + let loop_scope = self.find_scope(expr, label.map(|l| l.node)); let b = self.add_ast_node(expr.id, &[pred]); self.add_exiting_edge(expr, b, loop_scope, loop_scope.break_index); @@ -293,7 +293,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } hir::ExprAgain(label) => { - let loop_scope = self.find_scope(expr, label.map(|l| l.node.name)); + let loop_scope = self.find_scope(expr, label.map(|l| l.node)); let a = self.add_ast_node(expr.id, &[pred]); self.add_exiting_edge(expr, a, loop_scope, loop_scope.continue_index); diff --git a/src/librustc/hir/fold.rs b/src/librustc/hir/fold.rs index 740d72f4c3e3c..a91d16f25a2b8 100644 --- a/src/librustc/hir/fold.rs +++ b/src/librustc/hir/fold.rs @@ -126,10 +126,6 @@ pub trait Folder : Sized { noop_fold_name(n, self) } - fn fold_ident(&mut self, i: Ident) -> Ident { - noop_fold_ident(i, self) - } - fn fold_usize(&mut self, i: usize) -> usize { noop_fold_usize(i, self) } @@ -407,10 +403,6 @@ pub fn noop_fold_name(n: Name, _: &mut T) -> Name { n } -pub fn noop_fold_ident(i: Ident, _: &mut T) -> Ident { - i -} - pub fn noop_fold_usize(i: usize, _: &mut T) -> usize { i } @@ -418,9 +410,9 @@ pub fn noop_fold_usize(i: usize, _: &mut T) -> usize { pub fn noop_fold_path(Path { global, segments, span }: Path, fld: &mut T) -> Path { Path { global: global, - segments: segments.move_map(|PathSegment { identifier, parameters }| { + segments: segments.move_map(|PathSegment { name, parameters }| { PathSegment { - identifier: fld.fold_ident(identifier), + name: fld.fold_name(name), parameters: fld.fold_path_parameters(parameters), } }), @@ -926,7 +918,7 @@ pub fn noop_fold_pat(p: P, folder: &mut T) -> P { PatKind::Ident(binding_mode, Spanned { span: folder.new_span(pth1.span), - node: folder.fold_ident(pth1.node), + node: folder.fold_name(pth1.node), }, sub.map(|x| folder.fold_pat(x))) } @@ -1014,14 +1006,14 @@ pub fn noop_fold_expr(Expr { id, node, span, attrs }: Expr, folder: & folder.fold_block(tr), fl.map(|x| folder.fold_expr(x))) } - ExprWhile(cond, body, opt_ident) => { + ExprWhile(cond, body, opt_name) => { ExprWhile(folder.fold_expr(cond), folder.fold_block(body), - opt_ident.map(|i| folder.fold_ident(i))) + opt_name.map(|i| folder.fold_name(i))) } - ExprLoop(body, opt_ident) => { + ExprLoop(body, opt_name) => { ExprLoop(folder.fold_block(body), - opt_ident.map(|i| folder.fold_ident(i))) + opt_name.map(|i| folder.fold_name(i))) } ExprMatch(expr, arms, source) => { ExprMatch(folder.fold_expr(expr), @@ -1061,11 +1053,11 @@ pub fn noop_fold_expr(Expr { id, node, span, attrs }: Expr, folder: & }); ExprPath(qself, folder.fold_path(path)) } - ExprBreak(opt_ident) => ExprBreak(opt_ident.map(|label| { - respan(folder.new_span(label.span), folder.fold_ident(label.node)) + ExprBreak(opt_name) => ExprBreak(opt_name.map(|label| { + respan(folder.new_span(label.span), folder.fold_name(label.node)) })), - ExprAgain(opt_ident) => ExprAgain(opt_ident.map(|label| { - respan(folder.new_span(label.span), folder.fold_ident(label.node)) + ExprAgain(opt_name) => ExprAgain(opt_name.map(|label| { + respan(folder.new_span(label.span), folder.fold_name(label.node)) })), ExprRet(e) => ExprRet(e.map(|x| folder.fold_expr(x))), ExprInlineAsm(asm, outputs, inputs) => { diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index b387ced48228c..2e9e433b830fc 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -97,9 +97,6 @@ pub trait Visitor<'v> : Sized { fn visit_name(&mut self, _span: Span, _name: Name) { // Nothing to do. } - fn visit_ident(&mut self, span: Span, ident: Ident) { - walk_ident(self, span, ident); - } fn visit_mod(&mut self, m: &'v Mod, _s: Span, _n: NodeId) { walk_mod(self, m) } @@ -211,16 +208,6 @@ pub fn walk_opt_name<'v, V: Visitor<'v>>(visitor: &mut V, span: Span, opt_name: } } -pub fn walk_opt_ident<'v, V: Visitor<'v>>(visitor: &mut V, span: Span, opt_ident: Option) { - for ident in opt_ident { - visitor.visit_ident(span, ident); - } -} - -pub fn walk_ident<'v, V: Visitor<'v>>(visitor: &mut V, span: Span, ident: Ident) { - visitor.visit_name(span, ident.name); -} - /// Walks the contents of a crate. See also `Crate::visit_all_items`. pub fn walk_crate<'v, V: Visitor<'v>>(visitor: &mut V, krate: &'v Crate) { visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID); @@ -439,7 +426,7 @@ pub fn walk_path_list_item<'v, V: Visitor<'v>>(visitor: &mut V, pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V, path_span: Span, segment: &'v PathSegment) { - visitor.visit_ident(path_span, segment.identifier); + visitor.visit_name(path_span, segment.name); visitor.visit_path_parameters(path_span, &segment.parameters); } @@ -495,7 +482,7 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) { visitor.visit_pat(subpattern) } PatKind::Ident(_, ref pth1, ref optional_subpattern) => { - visitor.visit_ident(pth1.span, pth1.node); + visitor.visit_name(pth1.span, pth1.node); walk_list!(visitor, visit_pat, optional_subpattern); } PatKind::Lit(ref expression) => visitor.visit_expr(expression), @@ -750,14 +737,14 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) { visitor.visit_block(if_block); walk_list!(visitor, visit_expr, optional_else); } - ExprWhile(ref subexpression, ref block, opt_ident) => { + ExprWhile(ref subexpression, ref block, opt_name) => { visitor.visit_expr(subexpression); visitor.visit_block(block); - walk_opt_ident(visitor, expression.span, opt_ident) + walk_opt_name(visitor, expression.span, opt_name) } - ExprLoop(ref block, opt_ident) => { + ExprLoop(ref block, opt_name) => { visitor.visit_block(block); - walk_opt_ident(visitor, expression.span, opt_ident) + walk_opt_name(visitor, expression.span, opt_name) } ExprMatch(ref subexpression, ref arms, _) => { visitor.visit_expr(subexpression); @@ -796,9 +783,9 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) { } visitor.visit_path(path, expression.id) } - ExprBreak(ref opt_sp_ident) | ExprAgain(ref opt_sp_ident) => { - for sp_ident in opt_sp_ident { - visitor.visit_ident(sp_ident.span, sp_ident.node); + ExprBreak(ref opt_sp_name) | ExprAgain(ref opt_sp_name) => { + for sp_name in opt_sp_name { + visitor.visit_name(sp_name.span, sp_name.node); } } ExprRet(ref optional_expression) => { diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 0c3c190064b08..f5cb611b95fd1 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -150,8 +150,8 @@ impl<'a> LoweringContext<'a> { self.id_assigner.next_node_id() } - fn str_to_ident(&self, s: &'static str) -> hir::Ident { - hir::Ident::from_name(token::gensym(s)) + fn str_to_ident(&self, s: &'static str) -> Name { + token::gensym(s) } fn with_parent_def(&mut self, parent_id: NodeId, f: F) -> T @@ -169,11 +169,8 @@ impl<'a> LoweringContext<'a> { result } - fn lower_ident(&mut self, ident: Ident) -> hir::Ident { - hir::Ident { - name: mtwt::resolve(ident), - unhygienic_name: ident.name, - } + fn lower_ident(&mut self, ident: Ident) -> Name { + mtwt::resolve(ident) } fn lower_attrs(&mut self, attrs: &Vec) -> hir::HirVec { @@ -329,10 +326,10 @@ impl<'a> LoweringContext<'a> { .iter() .map(|&PathSegment { identifier, ref parameters }| { hir::PathSegment { - identifier: if maybe_hygienic { + name: if maybe_hygienic { self.lower_ident(identifier) } else { - hir::Ident::from_name(identifier.name) + identifier.name }, parameters: self.lower_path_parameters(parameters), } @@ -1692,7 +1689,7 @@ impl<'a> LoweringContext<'a> { self.expr(span, hir::ExprCall(e, args), attrs) } - fn expr_ident(&mut self, span: Span, id: hir::Ident, attrs: ThinAttributes, binding: NodeId) + fn expr_ident(&mut self, span: Span, id: Name, attrs: ThinAttributes, binding: NodeId) -> P { let expr_path = hir::ExprPath(None, self.path_ident(span, id)); let expr = self.expr(span, expr_path, attrs); @@ -1760,7 +1757,7 @@ impl<'a> LoweringContext<'a> { fn stmt_let(&mut self, sp: Span, mutbl: bool, - ident: hir::Ident, + ident: Name, ex: P, attrs: ThinAttributes) -> (hir::Stmt, NodeId) { @@ -1834,16 +1831,16 @@ impl<'a> LoweringContext<'a> { pat } - fn pat_ident(&mut self, span: Span, ident: hir::Ident) -> P { - self.pat_ident_binding_mode(span, ident, hir::BindByValue(hir::MutImmutable)) + fn pat_ident(&mut self, span: Span, name: Name) -> P { + self.pat_ident_binding_mode(span, name, hir::BindByValue(hir::MutImmutable)) } - fn pat_ident_binding_mode(&mut self, span: Span, ident: hir::Ident, bm: hir::BindingMode) + fn pat_ident_binding_mode(&mut self, span: Span, name: Name, bm: hir::BindingMode) -> P { let pat_ident = hir::PatKind::Ident(bm, Spanned { span: span, - node: ident, + node: name, }, None); @@ -1851,7 +1848,7 @@ impl<'a> LoweringContext<'a> { let parent_def = self.parent_def; let def = self.resolver.definitions().map(|defs| { - let def_path_data = DefPathData::Binding(ident.name); + let def_path_data = DefPathData::Binding(name); let def_index = defs.create_def_with_parent(parent_def, pat.id, def_path_data); Def::Local(DefId::local(def_index), pat.id) }).unwrap_or(Def::Err); @@ -1872,36 +1869,36 @@ impl<'a> LoweringContext<'a> { }) } - fn path_ident(&mut self, span: Span, id: hir::Ident) -> hir::Path { + fn path_ident(&mut self, span: Span, id: Name) -> hir::Path { self.path(span, vec![id]) } - fn path(&mut self, span: Span, strs: Vec) -> hir::Path { + fn path(&mut self, span: Span, strs: Vec) -> hir::Path { self.path_all(span, false, strs, hir::HirVec::new(), hir::HirVec::new(), hir::HirVec::new()) } - fn path_global(&mut self, span: Span, strs: Vec) -> hir::Path { + fn path_global(&mut self, span: Span, strs: Vec) -> hir::Path { self.path_all(span, true, strs, hir::HirVec::new(), hir::HirVec::new(), hir::HirVec::new()) } fn path_all(&mut self, sp: Span, global: bool, - mut idents: Vec, + mut names: Vec, lifetimes: hir::HirVec, types: hir::HirVec>, bindings: hir::HirVec) -> hir::Path { - let last_identifier = idents.pop().unwrap(); - let mut segments: Vec = idents.into_iter().map(|ident| { + let last_identifier = names.pop().unwrap(); + let mut segments: Vec = names.into_iter().map(|name| { hir::PathSegment { - identifier: ident, + name: name, parameters: hir::PathParameters::none(), } }).collect(); segments.push(hir::PathSegment { - identifier: last_identifier, + name: last_identifier, parameters: hir::AngleBracketedParameters(hir::AngleBracketedParameterData { lifetimes: lifetimes, types: types, @@ -1915,12 +1912,12 @@ impl<'a> LoweringContext<'a> { } } - fn std_path(&mut self, components: &[&str]) -> Vec { + fn std_path(&mut self, components: &[&str]) -> Vec { let mut v = Vec::new(); if let Some(s) = self.crate_root { - v.push(hir::Ident::from_name(token::intern(s))); + v.push(token::intern(s)); } - v.extend(components.iter().map(|s| hir::Ident::from_name(token::intern(s)))); + v.extend(components.iter().map(|s| token::intern(s))); return v; } diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs index 640ef48493a2c..e783d84dc1b4a 100644 --- a/src/librustc/hir/map/def_collector.rs +++ b/src/librustc/hir/map/def_collector.rs @@ -396,8 +396,8 @@ impl<'ast> intravisit::Visitor<'ast> for DefCollector<'ast> { fn visit_pat(&mut self, pat: &'ast hir::Pat) { let parent_def = self.parent_def; - if let hir::PatKind::Ident(_, id, _) = pat.node { - let def = self.create_def(pat.id, DefPathData::Binding(id.node.name)); + if let hir::PatKind::Ident(_, name, _) = pat.node { + let def = self.create_def(pat.id, DefPathData::Binding(name.node)); self.parent_def = Some(def); } diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index f0eb580cfd57e..c0bbccad5f20f 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -562,9 +562,7 @@ impl<'ast> Map<'ast> { NodeVariant(v) => v.node.name, NodeLifetime(lt) => lt.name, NodeTyParam(tp) => tp.name, - NodeLocal(&Pat { node: PatKind::Ident(_,l,_), .. }) => { - l.node.name - }, + NodeLocal(&Pat { node: PatKind::Ident(_,l,_), .. }) => l.node, NodeStructCtor(_) => self.name(self.get_parent(id)), _ => bug!("no name for {}", self.node_to_string(id)) } diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index eb38458a3acfa..1b0b803ddafb1 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -46,8 +46,6 @@ use syntax::ptr::P; use std::collections::BTreeMap; use std::fmt; -use std::hash::{Hash, Hasher}; -use serialize::{Encodable, Decodable, Encoder, Decoder}; /// HIR doesn't commit to a concrete storage type and have its own alias for a vector. /// It can be `Vec`, `P<[T]>` or potentially `Box<[T]>`, or some other container with similar @@ -76,63 +74,6 @@ pub mod pat_util; pub mod print; pub mod svh; -/// Identifier in HIR -#[derive(Clone, Copy, Eq)] -pub struct Ident { - /// Hygienic name (renamed), should be used by default - pub name: Name, - /// Unhygienic name (original, not renamed), needed in few places in name resolution - pub unhygienic_name: Name, -} - -impl Ident { - /// Creates a HIR identifier with both `name` and `unhygienic_name` initialized with - /// the argument. Hygiene properties of the created identifier depend entirely on this - /// argument. If the argument is a plain interned string `intern("iter")`, then the result - /// is unhygienic and can interfere with other entities named "iter". If the argument is - /// a "fresh" name created with `gensym("iter")`, then the result is hygienic and can't - /// interfere with other entities having the same string as a name. - pub fn from_name(name: Name) -> Ident { - Ident { name: name, unhygienic_name: name } - } -} - -impl PartialEq for Ident { - fn eq(&self, other: &Ident) -> bool { - self.name == other.name - } -} - -impl Hash for Ident { - fn hash(&self, state: &mut H) { - self.name.hash(state) - } -} - -impl fmt::Debug for Ident { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&self.name, f) - } -} - -impl fmt::Display for Ident { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&self.name, f) - } -} - -impl Encodable for Ident { - fn encode(&self, s: &mut S) -> Result<(), S::Error> { - self.name.encode(s) - } -} - -impl Decodable for Ident { - fn decode(d: &mut D) -> Result { - Ok(Ident::from_name(Name::decode(d)?)) - } -} - #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] pub struct Lifetime { pub id: NodeId, @@ -184,12 +125,12 @@ impl fmt::Display for Path { impl Path { /// Convert a span and an identifier to the corresponding /// 1-segment path. - pub fn from_ident(s: Span, ident: Ident) -> Path { + pub fn from_name(s: Span, name: Name) -> Path { Path { span: s, global: false, segments: hir_vec![PathSegment { - identifier: ident, + name: name, parameters: PathParameters::none() }], } @@ -201,15 +142,7 @@ impl Path { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct PathSegment { /// The identifier portion of this path segment. - /// - /// Hygiene properties of this identifier are worth noting. - /// Most path segments are not hygienic and they are not renamed during - /// lowering from AST to HIR (see comments to `fn lower_path`). However segments from - /// unqualified paths with one segment originating from `ExprPath` (local-variable-like paths) - /// can be hygienic, so they are renamed. You should not normally care about this peculiarity - /// and just use `identifier.name` unless you modify identifier resolution code - /// (`fn resolve_identifier` and other functions called by it in `rustc_resolve`). - pub identifier: Ident, + pub name: Name, /// Type/lifetime parameters attached to this path. They come in /// two flavors: `Path` and `Path(A,B) -> C`. Note that @@ -600,7 +533,7 @@ pub enum PatKind { /// which it is. The resolver determines this, and /// records this pattern's `NodeId` in an auxiliary /// set (of "PatIdents that refer to unit patterns or constants"). - Ident(BindingMode, Spanned, Option>), + Ident(BindingMode, Spanned, Option>), /// A struct or struct variant pattern, e.g. `Variant {x, y, ..}`. /// The `bool` is `true` in the presence of a `..`. @@ -940,11 +873,11 @@ pub enum Expr_ { /// A while loop, with an optional label /// /// `'label: while expr { block }` - ExprWhile(P, P, Option), + ExprWhile(P, P, Option), /// Conditionless loop (can be exited with break, continue, or return) /// /// `'label: loop { block }` - ExprLoop(P, Option), + ExprLoop(P, Option), /// A `match` block, with a source that indicates whether or not it is /// the result of a desugaring, and if so, which kind. ExprMatch(P, HirVec, MatchSource), @@ -980,9 +913,9 @@ pub enum Expr_ { /// A referencing operation (`&a` or `&mut a`) ExprAddrOf(Mutability, P), /// A `break`, with an optional label to break - ExprBreak(Option>), + ExprBreak(Option>), /// A `continue`, with an optional label - ExprAgain(Option>), + ExprAgain(Option>), /// A `return`, with an optional value to be returned ExprRet(Option>), diff --git a/src/librustc/hir/pat_util.rs b/src/librustc/hir/pat_util.rs index 6bbd6a207ee04..15f2310607ffe 100644 --- a/src/librustc/hir/pat_util.rs +++ b/src/librustc/hir/pat_util.rs @@ -113,19 +113,6 @@ pub fn pat_is_binding_or_wild(dm: &DefMap, pat: &hir::Pat) -> bool { /// `match foo() { Some(a) => (), None => () }` pub fn pat_bindings(dm: &RefCell, pat: &hir::Pat, mut it: I) where I: FnMut(hir::BindingMode, ast::NodeId, Span, &Spanned), -{ - pat.walk(|p| { - match p.node { - PatKind::Ident(binding_mode, ref pth, _) if pat_is_binding(&dm.borrow(), p) => { - it(binding_mode, p.id, p.span, &respan(pth.span, pth.node.name)); - } - _ => {} - } - true - }); -} -pub fn pat_bindings_ident(dm: &RefCell, pat: &hir::Pat, mut it: I) where - I: FnMut(hir::BindingMode, ast::NodeId, Span, &Spanned), { pat.walk(|p| { match p.node { @@ -201,7 +188,7 @@ pub fn pat_contains_bindings_or_wild(dm: &DefMap, pat: &hir::Pat) -> bool { pub fn simple_name<'a>(pat: &'a hir::Pat) -> Option { match pat.node { PatKind::Ident(hir::BindByValue(_), ref path1, None) => { - Some(path1.node.name) + Some(path1.node) } _ => { None @@ -210,8 +197,7 @@ pub fn simple_name<'a>(pat: &'a hir::Pat) -> Option { } pub fn def_to_path<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> hir::Path { - let name = tcx.item_name(id); - hir::Path::from_ident(DUMMY_SP, hir::Ident::from_name(name)) + hir::Path::from_name(DUMMY_SP, tcx.item_name(id)) } /// Return variants that are necessary to exist for the pattern to match. diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index c3617cb768d56..4455c7da3ba3f 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -1351,9 +1351,9 @@ impl<'a> State<'a> { hir::ExprIf(ref test, ref blk, ref elseopt) => { self.print_if(&test, &blk, elseopt.as_ref().map(|e| &**e))?; } - hir::ExprWhile(ref test, ref blk, opt_ident) => { - if let Some(ident) = opt_ident { - self.print_name(ident.name)?; + hir::ExprWhile(ref test, ref blk, opt_name) => { + if let Some(name) = opt_name { + self.print_name(name)?; self.word_space(":")?; } self.head("while")?; @@ -1361,9 +1361,9 @@ impl<'a> State<'a> { space(&mut self.s)?; self.print_block(&blk)?; } - hir::ExprLoop(ref blk, opt_ident) => { - if let Some(ident) = opt_ident { - self.print_name(ident.name)?; + hir::ExprLoop(ref blk, opt_name) => { + if let Some(name) = opt_name { + self.print_name(name)?; self.word_space(":")?; } self.head("loop")?; @@ -1455,19 +1455,19 @@ impl<'a> State<'a> { hir::ExprPath(Some(ref qself), ref path) => { self.print_qpath(path, qself, true)? } - hir::ExprBreak(opt_ident) => { + hir::ExprBreak(opt_name) => { word(&mut self.s, "break")?; space(&mut self.s)?; - if let Some(ident) = opt_ident { - self.print_name(ident.node.name)?; + if let Some(name) = opt_name { + self.print_name(name.node)?; space(&mut self.s)?; } } - hir::ExprAgain(opt_ident) => { + hir::ExprAgain(opt_name) => { word(&mut self.s, "continue")?; space(&mut self.s)?; - if let Some(ident) = opt_ident { - self.print_name(ident.node.name)?; + if let Some(name) = opt_name { + self.print_name(name.node)?; space(&mut self.s)? } } @@ -1615,7 +1615,7 @@ impl<'a> State<'a> { word(&mut self.s, "::")? } - self.print_name(segment.identifier.name)?; + self.print_name(segment.name)?; self.print_path_parameters(&segment.parameters, colons_before_params)?; } @@ -1639,7 +1639,7 @@ impl<'a> State<'a> { word(&mut self.s, ">")?; word(&mut self.s, "::")?; let item_segment = path.segments.last().unwrap(); - self.print_name(item_segment.identifier.name)?; + self.print_name(item_segment.name)?; self.print_path_parameters(&item_segment.parameters, colons_before_params) } @@ -1727,7 +1727,7 @@ impl<'a> State<'a> { self.word_nbsp("mut")?; } } - self.print_name(path1.node.name)?; + self.print_name(path1.node)?; match *sub { Some(ref p) => { word(&mut self.s, "@")?; @@ -2095,7 +2095,7 @@ impl<'a> State<'a> { hir::ViewPathSimple(name, ref path) => { self.print_path(path, false, 0)?; - if path.segments.last().unwrap().identifier.name != name { + if path.segments.last().unwrap().name != name { space(&mut self.s)?; self.word_space("as")?; self.print_name(name)?; @@ -2151,8 +2151,8 @@ impl<'a> State<'a> { if let Some(eself) = input.to_self() { self.print_explicit_self(&eself)?; } else { - let invalid = if let PatKind::Ident(_, ident, _) = input.pat.node { - ident.node.name == keywords::Invalid.name() + let invalid = if let PatKind::Ident(_, name, _) = input.pat.node { + name.node == keywords::Invalid.name() } else { false }; diff --git a/src/librustc/infer/error_reporting.rs b/src/librustc/infer/error_reporting.rs index 950b7f68ed878..45982793a703b 100644 --- a/src/librustc/infer/error_reporting.rs +++ b/src/librustc/infer/error_reporting.rs @@ -1514,7 +1514,7 @@ impl<'a, 'gcx, 'tcx> Rebuilder<'a, 'gcx, 'tcx> { } }; let new_seg = hir::PathSegment { - identifier: last_seg.identifier, + name: last_seg.name, parameters: new_parameters }; let mut new_segs = Vec::new(); diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 473fd7d9be654..be8caeb436a34 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -1050,7 +1050,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { hir::ExprBreak(opt_label) => { // Find which label this break jumps to - let sc = self.find_loop_scope(opt_label.map(|l| l.node.name), expr.id, expr.span); + let sc = self.find_loop_scope(opt_label.map(|l| l.node), expr.id, expr.span); // Now that we know the label we're going to, // look it up in the break loop nodes table @@ -1063,7 +1063,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { hir::ExprAgain(opt_label) => { // Find which label this expr continues to - let sc = self.find_loop_scope(opt_label.map(|l| l.node.name), expr.id, expr.span); + let sc = self.find_loop_scope(opt_label.map(|l| l.node), expr.id, expr.span); // Now that we know the label we're going to, // look it up in the continue loop nodes table diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 932f2882b4963..2200d72c883ff 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -433,7 +433,7 @@ fn extract_labels<'v, 'a>(ctxt: &mut LifetimeContext<'a>, b: &'v hir::Block) { fn expression_label(ex: &hir::Expr) -> Option { match ex.node { hir::ExprWhile(_, _, Some(label)) | - hir::ExprLoop(_, Some(label)) => Some(label.unhygienic_name), + hir::ExprLoop(_, Some(label)) => Some(label.unhygienize()), _ => None, } } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 114e81721ab28..dfb4ec739247d 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2216,7 +2216,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { match self.map.find(id) { Some(ast_map::NodeLocal(pat)) => { match pat.node { - PatKind::Ident(_, ref path1, _) => path1.node.name.as_str(), + PatKind::Ident(_, ref path1, _) => path1.node.as_str(), _ => { bug!("Variable id {} maps to {:?}, not local", id, pat); }, diff --git a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs index c85d69fa8a60d..83322215e30ca 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs @@ -100,7 +100,7 @@ pub fn gather_move_from_pat<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, let pat_span_path_opt = match move_pat.node { PatKind::Ident(_, ref path1, _) => { Some(MoveSpanAndPath{span: move_pat.span, - name: path1.node.name}) + name: path1.node}) }, _ => None, }; diff --git a/src/librustc_const_eval/check_match.rs b/src/librustc_const_eval/check_match.rs index 61d2408d5bfbb..2fb5d796589b2 100644 --- a/src/librustc_const_eval/check_match.rs +++ b/src/librustc_const_eval/check_match.rs @@ -240,24 +240,24 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &hir::Expr) { fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat) { pat.walk(|p| { match p.node { - PatKind::Ident(hir::BindByValue(hir::MutImmutable), ident, None) => { + PatKind::Ident(hir::BindByValue(hir::MutImmutable), name, None) => { let pat_ty = cx.tcx.pat_ty(p); if let ty::TyEnum(edef, _) = pat_ty.sty { let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def()); if let Some(Def::Local(..)) = def { if edef.variants.iter().any(|variant| - variant.name == ident.node.unhygienic_name + variant.name == name.node.unhygienize() && variant.kind() == VariantKind::Unit ) { 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 `{}`", - ident.node, ty_path); + name.node, ty_path); help!(err, "if you meant to match on a variant, \ consider making the path in the pattern qualified: `{}::{}`", - ty_path, ident.node); + ty_path, name.node); err.emit(); } } diff --git a/src/librustc_incremental/calculate_svh.rs b/src/librustc_incremental/calculate_svh.rs index e914c38963cab..f134f3c3f1044 100644 --- a/src/librustc_incremental/calculate_svh.rs +++ b/src/librustc_incremental/calculate_svh.rs @@ -244,7 +244,7 @@ mod svh_visitor { ExprType(..) => SawExprType, ExprIf(..) => SawExprIf, ExprWhile(..) => SawExprWhile, - ExprLoop(_, id) => SawExprLoop(id.map(|id| id.name.as_str())), + ExprLoop(_, id) => SawExprLoop(id.map(|id| id.as_str())), ExprMatch(..) => SawExprMatch, ExprClosure(..) => SawExprClosure, ExprBlock(..) => SawExprBlock, @@ -255,8 +255,8 @@ mod svh_visitor { ExprIndex(..) => SawExprIndex, ExprPath(ref qself, _) => SawExprPath(qself.as_ref().map(|q| q.position)), ExprAddrOf(m, _) => SawExprAddrOf(m), - ExprBreak(id) => SawExprBreak(id.map(|id| id.node.name.as_str())), - ExprAgain(id) => SawExprAgain(id.map(|id| id.node.name.as_str())), + ExprBreak(id) => SawExprBreak(id.map(|id| id.node.as_str())), + ExprAgain(id) => SawExprAgain(id.map(|id| id.node.as_str())), ExprRet(..) => SawExprRet, ExprInlineAsm(ref a,_,_) => SawExprInlineAsm(a), ExprStruct(..) => SawExprStruct, diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index f4fb226d3525f..27a6e433c7399 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -277,7 +277,7 @@ impl LateLintPass for NonSnakeCase { if let &PatKind::Ident(_, ref path1, _) = &p.node { let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def()); if let Some(Def::Local(..)) = def { - self.check_snake_case(cx, "variable", &path1.node.name.as_str(), Some(p.span)); + self.check_snake_case(cx, "variable", &path1.node.as_str(), Some(p.span)); } } } @@ -363,7 +363,7 @@ impl LateLintPass for NonUpperCaseGlobals { match (&p.node, cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def())) { (&PatKind::Ident(_, ref path1, _), Some(Def::Const(..))) => { NonUpperCaseGlobals::check_upper_case(cx, "constant in pattern", - path1.node.name, p.span); + path1.node, p.span); } _ => {} } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index d1eba5b3f4a4c..49b59aea46ee7 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -172,7 +172,7 @@ impl LateLintPass for NonShorthandFieldPatterns { }); for fieldpat in field_pats { if let PatKind::Ident(_, ident, None) = fieldpat.node.pat.node { - if ident.node.unhygienic_name == fieldpat.node.name { + if ident.node.unhygienize() == fieldpat.node.name { cx.span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat.span, &format!("the `{}:` in this pattern is redundant and can \ be removed", ident.node)) diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index 020f12d753e63..662942a5bdc10 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -762,7 +762,7 @@ fn encode_method_argument_names(rbml_w: &mut Encoder, for arg in &decl.inputs { let tag = tag_method_argument_name; if let PatKind::Ident(_, ref path1, _) = arg.pat.node { - let name = path1.node.name.as_str(); + let name = path1.node.as_str(); rbml_w.wr_tagged_bytes(tag, name.as_bytes()); } else { rbml_w.wr_tagged_bytes(tag, &[]); diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs index 77499a0f96cde..d75cf3b7587ea 100644 --- a/src/librustc_mir/build/mod.rs +++ b/src/librustc_mir/build/mod.rs @@ -222,7 +222,7 @@ pub fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>, }; if let Some(hir::map::NodeLocal(pat)) = tcx.map.find(fv.def.var_id()) { if let hir::PatKind::Ident(_, ref ident, _) = pat.node { - decl.debug_name = ident.node.name; + decl.debug_name = ident.node; } } decl @@ -335,7 +335,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { if let Some(pat) = pattern { if let hir::PatKind::Ident(_, ref ident, _) = pat.node { if pat_is_binding(&self.hir.tcx().def_map.borrow(), pat) { - name = ident.node.name; + name = ident.node; } } } diff --git a/src/librustc_mir/hair/cx/pattern.rs b/src/librustc_mir/hair/cx/pattern.rs index 9e08e7b62d3bf..0118b97dd7f3e 100644 --- a/src/librustc_mir/hair/cx/pattern.rs +++ b/src/librustc_mir/hair/cx/pattern.rs @@ -166,7 +166,7 @@ impl<'patcx, 'cx, 'gcx, 'tcx> PatCx<'patcx, 'cx, 'gcx, 'tcx> { { let id = match self.binding_map { None => pat.id, - Some(ref map) => map[&ident.node.name], + Some(ref map) => map[&ident.node], }; let var_ty = self.cx.tcx.node_id_to_type(pat.id); let region = match var_ty.sty { @@ -197,7 +197,7 @@ impl<'patcx, 'cx, 'gcx, 'tcx> PatCx<'patcx, 'cx, 'gcx, 'tcx> { PatternKind::Binding { mutability: mutability, mode: mode, - name: ident.node.name, + name: ident.node, var: id, ty: var_ty, subpattern: self.to_opt_pattern(sub), diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 5b447a1690f6c..1d774eda71bd1 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1123,7 +1123,7 @@ impl Named for ast::PathSegment { impl Named for hir::PathSegment { fn name(&self) -> Name { - self.identifier.name + self.name } } diff --git a/src/librustc_trans/_match.rs b/src/librustc_trans/_match.rs index 6df308d5e624a..dbc277f243267 100644 --- a/src/librustc_trans/_match.rs +++ b/src/librustc_trans/_match.rs @@ -482,7 +482,7 @@ fn expand_nested_bindings<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, loop { pat = match pat.node { PatKind::Ident(_, ref path, Some(ref inner)) => { - bound_ptrs.push((path.node.name, val.val)); + bound_ptrs.push((path.node, val.val)); &inner }, _ => break @@ -520,7 +520,7 @@ fn enter_match<'a, 'b, 'p, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, match this.node { PatKind::Ident(_, ref path, None) => { if pat_is_binding(&dm.borrow(), &this) { - bound_ptrs.push((path.node.name, val.val)); + bound_ptrs.push((path.node, val.val)); } } PatKind::Vec(ref before, Some(ref slice), ref after) => { @@ -528,7 +528,7 @@ fn enter_match<'a, 'b, 'p, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, let subslice_val = bind_subslice_pat( bcx, this.id, val, before.len(), after.len()); - bound_ptrs.push((path.node.name, subslice_val)); + bound_ptrs.push((path.node, subslice_val)); } } _ => {} @@ -1802,7 +1802,7 @@ pub fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // binding will live and place it into the appropriate // map. bcx = mk_binding_alloca( - bcx, pat.id, path1.node.name, cleanup_scope, (), + bcx, pat.id, path1.node, cleanup_scope, (), "_match::bind_irrefutable_pat", |(), bcx, Datum { val: llval, ty, kind: _ }| { match pat_binding_mode { diff --git a/src/librustc_trans/debuginfo/create_scope_map.rs b/src/librustc_trans/debuginfo/create_scope_map.rs index 3a8974c2aca03..ba592382d1a79 100644 --- a/src/librustc_trans/debuginfo/create_scope_map.rs +++ b/src/librustc_trans/debuginfo/create_scope_map.rs @@ -51,9 +51,9 @@ pub fn create_scope_map(cx: &CrateContext, // Push argument identifiers onto the stack so arguments integrate nicely // with variable shadowing. for arg in args { - pat_util::pat_bindings_ident(def_map, &arg.pat, |_, node_id, _, path1| { + pat_util::pat_bindings(def_map, &arg.pat, |_, node_id, _, path1| { scope_stack.push(ScopeStackEntry { scope_metadata: fn_metadata, - name: Some(path1.node.unhygienic_name) }); + name: Some(path1.node.unhygienize()) }); scope_map.insert(node_id, fn_metadata); }) } @@ -248,7 +248,7 @@ fn walk_pattern(cx: &CrateContext, // scope stack and maybe introduce an artificial scope if pat_util::pat_is_binding(&def_map.borrow(), &pat) { - let name = path1.node.unhygienic_name; + let name = path1.node.unhygienize(); // LLVM does not properly generate 'DW_AT_start_scope' fields // for variable DIEs. For this reason we have to introduce diff --git a/src/librustc_trans/debuginfo/metadata.rs b/src/librustc_trans/debuginfo/metadata.rs index 7826693c82710..ccb01789aa64c 100644 --- a/src/librustc_trans/debuginfo/metadata.rs +++ b/src/librustc_trans/debuginfo/metadata.rs @@ -1946,7 +1946,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, Some(hir_map::NodeLocal(pat)) => { match pat.node { PatKind::Ident(_, ref path1, _) => { - path1.node.name + path1.node } _ => { span_bug!(span, diff --git a/src/librustc_trans/expr.rs b/src/librustc_trans/expr.rs index 186781547f98c..36a593a546b9c 100644 --- a/src/librustc_trans/expr.rs +++ b/src/librustc_trans/expr.rs @@ -928,13 +928,13 @@ fn trans_rvalue_stmt_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match expr.node { hir::ExprBreak(label_opt) => { - controlflow::trans_break(bcx, expr, label_opt.map(|l| l.node.name)) + controlflow::trans_break(bcx, expr, label_opt.map(|l| l.node)) } hir::ExprType(ref e, _) => { trans_into(bcx, &e, Ignore) } hir::ExprAgain(label_opt) => { - controlflow::trans_cont(bcx, expr, label_opt.map(|l| l.node.name)) + controlflow::trans_cont(bcx, expr, label_opt.map(|l| l.node)) } hir::ExprRet(ref ex) => { // Check to see if the return expression itself is reachable. diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 4faefb610562d..3f7c61871ffa3 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -1245,7 +1245,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { -> (Ty<'tcx>, Def) { let tcx = self.tcx(); - let assoc_name = item_segment.identifier.name; + let assoc_name = item_segment.name; debug!("associated_path_def_to_ty: {:?}::{}", ty, assoc_name); @@ -1356,7 +1356,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { self.report_ambiguous_associated_type(span, "Type", &path_str, - &item_segment.identifier.name.as_str()); + &item_segment.name.as_str()); return tcx.types.err; }; @@ -1371,7 +1371,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { debug!("qpath_to_ty: trait_ref={:?}", trait_ref); - self.projected_ty(span, trait_ref, item_segment.identifier.name) + self.projected_ty(span, trait_ref, item_segment.name) } /// Convert a type supplied as value for a type argument from AST into our diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index d55ca803c64ca..10c8ea84bfd64 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -200,7 +200,7 @@ impl<'a, 'gcx, 'tcx> PatCtxt<'a, 'gcx, 'tcx> { // if there are multiple arms, make sure they all agree on // what the type of the binding `x` ought to be - if let Some(&canon_id) = self.map.get(&path.node.name) { + if let Some(&canon_id) = self.map.get(&path.node) { if canon_id != pat.id { let ct = self.local_ty(pat.span, canon_id); self.demand_eqtype(pat.span, ct, typ); @@ -212,7 +212,7 @@ impl<'a, 'gcx, 'tcx> PatCtxt<'a, 'gcx, 'tcx> { } } PatKind::Ident(_, ref path, _) => { - let path = hir::Path::from_ident(path.span, path.node); + let path = hir::Path::from_name(path.span, path.node); self.check_pat_enum(pat, &path, Some(&[]), expected, false); } PatKind::TupleStruct(ref path, ref subpats) => { diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index be329ec11afcb..2cd60d20251f3 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -216,7 +216,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { } else if let Expr_::ExprPath(_, path) = expr.node.clone() { if let Some(segment) = path.segments.last() { - report_function!(expr.span, segment.identifier.name); + report_function!(expr.span, segment.name); } } } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index ed2edc30c9d31..7e912eba214b6 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -3869,7 +3869,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { &ty_segments[..base_ty_end], &ty_segments[base_ty_end..]); let item_segment = path.segments.last().unwrap(); - let item_name = item_segment.identifier.name; + let item_name = item_segment.name; let def = match self.resolve_ufcs(span, item_name, ty, node_id) { Ok(def) => Some(def), Err(error) => { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index ce83c4a258ce9..463702c11b7b7 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1626,7 +1626,7 @@ impl Clean for hir::Ty { segments: segments.into(), }; Type::QPath { - name: p.segments.last().unwrap().identifier.name.clean(cx), + name: p.segments.last().unwrap().name.clean(cx), self_type: box qself.ty.clean(cx), trait_: box resolve_type(cx, trait_path.clean(cx), self.id) } @@ -2064,7 +2064,7 @@ pub struct PathSegment { impl Clean for hir::PathSegment { fn clean(&self, cx: &DocContext) -> PathSegment { PathSegment { - name: self.identifier.name.clean(cx), + name: self.name.clean(cx), params: self.parameters.clean(cx) } } @@ -2073,7 +2073,7 @@ impl Clean for hir::PathSegment { fn path_to_string(p: &hir::Path) -> String { let mut s = String::new(); let mut first = true; - for i in p.segments.iter().map(|x| x.identifier.name.as_str()) { + for i in p.segments.iter().map(|x| x.name.as_str()) { if !first || p.global { s.push_str("::"); } else { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 0f3b9be3a7ac6..d9409d3bbd921 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -60,6 +60,10 @@ impl Name { pub fn as_str(self) -> token::InternedString { token::InternedString::new_from_name(self) } + + pub fn unhygienize(self) -> Name { + token::intern(&self.as_str()) + } } impl fmt::Debug for Name { From 79b343d87c64e786c79f640675beefa4064100ec Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 6 Mar 2016 15:54:44 +0300 Subject: [PATCH 2/3] lowering: Rename identifiers only when necessary Do not rename invalid identifiers, they stop being invalid after renaming --- src/librustc/hir/lowering.rs | 44 ++++++++++++++++++++++++++---------- src/librustc_resolve/lib.rs | 4 ++++ 2 files changed, 36 insertions(+), 12 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index f5cb611b95fd1..67ea7951de719 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -44,7 +44,7 @@ use hir; use hir::map::Definitions; use hir::map::definitions::DefPathData; use hir::def_id::{DefIndex, DefId}; -use hir::def::Def; +use hir::def::{Def, PathResolution}; use std::collections::BTreeMap; use std::iter; @@ -53,7 +53,7 @@ use syntax::attr::{ThinAttributes, ThinAttributesExt}; use syntax::ext::mtwt; use syntax::ptr::P; use syntax::codemap::{respan, Spanned, Span}; -use syntax::parse::token; +use syntax::parse::token::{self, keywords}; use syntax::std_inject; use syntax::visit::{self, Visitor}; @@ -72,6 +72,9 @@ pub trait Resolver { // Resolve a global hir path generated by the lowerer when expanding `for`, `if let`, etc. fn resolve_generated_global_path(&mut self, path: &hir::Path, is_value: bool) -> Def; + // Obtain the resolution for a node id + fn get_resolution(&mut self, id: NodeId) -> Option; + // Record the resolution of a path or binding generated by the lowerer when expanding. fn record_resolution(&mut self, id: NodeId, def: Def); @@ -85,6 +88,9 @@ impl Resolver for DummyResolver { fn resolve_generated_global_path(&mut self, _path: &hir::Path, _is_value: bool) -> Def { Def::Err } + fn get_resolution(&mut self, _id: NodeId) -> Option { + None + } fn record_resolution(&mut self, _id: NodeId, _def: Def) {} fn definitions(&mut self) -> Option<&mut Definitions> { None @@ -170,7 +176,11 @@ impl<'a> LoweringContext<'a> { } fn lower_ident(&mut self, ident: Ident) -> Name { - mtwt::resolve(ident) + if ident.name != keywords::Invalid.name() { + mtwt::resolve(ident) + } else { + ident.name + } } fn lower_attrs(&mut self, attrs: &Vec) -> hir::HirVec { @@ -315,18 +325,14 @@ impl<'a> LoweringContext<'a> { } } - // Path segments are usually unhygienic, hygienic path segments can occur only in - // identifier-like paths originating from `ExprPath`. - // Make life simpler for rustc_resolve by renaming only such segments. - fn lower_path_full(&mut self, p: &Path, maybe_hygienic: bool) -> hir::Path { - let maybe_hygienic = maybe_hygienic && !p.global && p.segments.len() == 1; + fn lower_path_full(&mut self, p: &Path, rename: bool) -> hir::Path { hir::Path { global: p.global, segments: p.segments .iter() .map(|&PathSegment { identifier, ref parameters }| { hir::PathSegment { - name: if maybe_hygienic { + name: if rename { self.lower_ident(identifier) } else { identifier.name @@ -846,9 +852,14 @@ impl<'a> LoweringContext<'a> { PatKind::Wild => hir::PatKind::Wild, PatKind::Ident(ref binding_mode, pth1, ref sub) => { self.with_parent_def(p.id, |this| { + let name = match this.resolver.get_resolution(p.id).map(|d| d.full_def()) { + // Only pattern bindings are renamed + None | Some(Def::Local(..)) => this.lower_ident(pth1.node), + _ => pth1.node.name, + }; hir::PatKind::Ident(this.lower_binding_mode(binding_mode), - respan(pth1.span, this.lower_ident(pth1.node)), - sub.as_ref().map(|x| this.lower_pat(x))) + respan(pth1.span, name), + sub.as_ref().map(|x| this.lower_pat(x))) }) } PatKind::Lit(ref e) => hir::PatKind::Lit(self.lower_expr(e)), @@ -1212,7 +1223,16 @@ impl<'a> LoweringContext<'a> { position: position, } }); - hir::ExprPath(hir_qself, self.lower_path_full(path, qself.is_none())) + let rename = if path.segments.len() == 1 { + // Only local variables are renamed + match self.resolver.get_resolution(e.id).map(|d| d.full_def()) { + Some(Def::Local(..)) | Some(Def::Upvar(..)) => true, + _ => false, + } + } else { + false + }; + hir::ExprPath(hir_qself, self.lower_path_full(path, rename)) } ExprKind::Break(opt_ident) => hir::ExprBreak(opt_ident.map(|sp_ident| { respan(sp_ident.span, self.lower_ident(sp_ident.node)) diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 1d774eda71bd1..016dff5f00539 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1102,6 +1102,10 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> { } } + fn get_resolution(&mut self, id: NodeId) -> Option { + self.def_map.get(&id).cloned() + } + fn record_resolution(&mut self, id: NodeId, def: Def) { self.def_map.insert(id, PathResolution { base_def: def, depth: 0 }); } From 02a1eef6e4eb4bcc214e0e00ddc62406c8990e2d Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 6 Mar 2016 15:54:44 +0300 Subject: [PATCH 3/3] Fix rebase --- src/librustc/hir/mod.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 1b0b803ddafb1..39a6ec9f3af27 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -1142,8 +1142,8 @@ pub type ExplicitSelf = Spanned; impl Arg { pub fn to_self(&self) -> Option { - if let PatKind::Ident(BindByValue(mutbl), ident, _) = self.pat.node { - if ident.node.unhygienic_name == keywords::SelfValue.name() { + if let PatKind::Ident(BindByValue(mutbl), name, _) = self.pat.node { + if name.node.unhygienize() == keywords::SelfValue.name() { return match self.ty.node { TyInfer => Some(respan(self.pat.span, SelfKind::Value(mutbl))), TyRptr(lt, MutTy{ref ty, mutbl}) if ty.node == TyInfer => { @@ -1158,8 +1158,8 @@ impl Arg { } pub fn is_self(&self) -> bool { - if let PatKind::Ident(_, ident, _) = self.pat.node { - ident.node.unhygienic_name == keywords::SelfValue.name() + if let PatKind::Ident(_, name, _) = self.pat.node { + name.node.unhygienize() == keywords::SelfValue.name() } else { false }