From c5454c04bc61760b780c3b08d1b3830267815168 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sat, 9 Jun 2018 23:25:33 +0300 Subject: [PATCH 1/8] Use `Ident`s for lifetimes in HIR --- src/librustc/hir/intravisit.rs | 6 +-- src/librustc/hir/lowering.rs | 51 +++++++++++++------------ src/librustc/hir/map/def_collector.rs | 25 ++++++------ src/librustc/hir/map/mod.rs | 4 +- src/librustc/hir/mod.rs | 25 +++++++++--- src/librustc/middle/resolve_lifetime.rs | 31 +++++++-------- src/librustc_lint/bad_style.rs | 2 +- src/librustc_typeck/check/wfcheck.rs | 2 +- src/librustc_typeck/collect.rs | 4 +- src/librustdoc/clean/auto_trait.rs | 2 +- src/librustdoc/clean/mod.rs | 10 ++--- src/libsyntax_pos/symbol.rs | 4 ++ 12 files changed, 93 insertions(+), 73 deletions(-) diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index 2a351d99841ff..bb8b0fd8e0179 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -432,8 +432,8 @@ pub fn walk_label<'v, V: Visitor<'v>>(visitor: &mut V, label: &'v Label) { pub fn walk_lifetime<'v, V: Visitor<'v>>(visitor: &mut V, lifetime: &'v Lifetime) { visitor.visit_id(lifetime.id); match lifetime.name { - LifetimeName::Param(ParamName::Plain(name)) => { - visitor.visit_name(lifetime.span, name); + LifetimeName::Param(ParamName::Plain(ident)) => { + visitor.visit_ident(ident); } LifetimeName::Param(ParamName::Fresh(_)) | LifetimeName::Static | @@ -741,7 +741,7 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi visitor.visit_id(param.id); walk_list!(visitor, visit_attribute, ¶m.attrs); match param.name { - ParamName::Plain(name) => visitor.visit_name(param.span, name), + ParamName::Plain(ident) => visitor.visit_ident(ident), ParamName::Fresh(_) => {} } match param.kind { diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index e14a86eb954f0..561097e9afc96 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -138,7 +138,7 @@ pub struct LoweringContext<'a> { // When `is_collectin_in_band_lifetimes` is true, each lifetime is checked // against this list to see if it is already in-scope, or if a definition // needs to be created for it. - in_scope_lifetimes: Vec, + in_scope_lifetimes: Vec, type_def_lifetime_params: DefIdMap, @@ -678,15 +678,15 @@ impl<'a> LoweringContext<'a> { // that collisions are ok here and this shouldn't // really show up for end-user. let str_name = match hir_name { - ParamName::Plain(name) => name.as_str(), - ParamName::Fresh(_) => keywords::UnderscoreLifetime.name().as_str(), + ParamName::Plain(ident) => name.as_interned_str(), + ParamName::Fresh(_) => keywords::UnderscoreLifetime.name().as_interned_str(), }; // Add a definition for the in-band lifetime def self.resolver.definitions().create_def_with_parent( parent_id.index, def_node_id, - DefPathData::LifetimeParam(str_name.as_interned_str()), + DefPathData::LifetimeDef(str_name), DefIndexAddressSpace::High, Mark::root(), span, @@ -712,22 +712,23 @@ impl<'a> LoweringContext<'a> { /// lifetimes are enabled, then we want to push that lifetime into /// the vector of names to define later. In that case, it will get /// added to the appropriate generics. - fn maybe_collect_in_band_lifetime(&mut self, span: Span, name: Name) { + fn maybe_collect_in_band_lifetime(&mut self, ident: Ident) { if !self.is_collecting_in_band_lifetimes { return; } - if self.in_scope_lifetimes.contains(&name) { + if self.in_scope_lifetimes.contains(&ident.modern()) { return; } let hir_name = ParamName::Plain(name); - if self.lifetimes_to_define.iter().any(|(_, lt_name)| *lt_name == hir_name) { + if self.lifetimes_to_define.iter() + .any(|(_, lt_name)| *lt_name.modern() == hir_name.modern()) { return; } - self.lifetimes_to_define.push((span, hir_name)); + self.lifetimes_to_define.push((ident.span, hir_name)); } /// When we have either an elided or `'_` lifetime in an impl @@ -750,7 +751,7 @@ impl<'a> LoweringContext<'a> { { let old_len = self.in_scope_lifetimes.len(); let lt_def_names = params.iter().filter_map(|param| match param.kind { - GenericParamKind::Lifetime { .. } => Some(param.ident.name), + GenericParamKind::Lifetime { .. } => Some(param.ident.modern()), _ => None, }); self.in_scope_lifetimes.extend(lt_def_names); @@ -774,7 +775,7 @@ impl<'a> LoweringContext<'a> { { let old_len = self.in_scope_lifetimes.len(); let lt_def_names = params.iter().filter_map(|param| match param.kind { - hir::GenericParamKind::Lifetime { .. } => Some(param.name.name()), + hir::GenericParamKind::Lifetime { .. } => Some(param.name.ident().modern()), _ => None, }); self.in_scope_lifetimes.extend(lt_def_names); @@ -1443,7 +1444,7 @@ impl<'a> LoweringContext<'a> { self.context.resolver.definitions().create_def_with_parent( self.parent, def_node_id, - DefPathData::LifetimeParam(name.name().as_interned_str()), + DefPathData::LifetimeParam(name.ident().as_interned_str()), DefIndexAddressSpace::High, Mark::root(), lifetime.span, @@ -2177,20 +2178,22 @@ impl<'a> LoweringContext<'a> { fn lower_lifetime(&mut self, l: &Lifetime) -> hir::Lifetime { let span = l.ident.span; match self.lower_ident(l.ident) { - x if x == "'static" => self.new_named_lifetime(l.id, span, hir::LifetimeName::Static), - x if x == "'_" => match self.anonymous_lifetime_mode { - AnonymousLifetimeMode::CreateParameter => { - let fresh_name = self.collect_fresh_in_band_lifetime(span); - self.new_named_lifetime(l.id, span, hir::LifetimeName::Param(fresh_name)) - } + ident if ident.name == keywords::StaticLifetime.name() => + self.new_named_lifetime(l.id, span, hir::LifetimeName::Static), + ident if ident.name == keywords::UnderscoreLifetime.name() => + match self.anonymous_lifetime_mode { + AnonymousLifetimeMode::CreateParameter => { + let fresh_name = self.collect_fresh_in_band_lifetime(span); + self.new_named_lifetime(l.id, span, hir::LifetimeName::Param(fresh_name)) + } - AnonymousLifetimeMode::PassThrough => { - self.new_named_lifetime(l.id, span, hir::LifetimeName::Underscore) - } - }, - name => { - self.maybe_collect_in_band_lifetime(span, name); - let param_name = ParamName::Plain(name); + AnonymousLifetimeMode::PassThrough => { + self.new_named_lifetime(l.id, span, hir::LifetimeName::Underscore) + } + }, + ident => { + self.maybe_collect_in_band_lifetime(ident); + let param_name = ParamName::Plain(ident); self.new_named_lifetime(l.id, span, hir::LifetimeName::Param(param_name)) } } diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs index 7c71401c8b2e8..261b5d313eff0 100644 --- a/src/librustc/hir/map/def_collector.rs +++ b/src/librustc/hir/map/def_collector.rs @@ -112,11 +112,11 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { // information we encapsulate into, the better let def_data = match i.node { ItemKind::Impl(..) => DefPathData::Impl, - ItemKind::Trait(..) => DefPathData::Trait(i.ident.name.as_interned_str()), + ItemKind::Trait(..) => DefPathData::Trait(i.ident.as_interned_str()), ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) | ItemKind::TraitAlias(..) | ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) | ItemKind::Ty(..) => - DefPathData::TypeNs(i.ident.name.as_interned_str()), + DefPathData::TypeNs(i.ident.as_interned_str()), ItemKind::Mod(..) if i.ident == keywords::Invalid.ident() => { return visit::walk_item(self, i); } @@ -129,10 +129,10 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { |this| visit::walk_item(this, i) ) } - ItemKind::Mod(..) => DefPathData::Module(i.ident.name.as_interned_str()), + ItemKind::Mod(..) => DefPathData::Module(i.ident.as_interned_str()), ItemKind::Static(..) | ItemKind::Const(..) | ItemKind::Fn(..) => - DefPathData::ValueNs(i.ident.name.as_interned_str()), - ItemKind::MacroDef(..) => DefPathData::MacroDef(i.ident.name.as_interned_str()), + DefPathData::ValueNs(i.ident.as_interned_str()), + ItemKind::MacroDef(..) => DefPathData::MacroDef(i.ident.as_interned_str()), ItemKind::Mac(..) => return self.visit_macro_invoc(i.id), ItemKind::GlobalAsm(..) => DefPathData::Misc, ItemKind::Use(..) => { @@ -169,7 +169,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { } let def = self.create_def(foreign_item.id, - DefPathData::ValueNs(foreign_item.ident.name.as_interned_str()), + DefPathData::ValueNs(foreign_item.ident.as_interned_str()), REGULAR_SPACE, foreign_item.span); @@ -180,8 +180,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { fn visit_variant(&mut self, v: &'a Variant, g: &'a Generics, item_id: NodeId) { let def = self.create_def(v.node.data.id(), - DefPathData::EnumVariant(v.node.ident - .name.as_interned_str()), + DefPathData::EnumVariant(v.node.ident.as_interned_str()), REGULAR_SPACE, v.span); self.with_parent(def, |this| visit::walk_variant(this, v, g, item_id)); @@ -201,7 +200,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { } fn visit_generic_param(&mut self, param: &'a GenericParam) { - let name = param.ident.name.as_interned_str(); + let name = param.ident.as_interned_str(); let def_path_data = match param.kind { GenericParamKind::Lifetime { .. } => DefPathData::LifetimeParam(name), GenericParamKind::Type { .. } => DefPathData::TypeParam(name), @@ -214,9 +213,9 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { fn visit_trait_item(&mut self, ti: &'a TraitItem) { let def_data = match ti.node { TraitItemKind::Method(..) | TraitItemKind::Const(..) => - DefPathData::ValueNs(ti.ident.name.as_interned_str()), + DefPathData::ValueNs(ti.ident.as_interned_str()), TraitItemKind::Type(..) => { - DefPathData::AssocTypeInTrait(ti.ident.name.as_interned_str()) + DefPathData::AssocTypeInTrait(ti.ident.as_interned_str()) }, TraitItemKind::Macro(..) => return self.visit_macro_invoc(ti.id), }; @@ -239,8 +238,8 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { ) } ImplItemKind::Method(..) | ImplItemKind::Const(..) => - DefPathData::ValueNs(ii.ident.name.as_interned_str()), - ImplItemKind::Type(..) => DefPathData::AssocTypeInImpl(ii.ident.name.as_interned_str()), + DefPathData::ValueNs(ii.ident.as_interned_str()), + ImplItemKind::Type(..) => DefPathData::AssocTypeInImpl(ii.ident.as_interned_str()), ImplItemKind::Macro(..) => return self.visit_macro_invoc(ii.id), }; diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 1e03381861b9b..8c2f4e89352e5 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -953,8 +953,8 @@ impl<'hir> Map<'hir> { NodeTraitItem(ti) => ti.name, NodeVariant(v) => v.node.name, NodeField(f) => f.ident.name, - NodeLifetime(lt) => lt.name.name(), - NodeGenericParam(param) => param.name.name(), + NodeLifetime(lt) => lt.name.ident().name, + NodeGenericParam(param) => param.name.ident().name, NodeBinding(&Pat { node: PatKind::Binding(_,_,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 68ff74a0e5112..dedc276dcc347 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -245,13 +245,13 @@ pub enum LifetimeName { } impl LifetimeName { - pub fn name(&self) -> Name { - use self::LifetimeName::*; + pub fn ident(&self) -> Ident { match *self { - Implicit => keywords::Invalid.name(), - Underscore => keywords::UnderscoreLifetime.name(), - Static => keywords::StaticLifetime.name(), - Param(param_name) => param_name.name(), + LifetimeName::Implicit => keywords::Invalid.ident(), + LifetimeName::Fresh(_) | LifetimeName::Underscore => + keywords::UnderscoreLifetime.ident(), + LifetimeName::Static => keywords::StaticLifetime.ident(), + LifetimeName::Ident(ident) => ident, } } @@ -272,6 +272,19 @@ impl LifetimeName { fn is_static(&self) -> bool { self == &LifetimeName::Static } + + pub fn modern(&self) -> LifetimeName { + match *self { + LifetimeName::Ident(ident) => LifetimeName::Ident(ident.modern()), + lifetime_name => lifetime_name, + } + } +} + +impl fmt::Display for Lifetime { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + self.name.ident().fmt(f) + } } impl fmt::Debug for Lifetime { diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 076c3c5f17df8..1d9345dbae265 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -94,7 +94,7 @@ impl Region { let def_id = hir_map.local_def_id(param.id); let origin = LifetimeDefOrigin::from_param(param); debug!("Region::early: index={} def_id={:?}", i, def_id); - (param.name, Region::EarlyBound(i, def_id, origin)) + (param.name.modern(), Region::EarlyBound(i, def_id, origin)) } fn late(hir_map: &Map, param: &GenericParam) -> (ParamName, Region) { @@ -108,7 +108,7 @@ impl Region { def_id, origin, ); - (param.name, Region::LateBound(depth, def_id, origin)) + (param.name.modern(), Region::LateBound(depth, def_id, origin)) } fn late_anon(index: &Cell) -> Region { @@ -1177,7 +1177,7 @@ fn extract_labels(ctxt: &mut LifetimeContext<'_, '_>, body: &hir::Body) { ref lifetimes, s, .. } => { // FIXME (#24278): non-hygienic comparison - let param_name = hir::ParamName::Plain(label); + let param_name = hir::ParamName::Plain(ast::Ident::with_empty_ctxt(label)); if let Some(def) = lifetimes.get(¶m_name) { let node_id = tcx.hir.as_local_node_id(def.id().unwrap()).unwrap(); @@ -1220,7 +1220,7 @@ fn compute_object_lifetime_defaults( generics.params.iter().find_map(|param| match param.kind { GenericParamKind::Lifetime { .. } => { if i == 0 { - return Some(param.name.name().to_string()); + return Some(param.name.ident().to_string()); } i -= 1; None @@ -1254,7 +1254,7 @@ fn object_lifetime_defaults_for_item( fn add_bounds(set: &mut Set1, bounds: &[hir::GenericBound]) { for bound in bounds { if let hir::GenericBound::Outlives(ref lifetime) = *bound { - set.insert(lifetime.name); + set.insert(lifetime.name.modern()); } } } @@ -1582,7 +1582,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { LifetimeName::Param(param_name) => param_name, _ => bug!("expected LifetimeName::Param"), }; - if let Some(&def) = lifetimes.get(&name) { + if let Some(&def) = lifetimes.get(&name.modern()) { break Some(def.shifted(late_depth)); } else { late_depth += 1; @@ -1651,7 +1651,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { lifetime_ref.span, E0261, "use of undeclared lifetime name `{}`", - lifetime_ref.name.name() + lifetime_ref ).span_label(lifetime_ref.span, "undeclared lifetime") .emit(); } @@ -2254,7 +2254,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { lifetime_i.span, E0262, "invalid lifetime parameter name: `{}`", - name + lifetime ); err.span_label( lifetime_i.span, @@ -2327,7 +2327,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { ) { for &(label, label_span) in &self.labels_in_fn { // FIXME (#24278): non-hygienic comparison - if param.name.name() == label { + if param.name.ident().name == label { signal_shadowing_problem( self.tcx, label, @@ -2353,12 +2353,12 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { Scope::Binder { ref lifetimes, s, .. } => { - if let Some(&def) = lifetimes.get(¶m.name) { + if let Some(&def) = lifetimes.get(¶m.name.modern()) { let node_id = self.tcx.hir.as_local_node_id(def.id().unwrap()).unwrap(); signal_shadowing_problem( self.tcx, - param.name.name(), + param.name.ident().name, original_lifetime(self.tcx.hir.span(node_id)), shadower_lifetime(¶m), ); @@ -2520,7 +2520,8 @@ fn insert_late_bound_lifetimes( hir::GenericParamKind::Lifetime { .. } => { if !param.bounds.is_empty() { // `'a: 'b` means both `'a` and `'b` are referenced - appears_in_where_clause.regions.insert(hir::LifetimeName::Param(param.name)); + appears_in_where_clause + .regions.insert(hir::LifetimeName::Param(param.name.modern())); } } hir::GenericParamKind::Type { .. } => {} @@ -2537,7 +2538,7 @@ fn insert_late_bound_lifetimes( // - do not appear in the where-clauses // - are not implicitly captured by `impl Trait` for param in &generics.params { - let lt_name = hir::LifetimeName::Param(param.name); + let lt_name = hir::LifetimeName::Param(param.name.modern()); // appears in the where clauses? early-bound. if appears_in_where_clause.regions.contains(<_name) { continue; @@ -2596,7 +2597,7 @@ fn insert_late_bound_lifetimes( } fn visit_lifetime(&mut self, lifetime_ref: &'v hir::Lifetime) { - self.regions.insert(lifetime_ref.name); + self.regions.insert(lifetime_ref.name.modern()); } } @@ -2610,7 +2611,7 @@ fn insert_late_bound_lifetimes( } fn visit_lifetime(&mut self, lifetime_ref: &'v hir::Lifetime) { - self.regions.insert(lifetime_ref.name); + self.regions.insert(lifetime_ref.name.modern()); } } } diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index 1b5361187f36a..28e533054f0cb 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -258,7 +258,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { fn check_generic_param(&mut self, cx: &LateContext, param: &hir::GenericParam) { match param.kind { GenericParamKind::Lifetime { .. } => { - let name = param.name.name().as_str(); + let name = param.name.ident().as_str(); self.check_snake_case(cx, "lifetime", &name, Some(param.span)); } GenericParamKind::Type { .. } => {} diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index b61f09cbaea6d..be42549df74a3 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -632,7 +632,7 @@ fn check_variances_for_type_defn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } let param = &hir_generics.params[index]; - report_bivariance(tcx, param.span, param.name.name()); + report_bivariance(tcx, param.span, param.name.ident().name); } } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index a537b7d41c44b..28dba08f16a67 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -898,7 +898,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let early_lifetimes = early_bound_lifetimes_from_generics(tcx, ast_generics); params.extend(early_lifetimes.enumerate().map(|(i, param)| { ty::GenericParamDef { - name: param.name.name().as_interned_str(), + name: param.name.ident().as_interned_str(), index: own_start + i as u32, def_id: tcx.hir.local_def_id(param.id), pure_wrt_drop: param.pure_wrt_drop, @@ -1437,7 +1437,7 @@ pub fn explicit_predicates_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let region = tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion { def_id: tcx.hir.local_def_id(param.id), index, - name: param.name.name().as_interned_str(), + name: param.name.ident().as_interned_str(), })); index += 1; diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index 272819ba2dd96..dd86554bec431 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -253,7 +253,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> { let name = if param.name == "" { hir::ParamName::Plain(keywords::StaticLifetime.name()) } else { - hir::ParamName::Plain(param.name.as_symbol()) + hir::ParamName::Plain(ast::Ident::from_interned_str(param.name)) }; args.push(hir::GenericArg::Lifetime(hir::Lifetime { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 3cc0745b195e6..274269ef53ac4 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1664,7 +1664,7 @@ impl Clean for hir::Lifetime { _ => {} } } - Lifetime(self.name.name().to_string()) + Lifetime(self.name.ident().to_string()) } } @@ -1677,14 +1677,14 @@ impl Clean for hir::GenericParam { hir::GenericBound::Outlives(lt) => lt, _ => panic!(), }); - let name = bounds.next().unwrap().name.name(); - let mut s = format!("{}: {}", self.name.name(), name); + let name = bounds.next().unwrap().name.ident(); + let mut s = format!("{}: {}", self.name.ident(), name); for bound in bounds { - s.push_str(&format!(" + {}", bound.name.name())); + s.push_str(&format!(" + {}", bound.name.ident())); } Lifetime(s) } else { - Lifetime(self.name.name().to_string()) + Lifetime(self.name.ident().to_string()) } } _ => panic!(), diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs index abe738d751c13..b92553842bc82 100644 --- a/src/libsyntax_pos/symbol.rs +++ b/src/libsyntax_pos/symbol.rs @@ -70,6 +70,10 @@ impl Ident { pub fn as_str(self) -> LocalInternedString { self.name.as_str() } + + pub fn as_interned_str(self) -> InternedString { + self.name.as_interned_str() + } } impl PartialEq for Ident { From 1fe9b4d76331103e05d0347c9d36526ca3242117 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 10 Jun 2018 15:55:48 +0300 Subject: [PATCH 2/8] Use `Ident`s for associated type bindings in HIR --- src/librustc/hir/intravisit.rs | 2 +- src/librustc/hir/lowering.rs | 4 ++-- src/librustc/hir/mod.rs | 2 +- src/librustc/hir/print.rs | 2 +- src/librustc/ich/impls_hir.rs | 2 +- src/librustc/traits/project.rs | 5 ++-- .../traits/specialize/specialization_graph.rs | 2 +- src/librustc/ty/mod.rs | 5 ++-- src/librustc/ty/sty.rs | 6 ++--- src/librustc_traits/lowering.rs | 2 +- src/librustc_typeck/astconv.rs | 23 +++++++++---------- src/librustc_typeck/check/autoderef.rs | 4 ++-- src/librustc_typeck/check/method/mod.rs | 7 +++--- src/librustc_typeck/check/mod.rs | 6 +++-- src/librustdoc/clean/mod.rs | 2 +- 15 files changed, 38 insertions(+), 36 deletions(-) diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index bb8b0fd8e0179..12ca0d41d0849 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -660,7 +660,7 @@ pub fn walk_generic_args<'v, V: Visitor<'v>>(visitor: &mut V, pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(visitor: &mut V, type_binding: &'v TypeBinding) { visitor.visit_id(type_binding.id); - visitor.visit_name(type_binding.span, type_binding.name); + visitor.visit_ident(type_binding.ident); visitor.visit_ty(&type_binding.ty); } diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 561097e9afc96..5e2bfc113eacd 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -1064,7 +1064,7 @@ impl<'a> LoweringContext<'a> { fn lower_ty_binding(&mut self, b: &TypeBinding, itctx: ImplTraitContext) -> hir::TypeBinding { hir::TypeBinding { id: self.lower_node_id(b.id).node_id, - name: self.lower_ident(b.ident), + ident: b.ident, ty: self.lower_ty(&b.ty, itctx), span: b.span, } @@ -1820,7 +1820,7 @@ impl<'a> LoweringContext<'a> { bindings: hir_vec![ hir::TypeBinding { id: this.next_id().node_id, - name: Symbol::intern(FN_OUTPUT_NAME), + ident: Ident::from_str(FN_OUTPUT_NAME), ty: output .as_ref() .map(|ty| this.lower_ty(&ty, DISALLOWED)) diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index dedc276dcc347..3206c2fce2069 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -1607,7 +1607,7 @@ pub enum ImplItemKind { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct TypeBinding { pub id: NodeId, - pub name: Name, + pub ident: Ident, pub ty: P, pub span: Span, } diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 6db4e987840bb..05ceb1fcfcdfe 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -1762,7 +1762,7 @@ impl<'a> State<'a> { for binding in generic_args.bindings.iter() { start_or_comma(self)?; - self.print_name(binding.name)?; + self.print_ident(binding.ident)?; self.s.space()?; self.word_space("=")?; self.print_type(&binding.ty)?; diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index b71b69474a720..cad76c4100cda 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -278,7 +278,7 @@ impl_stable_hash_for!(struct hir::MethodSig { impl_stable_hash_for!(struct hir::TypeBinding { id, - name, + ident, ty, span }); diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs index 82f351782bbcd..77077732dcf2b 100644 --- a/src/librustc/traits/project.rs +++ b/src/librustc/traits/project.rs @@ -31,6 +31,7 @@ use infer::type_variable::TypeVariableOrigin; use middle::const_val::ConstVal; use mir::interpret::{GlobalId}; use rustc_data_structures::snapshot_map::{Snapshot, SnapshotMap}; +use syntax::ast::Ident; use syntax::symbol::Symbol; use ty::subst::{Subst, Substs}; use ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt}; @@ -1452,7 +1453,7 @@ fn confirm_callable_candidate<'cx, 'gcx, 'tcx>( projection_ty: ty::ProjectionTy::from_ref_and_name( tcx, trait_ref, - Symbol::intern(FN_OUTPUT_NAME), + Ident::from_str(FN_OUTPUT_NAME), ), ty: ret_type } @@ -1546,7 +1547,7 @@ fn assoc_ty_def<'cx, 'gcx, 'tcx>( let impl_node = specialization_graph::Node::Impl(impl_def_id); for item in impl_node.items(tcx) { if item.kind == ty::AssociatedKind::Type && - tcx.hygienic_eq(item.name, assoc_ty_name, trait_def_id) { + tcx.hygienic_eq(item.name.to_ident(), assoc_ty_name.to_ident(), trait_def_id) { return specialization_graph::NodeItem { node: specialization_graph::Node::Impl(impl_def_id), item, diff --git a/src/librustc/traits/specialize/specialization_graph.rs b/src/librustc/traits/specialize/specialization_graph.rs index e56a8662f3eb4..9b0edf42fdf4d 100644 --- a/src/librustc/traits/specialize/specialization_graph.rs +++ b/src/librustc/traits/specialize/specialization_graph.rs @@ -379,7 +379,7 @@ impl<'a, 'gcx, 'tcx> Ancestors { self.flat_map(move |node| { node.items(tcx).filter(move |impl_item| { impl_item.kind == trait_item_kind && - tcx.hygienic_eq(impl_item.name, trait_item_name, trait_def_id) + tcx.hygienic_eq(impl_item.name.to_ident(), trait_item_name.to_ident(), trait_def_id) }).map(move |item| NodeItem { node: node, item: item }) }) } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index e89a022f81870..686c560fe84b9 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2717,9 +2717,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { // Hygienically compare a use-site name (`use_name`) for a field or an associated item with its // supposed definition name (`def_name`). The method also needs `DefId` of the supposed // definition's parent/scope to perform comparison. - pub fn hygienic_eq(self, use_name: Name, def_name: Name, def_parent_def_id: DefId) -> bool { - let (use_ident, def_ident) = (use_name.to_ident(), def_name.to_ident()); - self.adjust_ident(use_ident, def_parent_def_id, DUMMY_NODE_ID).0 == def_ident + pub fn hygienic_eq(self, use_name: Ident, def_name: Ident, def_parent_def_id: DefId) -> bool { + self.adjust_ident(use_name, def_parent_def_id, DUMMY_NODE_ID).0 == def_name.modern() } pub fn adjust_ident(self, mut ident: Ident, scope: DefId, block: NodeId) -> (Ident, DefId) { diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 412dc7dc7e715..a34e1e4300962 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -25,7 +25,7 @@ use mir::interpret::{Scalar, Pointer, Value, ConstValue}; use std::iter; use std::cmp::Ordering; use rustc_target::spec::abi; -use syntax::ast::{self, Name}; +use syntax::ast::{self, Ident}; use syntax::symbol::{keywords, InternedString}; use serialize; @@ -853,11 +853,11 @@ impl<'a, 'tcx> ProjectionTy<'tcx> { /// Construct a ProjectionTy by searching the trait from trait_ref for the /// associated item named item_name. pub fn from_ref_and_name( - tcx: TyCtxt, trait_ref: ty::TraitRef<'tcx>, item_name: Name + tcx: TyCtxt, trait_ref: ty::TraitRef<'tcx>, item_name: Ident ) -> ProjectionTy<'tcx> { let item_def_id = tcx.associated_items(trait_ref.def_id).find(|item| { item.kind == ty::AssociatedKind::Type && - tcx.hygienic_eq(item_name, item.name, trait_ref.def_id) + tcx.hygienic_eq(item_name, item.name.to_ident(), trait_ref.def_id) }).unwrap().def_id; ProjectionTy { diff --git a/src/librustc_traits/lowering.rs b/src/librustc_traits/lowering.rs index 16aa63d699997..137a6b5c78db3 100644 --- a/src/librustc_traits/lowering.rs +++ b/src/librustc_traits/lowering.rs @@ -417,7 +417,7 @@ pub fn program_clauses_for_associated_type_value<'a, 'tcx>( let hypotheses = vec![trait_implemented]; // `>::AssocType` - let projection_ty = ty::ProjectionTy::from_ref_and_name(tcx, trait_ref, item.name); + let projection_ty = ty::ProjectionTy::from_ref_and_name(tcx, trait_ref, item.name.to_ident()); // `Normalize(>::AssocType -> T)` let normalize_goal = DomainGoal::Normalize(ty::ProjectionPredicate { projection_ty, ty }); diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index f3912c3042d7f..e8094dc27042b 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -83,7 +83,7 @@ pub trait AstConv<'gcx, 'tcx> { } struct ConvertedBinding<'tcx> { - item_name: ast::Name, + item_name: ast::Ident, ty: Ty<'tcx>, span: Span, } @@ -342,7 +342,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { let assoc_bindings = generic_args.bindings.iter().map(|binding| { ConvertedBinding { - item_name: binding.name, + item_name: binding.ident, ty: self.ast_ty_to_ty(&binding.ty), span: binding.span, } @@ -485,12 +485,12 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { fn trait_defines_associated_type_named(&self, trait_def_id: DefId, - assoc_name: ast::Name) + assoc_name: ast::Ident) -> bool { self.tcx().associated_items(trait_def_id).any(|item| { item.kind == ty::AssociatedKind::Type && - self.tcx().hygienic_eq(assoc_name, item.name, trait_def_id) + self.tcx().hygienic_eq(assoc_name, item.name.to_ident(), trait_def_id) }) } @@ -569,7 +569,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { }?; let (assoc_ident, def_scope) = - tcx.adjust_ident(binding.item_name.to_ident(), candidate.def_id(), ref_id); + tcx.adjust_ident(binding.item_name, candidate.def_id(), ref_id); let assoc_ty = tcx.associated_items(candidate.def_id()).find(|i| { i.kind == ty::AssociatedKind::Type && i.name.to_ident() == assoc_ident }).expect("missing associated type"); @@ -778,7 +778,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { // any ambiguity. fn find_bound_for_assoc_item(&self, ty_param_def_id: DefId, - assoc_name: ast::Name, + assoc_name: ast::Ident, span: Span) -> Result, ErrorReported> { @@ -807,7 +807,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { fn one_bound_for_assoc_type(&self, mut bounds: I, ty_param_name: &str, - assoc_name: ast::Name, + assoc_name: ast::Ident, span: Span) -> Result, ErrorReported> where I: Iterator> @@ -837,7 +837,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { for bound in bounds { let bound_span = self.tcx().associated_items(bound.def_id()).find(|item| { item.kind == ty::AssociatedKind::Type && - self.tcx().hygienic_eq(assoc_name, item.name, bound.def_id()) + self.tcx().hygienic_eq(assoc_name, item.name.to_ident(), bound.def_id()) }) .and_then(|item| self.tcx().hir.span_if_local(item.def_id)); @@ -873,7 +873,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { -> (Ty<'tcx>, Def) { let tcx = self.tcx(); - let assoc_name = item_segment.name; + let assoc_name = item_segment.name.to_ident(); debug!("associated_path_def_to_ty: {:?}::{}", ty, assoc_name); @@ -895,8 +895,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { let candidates = traits::supertraits(tcx, ty::Binder::bind(trait_ref)) - .filter(|r| self.trait_defines_associated_type_named(r.def_id(), - assoc_name)); + .filter(|r| self.trait_defines_associated_type_named(r.def_id(), assoc_name)); match self.one_bound_for_assoc_type(candidates, "Self", assoc_name, span) { Ok(bound) => bound, @@ -923,7 +922,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { }; let trait_did = bound.def_id(); - let (assoc_ident, def_scope) = tcx.adjust_ident(assoc_name.to_ident(), trait_did, ref_id); + let (assoc_ident, def_scope) = tcx.adjust_ident(assoc_name, trait_did, ref_id); let item = tcx.associated_items(trait_did).find(|i| { Namespace::from(i.kind) == Namespace::Type && i.name.to_ident() == assoc_ident diff --git a/src/librustc_typeck/check/autoderef.rs b/src/librustc_typeck/check/autoderef.rs index 4274e5c1e1f75..09562614982b8 100644 --- a/src/librustc_typeck/check/autoderef.rs +++ b/src/librustc_typeck/check/autoderef.rs @@ -21,7 +21,7 @@ use rustc::ty::{ToPredicate, TypeFoldable}; use rustc::ty::adjustment::{Adjustment, Adjust, OverloadedDeref}; use syntax_pos::Span; -use syntax::symbol::Symbol; +use syntax::ast::Ident; use std::iter; @@ -134,7 +134,7 @@ impl<'a, 'gcx, 'tcx> Autoderef<'a, 'gcx, 'tcx> { ty::ProjectionTy::from_ref_and_name( tcx, trait_ref, - Symbol::intern("Target"), + Ident::from_str("Target"), ), cause, 0, diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index a51876d7960b0..feb99f4b5938a 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -387,8 +387,9 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { /// and return it, or `None`, if no such item was defined there. pub fn associated_item(&self, def_id: DefId, item_name: ast::Name, ns: Namespace) -> Option { - self.tcx.associated_items(def_id) - .find(|item| Namespace::from(item.kind) == ns && - self.tcx.hygienic_eq(item_name, item.name, def_id)) + self.tcx.associated_items(def_id).find(|item| { + Namespace::from(item.kind) == ns && + self.tcx.hygienic_eq(item_name.to_ident(), item.name.to_ident(), def_id) + }) } } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 889073f6b4ca9..82df956b54ddf 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1400,11 +1400,13 @@ fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id)); let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id) .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) && - tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id)) + tcx.hygienic_eq(ty_impl_item.name.to_ident(), ac.name.to_ident(), + impl_trait_ref.def_id)) .or_else(|| { // Not compatible, but needed for the error message tcx.associated_items(impl_trait_ref.def_id) - .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id)) + .find(|ac| tcx.hygienic_eq(ty_impl_item.name.to_ident(), ac.name.to_ident(), + impl_trait_ref.def_id)) }); // Check that impl definition matches trait definition diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 274269ef53ac4..3a1390bb3c24f 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -4293,7 +4293,7 @@ pub struct TypeBinding { impl Clean for hir::TypeBinding { fn clean(&self, cx: &DocContext) -> TypeBinding { TypeBinding { - name: self.name.clean(cx), + name: self.ident.name.clean(cx), ty: self.ty.clean(cx) } } From e8215a4f6f7b32d0f068e72ab9a9c9f85bab0cdb Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 10 Jun 2018 17:40:45 +0300 Subject: [PATCH 3/8] Use `Ident`s for path segments in HIR --- src/librustc/hir/intravisit.rs | 2 +- src/librustc/hir/lowering.rs | 38 ++++++++++----------- src/librustc/hir/mod.rs | 12 +++---- src/librustc/hir/print.rs | 23 +++++++------ src/librustc/ich/impls_hir.rs | 2 +- src/librustc_lint/bad_style.rs | 2 +- src/librustc_privacy/lib.rs | 4 +-- src/librustc_resolve/lib.rs | 18 +++++----- src/librustc_typeck/astconv.rs | 4 +-- src/librustc_typeck/check/demand.rs | 2 +- src/librustc_typeck/check/method/mod.rs | 19 ++++++----- src/librustc_typeck/check/method/probe.rs | 15 ++++---- src/librustc_typeck/check/method/suggest.rs | 9 +++-- src/librustc_typeck/check/mod.rs | 8 ++--- src/librustdoc/clean/auto_trait.rs | 6 ++-- src/librustdoc/clean/mod.rs | 14 ++++---- 16 files changed, 88 insertions(+), 90 deletions(-) diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index 12ca0d41d0849..29507474aa1ee 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -644,7 +644,7 @@ pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) { pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V, path_span: Span, segment: &'v PathSegment) { - visitor.visit_name(path_span, segment.name); + visitor.visit_ident(segment.ident); if let Some(ref args) = segment.args { visitor.visit_generic_args(path_span, args); } diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 5e2bfc113eacd..5a0e9c36b910a 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -604,8 +604,8 @@ impl<'a> LoweringContext<'a> { self.sess.diagnostic() } - fn str_to_ident(&self, s: &'static str) -> Name { - Symbol::gensym(s) + fn str_to_ident(&self, s: &'static str) -> Ident { + Ident::with_empty_ctxt(Symbol::gensym(s)) } fn allow_internal_unstable(&self, reason: CompilerDesugaringKind, span: Span) -> Span { @@ -1139,7 +1139,7 @@ impl<'a> LoweringContext<'a> { None, P(hir::Path { def: self.expect_full_def(t.id), - segments: hir_vec![hir::PathSegment::from_name(keywords::SelfType.name())], + segments: hir_vec![hir::PathSegment::from_ident(keywords::SelfType.ident())], span: t.span, }), )), @@ -1195,7 +1195,7 @@ impl<'a> LoweringContext<'a> { let hir_bounds = self.lower_param_bounds(bounds, itctx); // Set the name to `impl Bound1 + Bound2` - let name = Symbol::intern(&pprust::ty_to_string(t)); + let ident = Ident::from_str(&pprust::ty_to_string(t)); self.in_band_ty_params.push(hir::GenericParam { id: def_node_id, name: ParamName::Plain(name), @@ -1214,7 +1214,7 @@ impl<'a> LoweringContext<'a> { P(hir::Path { span, def: Def::TyParam(DefId::local(def_index)), - segments: hir_vec![hir::PathSegment::from_name(name)], + segments: hir_vec![hir::PathSegment::from_ident(ident)], }), )) } @@ -1689,7 +1689,7 @@ impl<'a> LoweringContext<'a> { &mut self, def: Def, p: &Path, - name: Option, + ident: Option, param_mode: ParamMode, ) -> hir::Path { hir::Path { @@ -1706,7 +1706,7 @@ impl<'a> LoweringContext<'a> { ImplTraitContext::Disallowed, ) }) - .chain(name.map(|name| hir::PathSegment::from_name(name))) + .chain(ident.map(|ident| hir::PathSegment::from_ident(ident))) .collect(), span: p.span, } @@ -1769,7 +1769,7 @@ impl<'a> LoweringContext<'a> { } hir::PathSegment::new( - self.lower_ident(segment.ident), + segment.ident, generic_args, infer_types, ) @@ -3307,7 +3307,7 @@ impl<'a> LoweringContext<'a> { P(hir::Path { span: ident.span, def, - segments: hir_vec![hir::PathSegment::from_name(ident.name)], + segments: hir_vec![hir::PathSegment::from_ident(ident)], }), )), } @@ -3670,7 +3670,7 @@ impl<'a> LoweringContext<'a> { let e2 = self.lower_expr(e2); let ty_path = P(self.std_path(span, &["ops", "RangeInclusive"], None, false)); let ty = P(self.ty_path(id, span, hir::QPath::Resolved(None, ty_path))); - let new_seg = P(hir::PathSegment::from_name(Symbol::intern("new"))); + let new_seg = P(hir::PathSegment::from_name(Ident::from_str("new"))); let new_path = hir::QPath::TypeRelative(ty, new_seg); let new = P(self.expr(span, hir::ExprPath(new_path), ThinVec::new())); hir::ExprCall(new, hir_vec![e1, e2]) @@ -4340,14 +4340,14 @@ impl<'a> LoweringContext<'a> { self.expr(span, hir::ExprCall(e, args), ThinVec::new()) } - fn expr_ident(&mut self, span: Span, id: Name, binding: NodeId) -> hir::Expr { - self.expr_ident_with_attrs(span, id, binding, ThinVec::new()) + fn expr_ident(&mut self, span: Span, ident: Ident, binding: NodeId) -> hir::Expr { + self.expr_ident_with_attrs(span, ident, binding, ThinVec::new()) } fn expr_ident_with_attrs( &mut self, span: Span, - id: Name, + ident: Ident, binding: NodeId, attrs: ThinVec, ) -> hir::Expr { @@ -4356,7 +4356,7 @@ impl<'a> LoweringContext<'a> { P(hir::Path { span, def: Def::Local(binding), - segments: hir_vec![hir::PathSegment::from_name(id)], + segments: hir_vec![hir::PathSegment::from_ident(ident)], }), )); @@ -4438,7 +4438,7 @@ impl<'a> LoweringContext<'a> { &mut self, sp: Span, mutbl: bool, - ident: Name, + ident: Ident, ex: P, ) -> (hir::Stmt, NodeId) { let pat = if mutbl { @@ -4509,14 +4509,14 @@ impl<'a> LoweringContext<'a> { self.pat(span, pt) } - fn pat_ident(&mut self, span: Span, name: Name) -> P { - self.pat_ident_binding_mode(span, name, hir::BindingAnnotation::Unannotated) + fn pat_ident(&mut self, span: Span, ident: Ident) -> P { + self.pat_ident_binding_mode(span, ident, hir::BindingAnnotation::Unannotated) } fn pat_ident_binding_mode( &mut self, span: Span, - name: Name, + ident: Ident, bm: hir::BindingAnnotation, ) -> P { let LoweredNodeId { node_id, hir_id } = self.next_id(); @@ -4524,7 +4524,7 @@ impl<'a> LoweringContext<'a> { P(hir::Pat { id: node_id, hir_id, - node: hir::PatKind::Binding(bm, node_id, Spanned { span, node: name }, None), + node: hir::PatKind::Binding(bm, node_id, Spanned { span, node: ident.name }, None), span, }) } diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 3206c2fce2069..44c67b6e89a32 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -320,7 +320,7 @@ pub struct Path { impl Path { pub fn is_global(&self) -> bool { - !self.segments.is_empty() && self.segments[0].name == keywords::CrateRoot.name() + !self.segments.is_empty() && self.segments[0].ident.name == keywords::CrateRoot.name() } } @@ -341,7 +341,7 @@ impl fmt::Display for Path { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct PathSegment { /// The identifier portion of this path segment. - pub name: Name, + pub ident: Ident, /// Type/lifetime parameters attached to this path. They come in /// two flavors: `Path` and `Path(A,B) -> C`. Note that @@ -359,17 +359,17 @@ pub struct PathSegment { impl PathSegment { /// Convert an identifier to the corresponding segment. - pub fn from_name(name: Name) -> PathSegment { + pub fn from_ident(ident: Ident) -> PathSegment { PathSegment { - name, + ident, infer_types: true, args: None, } } - pub fn new(name: Name, args: GenericArgs, infer_types: bool) -> Self { + pub fn new(ident: Ident, args: GenericArgs, infer_types: bool) -> Self { PathSegment { - name, + ident, infer_types, args: if args.is_empty() { None diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 05ceb1fcfcdfe..dc1883aebd574 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -559,7 +559,7 @@ impl<'a> State<'a> { match kind { hir::UseKind::Single => { - if path.segments.last().unwrap().name != item.name { + if path.segments.last().unwrap().ident.name != item.name { self.s.space()?; self.word_space("as")?; self.print_name(item.name)?; @@ -845,7 +845,8 @@ impl<'a> State<'a> { hir::Visibility::Crate(ast::CrateSugar::PubCrate) => self.word_nbsp("pub(crate)")?, hir::Visibility::Restricted { ref path, .. } => { self.s.word("pub(")?; - if path.segments.len() == 1 && path.segments[0].name == keywords::Super.name() { + if path.segments.len() == 1 && + path.segments[0].ident.name == keywords::Super.name() { // Special case: `super` can print like `pub(super)`. self.s.word("super")?; } else { @@ -1266,7 +1267,7 @@ impl<'a> State<'a> { let base_args = &args[1..]; self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX)?; self.s.word(".")?; - self.print_name(segment.name)?; + self.print_ident(segment.ident)?; segment.with_generic_args(|generic_args| { if !generic_args.args.is_empty() || !generic_args.bindings.is_empty() { @@ -1634,9 +1635,9 @@ impl<'a> State<'a> { if i > 0 { self.s.word("::")? } - if segment.name != keywords::CrateRoot.name() && - segment.name != keywords::DollarCrate.name() { - self.print_name(segment.name)?; + if segment.ident.name != keywords::CrateRoot.name() && + segment.ident.name != keywords::DollarCrate.name() { + self.print_ident(segment.ident)?; segment.with_generic_args(|generic_args| { self.print_generic_args(generic_args, segment.infer_types, colons_before_params) @@ -1665,9 +1666,9 @@ impl<'a> State<'a> { if i > 0 { self.s.word("::")? } - if segment.name != keywords::CrateRoot.name() && - segment.name != keywords::DollarCrate.name() { - self.print_name(segment.name)?; + if segment.ident.name != keywords::CrateRoot.name() && + segment.ident.name != keywords::DollarCrate.name() { + self.print_ident(segment.ident)?; segment.with_generic_args(|generic_args| { self.print_generic_args(generic_args, segment.infer_types, @@ -1679,7 +1680,7 @@ impl<'a> State<'a> { self.s.word(">")?; self.s.word("::")?; let item_segment = path.segments.last().unwrap(); - self.print_name(item_segment.name)?; + self.print_ident(item_segment.ident)?; item_segment.with_generic_args(|generic_args| { self.print_generic_args(generic_args, item_segment.infer_types, @@ -1691,7 +1692,7 @@ impl<'a> State<'a> { self.print_type(qself)?; self.s.word(">")?; self.s.word("::")?; - self.print_name(item_segment.name)?; + self.print_ident(item_segment.ident)?; item_segment.with_generic_args(|generic_args| { self.print_generic_args(generic_args, item_segment.infer_types, diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index cad76c4100cda..feff4a5c27198 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -172,7 +172,7 @@ impl_stable_hash_for!(struct hir::Path { }); impl_stable_hash_for!(struct hir::PathSegment { - name, + ident, infer_types, args }); diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index 28e533054f0cb..70defbb0215d2 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -407,7 +407,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals { if path.segments.len() == 1 { NonUpperCaseGlobals::check_upper_case(cx, "constant in pattern", - path.segments[0].name, + path.segments[0].ident.name, path.span); } } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index de087049267b1..2aecbf32ec5a1 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -830,8 +830,8 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> { let is_local_static = if let Def::Static(..) = def { def_id.is_local() } else { false }; if !self.item_is_accessible(def_id) && !is_local_static { let name = match *qpath { - hir::QPath::Resolved(_, ref path) => format!("{}", path), - hir::QPath::TypeRelative(_, ref segment) => segment.name.to_string(), + hir::QPath::Resolved(_, ref path) => path.to_string(), + hir::QPath::TypeRelative(_, ref segment) => segment.ident.to_string(), }; let msg = format!("{} `{}` is private", def.kind_name(), name); self.tcx.sess.span_err(span, &msg); diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 2052918747b39..1437aa5fcc5d2 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1550,16 +1550,16 @@ impl<'a> Resolver<'a> { hir::Path { span, def: Def::Err, - segments: iter::once(keywords::CrateRoot.name()).chain({ - path_str.split("::").skip(1).map(Symbol::intern) - }).map(hir::PathSegment::from_name).collect(), + segments: iter::once(keywords::CrateRoot.ident()).chain({ + path_str.split("::").skip(1).map(Ident::from_str) + }).map(hir::PathSegment::from_ident).collect(), } } else { hir::Path { span, def: Def::Err, - segments: path_str.split("::").map(Symbol::intern) - .map(hir::PathSegment::from_name).collect(), + segments: path_str.split("::").map(Ident::from_str) + .map(hir::PathSegment::from_ident).collect(), } }; self.resolve_hir_path_cb(&mut path, is_value, |_, _, _| errored = true); @@ -1572,13 +1572,11 @@ impl<'a> Resolver<'a> { /// resolve_hir_path, but takes a callback in case there was an error fn resolve_hir_path_cb(&mut self, path: &mut hir::Path, is_value: bool, error_callback: F) - where F: for<'c, 'b> FnOnce(&'c mut Resolver, Span, ResolutionError<'b>) - { + where F: for<'c, 'b> FnOnce(&'c mut Resolver, Span, ResolutionError<'b>) + { let namespace = if is_value { ValueNS } else { TypeNS }; let hir::Path { ref segments, span, ref mut def } = *path; - let path: Vec = segments.iter() - .map(|seg| Ident::new(seg.name, span)) - .collect(); + let path: Vec<_> = segments.iter().map(|seg| seg.ident).collect(); // FIXME (Manishearth): Intra doc links won't get warned of epoch changes match self.resolve_path(&path, Some(namespace), true, span, CrateLint::No) { PathResult::Module(module) => *def = module.def().unwrap(), diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index e8094dc27042b..1954d81d32804 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -873,7 +873,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { -> (Ty<'tcx>, Def) { let tcx = self.tcx(); - let assoc_name = item_segment.name.to_ident(); + let assoc_name = item_segment.ident; debug!("associated_path_def_to_ty: {:?}::{}", ty, assoc_name); @@ -962,7 +962,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { self.report_ambiguous_associated_type(span, "Type", &path_str, - &item_segment.name.as_str()); + &item_segment.ident.as_str()); return tcx.types.err; }; diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 5b922af821cc2..2b619781119c5 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -226,7 +226,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { })), 1) = (self.tcx.hir.find(parent), decl.inputs.len()) { let self_ty = self.tables.borrow().node_id_to_type(expr[0].hir_id); let self_ty = format!("{:?}", self_ty); - let name = path.name.as_str(); + let name = path.ident.as_str(); let is_as_ref_able = ( self_ty.starts_with("&std::option::Option") || self_ty.starts_with("&std::result::Result") || diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index feb99f4b5938a..e160ceec1ee34 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -120,7 +120,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { allow_private: bool) -> bool { let mode = probe::Mode::MethodCall; - match self.probe_for_name(method_name.span, mode, method_name.name, + match self.probe_for_name(method_name.span, mode, method_name, IsSuggestion(false), self_ty, call_expr_id, ProbeScope::TraitsInScope) { Ok(..) => true, @@ -157,14 +157,14 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { self_expr: &'gcx hir::Expr) -> Result, MethodError<'tcx>> { debug!("lookup(method_name={}, self_ty={:?}, call_expr={:?}, self_expr={:?})", - segment.name, + segment.ident, self_ty, call_expr, self_expr); let pick = self.lookup_probe( span, - segment.name, + segment.ident, self_ty, call_expr, ProbeScope::TraitsInScope @@ -192,7 +192,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // We probe again, taking all traits into account (not only those in scope). let candidates = match self.lookup_probe(span, - segment.name, + segment.ident, self_ty, call_expr, ProbeScope::AllTraits) { @@ -222,7 +222,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { fn lookup_probe(&self, span: Span, - method_name: ast::Name, + method_name: ast::Ident, self_ty: Ty<'tcx>, call_expr: &'gcx hir::Expr, scope: ProbeScope) @@ -289,7 +289,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // Trait must have a method named `m_name` and it should not have // type parameters or early-bound regions. let tcx = self.tcx; - let method_item = self.associated_item(trait_def_id, m_name, Namespace::Value).unwrap(); + let method_item = + self.associated_item(trait_def_id, m_name.to_ident(), Namespace::Value).unwrap(); let def_id = method_item.def_id; let generics = tcx.generics_of(def_id); assert_eq!(generics.params.len(), 0); @@ -362,7 +363,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn resolve_ufcs(&self, span: Span, - method_name: ast::Name, + method_name: ast::Ident, self_ty: Ty<'tcx>, expr_id: ast::NodeId) -> Result> { @@ -385,11 +386,11 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { /// Find item with name `item_name` defined in impl/trait `def_id` /// and return it, or `None`, if no such item was defined there. - pub fn associated_item(&self, def_id: DefId, item_name: ast::Name, ns: Namespace) + pub fn associated_item(&self, def_id: DefId, item_name: ast::Ident, ns: Namespace) -> Option { self.tcx.associated_items(def_id).find(|item| { Namespace::from(item.kind) == ns && - self.tcx.hygienic_eq(item_name.to_ident(), item.name.to_ident(), def_id) + self.tcx.hygienic_eq(item_name, item.name.to_ident(), def_id) }) } } diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 834c7d4e9e391..ccbc0f9cfe24d 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -47,7 +47,7 @@ struct ProbeContext<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> { fcx: &'a FnCtxt<'a, 'gcx, 'tcx>, span: Span, mode: Mode, - method_name: Option, + method_name: Option, return_type: Option>, steps: Rc>>, inherent_candidates: Vec>, @@ -213,7 +213,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn probe_for_name(&self, span: Span, mode: Mode, - item_name: ast::Name, + item_name: ast::Ident, is_suggestion: IsSuggestion, self_ty: Ty<'tcx>, scope_expr_id: ast::NodeId, @@ -237,7 +237,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { fn probe_op(&'a self, span: Span, mode: Mode, - method_name: Option, + method_name: Option, return_type: Option>, is_suggestion: IsSuggestion, self_ty: Ty<'tcx>, @@ -382,7 +382,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> { fn new(fcx: &'a FnCtxt<'a, 'gcx, 'tcx>, span: Span, mode: Mode, - method_name: Option, + method_name: Option, return_type: Option>, steps: Rc>>, is_suggestion: IsSuggestion) @@ -422,8 +422,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> { { let is_accessible = if let Some(name) = self.method_name { let item = candidate.item; - let def_scope = - self.tcx.adjust_ident(name.to_ident(), item.container.id(), self.body_id).1; + let def_scope = self.tcx.adjust_ident(name, item.container.id(), self.body_id).1; item.vis.is_accessible_from(def_scope, self.tcx) } else { true @@ -799,7 +798,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> { Ok(()) } - fn candidate_method_names(&self) -> Vec { + fn candidate_method_names(&self) -> Vec { let mut set = FxHashSet(); let mut names: Vec<_> = self.inherent_candidates .iter() @@ -811,7 +810,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> { true } }) - .map(|candidate| candidate.item.name) + .map(|candidate| candidate.item.name.to_ident()) .filter(|&name| set.insert(name)) .collect(); diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 546ce34fe12ae..f6c66a9a14aa8 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -77,7 +77,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn report_method_error(&self, span: Span, rcvr_ty: Ty<'tcx>, - item_name: ast::Name, + item_name: ast::Ident, rcvr_expr: Option<&hir::Expr>, error: MethodError<'tcx>, args: Option<&'gcx [hir::Expr]>) { @@ -340,8 +340,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { match ty.sty { ty::TyAdt(def, substs) if !def.is_enum() => { let variant = &def.non_enum_variant(); - if let Some(index) = - self.tcx.find_field_index(item_name.to_ident(), variant) { + if let Some(index) = self.tcx.find_field_index(item_name, variant) { let field = &variant.fields[index]; let snippet = tcx.sess.codemap().span_to_snippet(expr.span); let expr_string = match snippet { @@ -393,7 +392,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { report_function!(expr.span, expr_string); } else if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = expr.node { if let Some(segment) = path.segments.last() { - report_function!(expr.span, segment.name); + report_function!(expr.span, segment.ident); } } } @@ -565,7 +564,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { err: &mut DiagnosticBuilder, span: Span, rcvr_ty: Ty<'tcx>, - item_name: ast::Name, + item_name: ast::Ident, rcvr_expr: Option<&hir::Expr>, valid_out_of_scope_traits: Vec) { if self.suggest_valid_traits(err, valid_out_of_scope_traits) { diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 82df956b54ddf..0b590e1110f59 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -3006,10 +3006,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { Ok(method) } Err(error) => { - if segment.name != keywords::Invalid.name() { + if segment.ident.name != keywords::Invalid.name() { self.report_method_error(span, rcvr_t, - segment.name, + segment.ident, Some(rcvr), error, Some(args)); @@ -4254,7 +4254,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // errors with default match binding modes. See #44614. return (*cached_def, Some(ty), slice::from_ref(&**item_segment)) } - let item_name = item_segment.name; + let item_name = item_segment.ident; let def = match self.resolve_ufcs(span, item_name, ty, node_id) { Ok(def) => def, Err(error) => { @@ -4262,7 +4262,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { method::MethodError::PrivateMatch(def, _) => def, _ => Def::Err, }; - if item_name != keywords::Invalid.name() { + if item_name.name != keywords::Invalid.name() { self.report_method_error(span, ty, item_name, None, error, None); } def diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index dd86554bec431..35483e33c474f 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -200,10 +200,10 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> { let mut segments = path.segments.into_vec(); let last = segments.pop().unwrap(); - let real_name = name.map(|name| Symbol::intern(&name)); + let real_name = name.map(|name| Ident::from_str(&name)); segments.push(hir::PathSegment::new( - real_name.unwrap_or(last.name), + real_name.unwrap_or(last.ident), self.generics_to_path_params(generics.clone()), false, )); @@ -285,7 +285,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> { span: DUMMY_SP, def: Def::TyParam(param.def_id), segments: HirVec::from_vec(vec![ - hir::PathSegment::from_name(param.name.as_symbol()) + hir::PathSegment::from_ident(Ident::from_interned_str(param.name)) ]), }), )), diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 3a1390bb3c24f..664a603920cb4 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2949,7 +2949,7 @@ impl Clean for hir::Ty { segments: segments.into(), }; Type::QPath { - name: p.segments.last().unwrap().name.clean(cx), + name: p.segments.last().unwrap().ident.name.clean(cx), self_type: box qself.clean(cx), trait_: box resolve_type(cx, trait_path.clean(cx), self.id) } @@ -2966,7 +2966,7 @@ impl Clean for hir::Ty { segments: vec![].into(), }; Type::QPath { - name: segment.name.clean(cx), + name: segment.ident.name.clean(cx), self_type: box qself.clean(cx), trait_: box resolve_type(cx, trait_path.clean(cx), self.id) } @@ -3575,7 +3575,7 @@ pub struct PathSegment { impl Clean for hir::PathSegment { fn clean(&self, cx: &DocContext) -> PathSegment { PathSegment { - name: self.name.clean(cx), + name: self.ident.name.clean(cx), args: self.with_generic_args(|generic_args| generic_args.clean(cx)) } } @@ -3628,7 +3628,7 @@ fn strip_path(path: &Path) -> Path { fn qpath_to_string(p: &hir::QPath) -> String { let segments = match *p { hir::QPath::Resolved(_, ref path) => &path.segments, - hir::QPath::TypeRelative(_, ref segment) => return segment.name.to_string(), + hir::QPath::TypeRelative(_, ref segment) => return segment.ident.to_string(), }; let mut s = String::new(); @@ -3636,8 +3636,8 @@ fn qpath_to_string(p: &hir::QPath) -> String { if i > 0 { s.push_str("::"); } - if seg.name != keywords::CrateRoot.name() { - s.push_str(&*seg.name.as_str()); + if seg.ident.name != keywords::CrateRoot.name() { + s.push_str(&*seg.ident.as_str()); } } s @@ -4427,7 +4427,7 @@ where F: Fn(DefId) -> Def { span: DUMMY_SP, def: def_ctor(def_id), segments: hir::HirVec::from_vec(apb.names.iter().map(|s| hir::PathSegment { - name: ast::Name::intern(&s), + ident: ast::Ident::from_str(&s), args: None, infer_types: false, }).collect()) From c6ca1e4abdb9476d8aa68457414ef80c5249caee Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 10 Jun 2018 19:33:30 +0300 Subject: [PATCH 4/8] 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. --- src/librustc/hir/intravisit.rs | 18 ++++---- src/librustc/hir/lowering.rs | 18 ++++---- src/librustc/hir/map/mod.rs | 4 +- src/librustc/hir/mod.rs | 14 +++--- src/librustc/hir/pat_util.rs | 23 +++------- src/librustc/hir/print.rs | 28 ++++++------ src/librustc/ich/impls_hir.rs | 4 +- .../infer/error_reporting/need_type_info.rs | 4 +- .../nice_region_error/different_lifetimes.rs | 8 ++-- .../nice_region_error/named_anon_conflict.rs | 6 +-- src/librustc/middle/liveness.rs | 21 ++++----- src/librustc/middle/resolve_lifetime.rs | 45 +++++++++---------- .../borrowck/gather_loans/gather_moves.rs | 4 +- src/librustc_borrowck/borrowck/unused.rs | 8 ++-- src/librustc_lint/bad_style.rs | 12 ++--- src/librustc_lint/builtin.rs | 12 ++--- src/librustc_metadata/encoder.rs | 12 +++-- src/librustc_mir/build/mod.rs | 8 ++-- src/librustc_mir/hair/pattern/check_match.rs | 6 +-- src/librustc_mir/hair/pattern/mod.rs | 6 +-- src/librustc_typeck/check/mod.rs | 6 +-- src/librustc_typeck/collect.rs | 6 +-- src/librustdoc/clean/mod.rs | 6 +-- src/libsyntax/parse/parser.rs | 2 +- 24 files changed, 125 insertions(+), 156 deletions(-) diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index 29507474aa1ee..61583d998940b 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 5a0e9c36b910a..49675f6dc080d 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