.iter()
.filter_map(|param| match param.kind {
ty::GenericParamDefKind::Lifetime => Some(param.name.to_string()),
- _ => None
+ _ => None,
})
.collect();
&Err(SelectionError::Unimplemented) => {
if self.is_of_param(pred.skip_binder().trait_ref.substs) {
already_visited.remove(&pred);
- self.add_user_pred(&mut user_computed_preds,
- ty::Predicate::Trait(pred.clone()));
+ self.add_user_pred(
+ &mut user_computed_preds,
+ ty::Predicate::Trait(pred.clone()),
+ );
predicates.push_back(pred);
} else {
debug!(
// under which a type implements an auto trait. A trait predicate involving
// a HRTB means that the type needs to work with any choice of lifetime,
// not just one specific lifetime (e.g. 'static).
- fn add_user_pred<'c>(&self, user_computed_preds: &mut FxHashSet<ty::Predicate<'c>>,
- new_pred: ty::Predicate<'c>) {
+ fn add_user_pred<'c>(
+ &self,
+ user_computed_preds: &mut FxHashSet<ty::Predicate<'c>>,
+ new_pred: ty::Predicate<'c>,
+ ) {
let mut should_add_new = true;
user_computed_preds.retain(|&old_pred| {
match (&new_pred, old_pred) {
if !new_substs.types().eq(old_substs.types()) {
// We can't compare lifetimes if the types are different,
// so skip checking old_pred
- return true
+ return true;
}
- for (new_region, old_region) in new_substs
- .regions()
- .zip(old_substs.regions()) {
-
+ for (new_region, old_region) in
+ new_substs.regions().zip(old_substs.regions())
+ {
match (new_region, old_region) {
// If both predicates have an 'ReLateBound' (a HRTB) in the
// same spot, we do nothing
(
ty::RegionKind::ReLateBound(_, _),
- ty::RegionKind::ReLateBound(_, _)
- ) => {},
+ ty::RegionKind::ReLateBound(_, _),
+ ) => {}
(ty::RegionKind::ReLateBound(_, _), _) => {
// The new predicate has a HRTB in a spot where the old
// so we return 'false' to remove the old predicate from
// user_computed_preds
return false;
- },
+ }
(_, ty::RegionKind::ReLateBound(_, _)) => {
// This is the opposite situation as the previous arm - the
// old predicate has a HRTB lifetime in a place where the
}
}
}
- },
+ }
_ => {}
}
- return true
+ return true;
});
if should_add_new {
match constraint {
&Constraint::VarSubVar(r1, r2) => {
{
- let deps1 = vid_map
- .entry(RegionTarget::RegionVid(r1))
- .or_default();
+ let deps1 = vid_map.entry(RegionTarget::RegionVid(r1)).or_default();
deps1.larger.insert(RegionTarget::RegionVid(r2));
}
- let deps2 = vid_map
- .entry(RegionTarget::RegionVid(r2))
- .or_default();
+ let deps2 = vid_map.entry(RegionTarget::RegionVid(r2)).or_default();
deps2.smaller.insert(RegionTarget::RegionVid(r1));
}
&Constraint::RegSubVar(region, vid) => {
{
- let deps1 = vid_map
- .entry(RegionTarget::Region(region))
- .or_default();
+ let deps1 = vid_map.entry(RegionTarget::Region(region)).or_default();
deps1.larger.insert(RegionTarget::RegionVid(vid));
}
- let deps2 = vid_map
- .entry(RegionTarget::RegionVid(vid))
- .or_default();
+ let deps2 = vid_map.entry(RegionTarget::RegionVid(vid)).or_default();
deps2.smaller.insert(RegionTarget::Region(region));
}
&Constraint::VarSubReg(vid, region) => {
}
&Constraint::RegSubReg(r1, r2) => {
{
- let deps1 = vid_map
- .entry(RegionTarget::Region(r1))
- .or_default();
+ let deps1 = vid_map.entry(RegionTarget::Region(r1)).or_default();
deps1.larger.insert(RegionTarget::Region(r2));
}
- let deps2 = vid_map
- .entry(RegionTarget::Region(r2))
- .or_default();
+ let deps2 = vid_map.entry(RegionTarget::Region(r2)).or_default();
deps2.smaller.insert(RegionTarget::Region(r1));
}
}
}
}
&ty::Predicate::RegionOutlives(ref binder) => {
- if select.infcx().region_outlives_predicate(&dummy_cause, binder).is_err() {
+ if select
+ .infcx()
+ .region_outlives_predicate(&dummy_cause, binder)
+ .is_err()
+ {
return false;
}
}