pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v GenericParam) {
visitor.visit_id(param.id);
match param.kind {
- GenericParamKind::Lifetime { ref bounds, ref lifetime_deprecated, .. } => {
- match lifetime_deprecated.name {
+ GenericParamKind::Lifetime { ref bounds, ref lifetime, .. } => {
+ match lifetime.name {
LifetimeName::Name(name) => {
visitor.visit_name(param.span, name);
}
name: hir_name,
bounds: vec![].into(),
in_band: true,
- lifetime_deprecated: hir::Lifetime {
+ lifetime: hir::Lifetime {
id: def_node_id,
span,
name: hir_name,
name,
bounds: vec![].into(),
in_band: false,
- lifetime_deprecated: hir::Lifetime {
+ lifetime: hir::Lifetime {
id: def_node_id,
span: lifetime.span,
name,
itctx: ImplTraitContext)
-> hir::GenericParam {
match param.kind {
- GenericParamKind::Lifetime { ref bounds, ref lifetime, .. } => {
+ GenericParamKind::Lifetime { ref bounds, ref lifetime } => {
let was_collecting_in_band = self.is_collecting_in_band_lifetimes;
self.is_collecting_in_band_lifetimes = false;
name: lifetime.name,
bounds: bounds.iter().map(|lt| self.lower_lifetime(lt)).collect(),
in_band: false,
- lifetime_deprecated: lifetime,
+ lifetime,
}
};
// `fn foo(x: &'a u8) -> &'a u8 { x }`
in_band: bool,
// We keep a `Lifetime` around for now just so we can `visit_lifetime`.
- lifetime_deprecated: Lifetime,
+ lifetime: Lifetime,
},
Type {
name: Name,
mem::discriminant(self).hash_stable(hcx, hasher);
match self {
hir::GenericParamKind::Lifetime { name, ref bounds, in_band,
- ref lifetime_deprecated } => {
+ ref lifetime } => {
name.hash_stable(hcx, hasher);
bounds.hash_stable(hcx, hasher);
in_band.hash_stable(hcx, hasher);
- lifetime_deprecated.hash_stable(hcx, hasher);
+ lifetime.hash_stable(hcx, hasher);
}
hir::GenericParamKind::Type { name, ref bounds, ref default, synthetic, attrs } => {
name.hash_stable(hcx, hasher);
.map(|set| match *set {
Set1::Empty => "BaseDefault".to_string(),
Set1::One(Region::Static) => "'static".to_string(),
- Set1::One(Region::EarlyBound(i, _, _)) => {
- let mut j = 0;
- generics.params.iter().find(|param| match param.kind {
+ Set1::One(Region::EarlyBound(mut i, _, _)) => {
+ generics.params.iter().find_map(|param| match param.kind {
GenericParamKind::Lifetime { .. } => {
- if i == j {
- return true;
+ if i == 0 {
+ return Some(param.name().to_string());
}
- j += 1;
- false
+ i -= 1;
+ None
}
- _ => false,
+ _ => None,
}).unwrap()
- .name()
- .to_string()
}
Set1::One(_) => bug!(),
Set1::Many => "Ambiguous".to_string(),
let substs = Substs::for_item(tcx, def_id, |param, substs| {
match param.kind {
GenericParamDefKind::Lifetime => {
- let i = param.index as usize - own_self;
- let mut j = 0;
+ let mut i = param.index as usize - own_self;
for arg in &generic_args.args {
match arg {
GenericArg::Lifetime(lt) => {
- if i == j {
+ if i == 0 {
return self.ast_region_to_region(lt, Some(param)).into();
}
- j += 1;
+ i -= 1;
}
_ => {}
}
return ty.into();
}
- let i = i - (lt_accepted + own_self);
+ let mut i = i - (lt_accepted + own_self);
if i < ty_provided {
// A provided type parameter.
- let mut j = 0;
for arg in &generic_args.args {
match arg {
GenericArg::Type(ty) => {
- if i == j {
+ if i == 0 {
return self.ast_ty_to_ty(ty).into();
}
- j += 1;
+ i -= 1;
}
_ => {}
}
let provided = &segment.args;
let own_counts = method_generics.own_counts();
Substs::for_item(self.tcx, pick.item.def_id, |param, _| {
- let i = param.index as usize;
+ let mut i = param.index as usize;
if i < parent_substs.len() {
parent_substs[i]
} else {
match param.kind {
GenericParamDefKind::Lifetime => {
if let Some(lifetime) = provided.as_ref().and_then(|data| {
- let mut j = 0;
for arg in &data.args {
match arg {
GenericArg::Lifetime(lt) => {
- if i - parent_substs.len() == j {
+ if i == parent_substs.len() {
return Some(lt);
}
- j += 1;
+ i -= 1;
}
_ => {}
}
}
GenericParamDefKind::Type {..} => {
if let Some(ast_ty) = provided.as_ref().and_then(|data| {
- let mut j = 0;
for arg in &data.args {
match arg {
GenericArg::Type(ty) => {
- if i - parent_substs.len() - own_counts.lifetimes == j {
+ if i == parent_substs.len() + own_counts.lifetimes {
return Some(ty);
}
- j += 1;
+ i -= 1;
}
_ => {}
}
pub fn walk_generic_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a GenericParam) {
match param.kind {
- GenericParamKind::Lifetime { ref bounds, ref lifetime, .. } => {
+ GenericParamKind::Lifetime { ref bounds, ref lifetime } => {
visitor.visit_ident(param.ident);
walk_list!(visitor, visit_lifetime, bounds);
walk_list!(visitor, visit_attribute, param.attrs.iter());
}
- GenericParamKind::Type { ref bounds, ref default, .. } => {
+ GenericParamKind::Type { ref bounds, ref default } => {
visitor.visit_ident(t.ident);
walk_list!(visitor, visit_ty_param_bound, bounds);
walk_list!(visitor, visit_ty, default);