From c4e8e718807d1925769bdcdd055c6d8de05f20ce Mon Sep 17 00:00:00 2001 From: varkor Date: Mon, 28 May 2018 14:55:23 +0100 Subject: [PATCH] Lift name into GenericParam --- src/librustc/hir/lowering.rs | 24 ++++++++++---------- src/librustc/hir/map/mod.rs | 4 ++-- src/librustc/hir/mod.rs | 15 ++----------- src/librustc/hir/print.rs | 2 +- src/librustc/ich/impls_hir.rs | 8 +++---- src/librustc/middle/resolve_lifetime.rs | 30 ++++++++++++------------- src/librustc_lint/bad_style.rs | 4 ++-- src/librustc_typeck/check/mod.rs | 2 +- src/librustc_typeck/check/wfcheck.rs | 2 +- src/librustc_typeck/collect.rs | 13 +++++------ src/librustdoc/clean/mod.rs | 10 ++++----- 11 files changed, 51 insertions(+), 63 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index fed4f150075b..d0a3f0d097fd 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -699,11 +699,12 @@ impl<'a> LoweringContext<'a> { hir::GenericParam { id: def_node_id, + name: hir_name.name(), span, pure_wrt_drop: false, bounds: vec![].into(), kind: hir::GenericParamKind::Lifetime { - name: hir_name, + lt_name: hir_name, in_band: true, lifetime: hir::Lifetime { id: def_node_id, @@ -734,10 +735,7 @@ impl<'a> LoweringContext<'a> { let hir_name = hir::LifetimeName::Name(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 == hir_name) { return; } @@ -788,7 +786,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()), + hir::GenericParamKind::Lifetime { .. } => Some(param.name), _ => None, }); self.in_scope_lifetimes.extend(lt_def_names); @@ -1251,11 +1249,11 @@ impl<'a> LoweringContext<'a> { let name = Symbol::intern(&pprust::ty_to_string(t)); self.in_band_ty_params.push(hir::GenericParam { id: def_node_id, + name, span, pure_wrt_drop: false, bounds: hir_bounds, kind: hir::GenericParamKind::Type { - name, default: None, synthetic: Some(hir::SyntheticTyParamKind::ImplTrait), attrs: P::new(), @@ -1366,10 +1364,10 @@ impl<'a> LoweringContext<'a> { fn visit_generic_param(&mut self, param: &'v hir::GenericParam) { // Record the introduction of 'a in `for<'a> ...` - if let hir::GenericParamKind::Lifetime { name, .. } = param.kind { + if let hir::GenericParamKind::Lifetime { lt_name, .. } = param.kind { // Introduce lifetimes one at a time so that we can handle // cases like `fn foo<'d>() -> impl for<'a, 'b: 'a, 'c: 'b + 'd>` - self.currently_bound_lifetimes.push(name); + self.currently_bound_lifetimes.push(lt_name); } hir::intravisit::walk_generic_param(self, param); @@ -1418,11 +1416,12 @@ impl<'a> LoweringContext<'a> { self.output_lifetime_params.push(hir::GenericParam { id: def_node_id, + name: name.name(), span: lifetime.span, pure_wrt_drop: false, bounds: vec![].into(), kind: hir::GenericParamKind::Lifetime { - name, + lt_name: name, in_band: false, lifetime: hir::Lifetime { id: def_node_id, @@ -1955,11 +1954,12 @@ impl<'a> LoweringContext<'a> { let lifetime = self.lower_lifetime(lifetime); let param = hir::GenericParam { id: lifetime.id, + name: lifetime.name.name(), span: lifetime.span, pure_wrt_drop: attr::contains_name(¶m.attrs, "may_dangle"), bounds, kind: hir::GenericParamKind::Lifetime { - name: lifetime.name, + lt_name: lifetime.name, in_band: false, lifetime, } @@ -1988,11 +1988,11 @@ impl<'a> LoweringContext<'a> { hir::GenericParam { id: self.lower_node_id(param.id).node_id, + name, span: param.ident.span, pure_wrt_drop: attr::contains_name(¶m.attrs, "may_dangle"), bounds, kind: hir::GenericParamKind::Type { - name, default: default.as_ref().map(|x| { self.lower_ty(x, ImplTraitContext::Disallowed) }), diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index cb93c7e70d17..999103980625 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -616,7 +616,7 @@ impl<'hir> Map<'hir> { NodeItem(&Item { node: ItemTrait(..), .. }) => { keywords::SelfType.name() } - NodeGenericParam(param) => param.name(), + NodeGenericParam(param) => param.name, _ => { bug!("ty_param_name: {} not a type parameter", self.node_to_string(id)) @@ -957,7 +957,7 @@ impl<'hir> Map<'hir> { NodeVariant(v) => v.node.name, NodeField(f) => f.ident.name, NodeLifetime(lt) => lt.name.name(), - NodeGenericParam(param) => param.name(), + NodeGenericParam(param) => param.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 8249b306a0c3..b4470ed7c1eb 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -424,8 +424,6 @@ pub enum TraitBoundModifier { Maybe, } -pub type Outlives = Lifetime; - /// The AST represents all type param bounds as types. /// typeck::collect::compute_bounds matches these against /// the "special" built-in traits (see middle::lang_items) and @@ -451,7 +449,7 @@ pub type ParamBounds = HirVec; pub enum GenericParamKind { /// A lifetime definition, eg `'a: 'b + 'c + 'd`. Lifetime { - name: LifetimeName, + lt_name: LifetimeName, // Indicates that the lifetime definition was synthetically added // as a result of an in-band lifetime usage like: // `fn foo(x: &'a u8) -> &'a u8 { x }` @@ -460,7 +458,6 @@ pub enum GenericParamKind { lifetime: Lifetime, }, Type { - name: Name, default: Option>, synthetic: Option, attrs: HirVec, @@ -470,6 +467,7 @@ pub enum GenericParamKind { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct GenericParam { pub id: NodeId, + pub name: Name, pub bounds: ParamBounds, pub span: Span, pub pure_wrt_drop: bool, @@ -477,15 +475,6 @@ pub struct GenericParam { pub kind: GenericParamKind, } -impl GenericParam { - pub fn name(&self) -> Name { - match self.kind { - GenericParamKind::Lifetime { name, .. } => name.name(), - GenericParamKind::Type { name, .. } => name, - } - } -} - pub struct GenericParamCount { pub lifetimes: usize, pub types: usize, diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 10cecdb2d47a..a4cbd6515955 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -2115,7 +2115,7 @@ impl<'a> State<'a> { } pub fn print_generic_param(&mut self, param: &GenericParam) -> io::Result<()> { - self.print_name(param.name())?; + self.print_name(param.name)?; match param.kind { GenericParamKind::Lifetime { .. } => { let mut sep = ":"; diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index f8da828d2c3b..0c31134ae9cb 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -196,6 +196,7 @@ impl_stable_hash_for!(enum hir::TraitBoundModifier { impl_stable_hash_for!(struct hir::GenericParam { id, + name, span, pure_wrt_drop, bounds, @@ -208,13 +209,12 @@ impl<'a> HashStable> for hir::GenericParamKind { hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match self { - hir::GenericParamKind::Lifetime { name, in_band, ref lifetime } => { - name.hash_stable(hcx, hasher); + hir::GenericParamKind::Lifetime { lt_name, in_band, ref lifetime } => { + lt_name.hash_stable(hcx, hasher); in_band.hash_stable(hcx, hasher); lifetime.hash_stable(hcx, hasher); } - hir::GenericParamKind::Type { name, ref default, synthetic, attrs } => { - name.hash_stable(hcx, hasher); + hir::GenericParamKind::Type { ref default, synthetic, attrs } => { default.hash_stable(hcx, hasher); synthetic.hash_stable(hcx, hasher); attrs.hash_stable(hcx, hasher); diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index fc160b35ae49..cc39456c2fe3 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -84,13 +84,13 @@ pub enum Region { fn new_region(hir_map: &Map, param: &hir::GenericParam) -> (hir::LifetimeName, DefId, LifetimeDefOrigin) { let def_id = hir_map.local_def_id(param.id); - let (name, origin) = match param.kind { - GenericParamKind::Lifetime { name, in_band, .. } => { - (name, LifetimeDefOrigin::from_is_in_band(in_band)) + let (lt_name, origin) = match param.kind { + GenericParamKind::Lifetime { lt_name, in_band, .. } => { + (lt_name, LifetimeDefOrigin::from_is_in_band(in_band)) } _ => bug!("expected a lifetime param"), }; - (name, def_id, origin) + (lt_name, def_id, origin) } impl Region { @@ -1222,7 +1222,7 @@ fn compute_object_lifetime_defaults( generics.params.iter().find_map(|param| match param.kind { GenericParamKind::Lifetime { .. } => { if i == 0 { - return Some(param.name().to_string()); + return Some(param.name.to_string()); } i -= 1; None @@ -1299,8 +1299,8 @@ fn object_lifetime_defaults_for_item( Set1::One(Region::Static) } else { generics.params.iter().filter_map(|param| match param.kind { - GenericParamKind::Lifetime { name, in_band, .. } => { - Some((param.id, name, in_band)) + GenericParamKind::Lifetime { lt_name, in_band, .. } => { + Some((param.id, lt_name, in_band)) } _ => None, }) @@ -2237,7 +2237,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { fn check_lifetime_params(&mut self, old_scope: ScopeRef, params: &'tcx [hir::GenericParam]) { let lifetimes: Vec<_> = params.iter().filter_map(|param| match param.kind { - GenericParamKind::Lifetime { name, .. } => Some((param, name)), + GenericParamKind::Lifetime { lt_name, .. } => Some((param, lt_name)), _ => None, }).collect(); for (i, (lifetime_i, lifetime_i_name)) in lifetimes.iter().enumerate() { @@ -2271,7 +2271,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { lifetime_j.span, E0263, "lifetime name `{}` declared twice in the same scope", - lifetime_j.name() + lifetime_j.name ).span_label(lifetime_j.span, "declared twice") .span_label(lifetime_i.span, "previous declaration here") .emit(); @@ -2302,13 +2302,13 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { lifetime_i.span.to(lt.span), &format!( "unnecessary lifetime parameter `{}`", - lifetime_i.name() + lifetime_i.name ), ) .help(&format!( "you can use the `'static` lifetime directly, in place \ of `{}`", - lifetime_i.name() + lifetime_i.name )) .emit(); } @@ -2331,7 +2331,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { ) { for &(label, label_span) in &self.labels_in_fn { // FIXME (#24278): non-hygienic comparison - if param.name() == label { + if param.name == label { signal_shadowing_problem( self.tcx, label, @@ -2343,7 +2343,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { } let name = match param.kind { - GenericParamKind::Lifetime { name, .. } => name, + GenericParamKind::Lifetime { lt_name, .. } => lt_name, _ => bug!("expected lifetime param"), }; @@ -2367,7 +2367,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { signal_shadowing_problem( self.tcx, - param.name(), + param.name, original_lifetime(self.tcx.hir.span(node_id)), shadower_lifetime(¶m), ); @@ -2539,7 +2539,7 @@ fn insert_late_bound_lifetimes( // - are not implicitly captured by `impl Trait` for param in &generics.params { let name = match param.kind { - GenericParamKind::Lifetime { name, .. } => name, + GenericParamKind::Lifetime { lt_name, .. } => lt_name, _ => continue, }; diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index f456ab367998..aeeb812dd77d 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -151,7 +151,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCamelCaseTypes { GenericParamKind::Lifetime { .. } => {} GenericParamKind::Type { synthetic, .. } => { if synthetic.is_none() { - self.check_case(cx, "type parameter", param.name(), param.span); + self.check_case(cx, "type parameter", param.name, param.span); } } } @@ -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 { .. } => { - self.check_snake_case(cx, "lifetime", ¶m.name().as_str(), Some(param.span)); + self.check_snake_case(cx, "lifetime", ¶m.name.as_str(), Some(param.span)); } GenericParamKind::Type { .. } => {} } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 036c0aa442e5..9ff400d013bf 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -5195,7 +5195,7 @@ pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, for (&used, param) in types_used.iter().zip(types) { if !used { struct_span_err!(tcx.sess, param.span, E0091, "type parameter `{}` is unused", - param.name()) + param.name) .span_label(param.span, "unused type parameter") .emit(); } diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index f8f012627908..9df8502461cc 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 = &ast_generics.params[index]; - report_bivariance(tcx, param.span, param.name()); + report_bivariance(tcx, param.span, param.name); } } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index c2b52e0de752..d53efe146000 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().as_interned_str(), + name: param.name.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, @@ -914,9 +914,8 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let mut i = 0; params.extend(ast_generics.params.iter().filter_map(|param| match param.kind { GenericParamKind::Type { ref default, synthetic, .. } => { - if param.name() == keywords::SelfType.name() { - span_bug!(param.span, - "`Self` should not be the name of a regular parameter"); + if param.name == keywords::SelfType.name() { + span_bug!(param.span, "`Self` should not be the name of a regular parameter"); } if !allow_defaults && default.is_some() { @@ -932,7 +931,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let ty_param = ty::GenericParamDef { index: type_start + i as u32, - name: param.name().as_interned_str(), + name: param.name.as_interned_str(), def_id: tcx.hir.local_def_id(param.id), pure_wrt_drop: param.pure_wrt_drop, kind: ty::GenericParamDefKind::Type { @@ -1438,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().as_interned_str(), + name: param.name.as_interned_str(), })); index += 1; @@ -1462,7 +1461,7 @@ pub fn explicit_predicates_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, for param in &ast_generics.params { match param.kind { GenericParamKind::Type { .. } => { - let param_ty = ty::ParamTy::new(index, param.name().as_interned_str()).to_ty(tcx); + let param_ty = ty::ParamTy::new(index, param.name.as_interned_str()).to_ty(tcx); index += 1; let sized = SizedByDefault::Yes; diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 2f48267579a6..cea29ab30dfe 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1678,13 +1678,13 @@ impl Clean for hir::GenericParam { _ => panic!(), }); let name = bounds.next().unwrap().name.name(); - let mut s = format!("{}: {}", self.name(), name); + let mut s = format!("{}: {}", self.name, name); for bound in bounds { s.push_str(&format!(" + {}", bound.name.name())); } Lifetime(s) } else { - Lifetime(self.name().to_string()) + Lifetime(self.name.to_string()) } } _ => panic!(), @@ -1897,18 +1897,18 @@ impl Clean for hir::GenericParam { _ => panic!(), }); let name = bounds.next().unwrap().name.name(); - let mut s = format!("{}: {}", self.name(), name); + let mut s = format!("{}: {}", self.name, name); for bound in bounds { s.push_str(&format!(" + {}", bound.name.name())); } s } else { - self.name().to_string() + self.name.to_string() }; (name, GenericParamDefKind::Lifetime) } hir::GenericParamKind::Type { ref default, synthetic, .. } => { - (self.name().clean(cx), GenericParamDefKind::Type { + (self.name.clean(cx), GenericParamDefKind::Type { did: cx.tcx.hir.local_def_id(self.id), bounds: self.bounds.clean(cx), default: default.clean(cx),