FalseEdges {
/// The target normal control flow will take
real_target: BasicBlock,
- /// The list of blocks control flow could conceptually take, but won't
+ /// A block control flow could conceptually take, but won't
/// in practice
- imaginary_targets: Vec<BasicBlock>,
+ imaginary_target: BasicBlock,
},
/// A terminator for blocks that only take one path in reality, but where we
/// reserve the right to unwind in borrowck, even if it won't happen in practice.
SwitchInt { ref targets, .. } => None.into_iter().chain(&targets[..]),
FalseEdges {
ref real_target,
- ref imaginary_targets,
- } => Some(real_target).into_iter().chain(&imaginary_targets[..]),
+ ref imaginary_target,
+ } => Some(real_target).into_iter().chain(slice::from_ref(imaginary_target)),
}
}
} => None.into_iter().chain(&mut targets[..]),
FalseEdges {
ref mut real_target,
- ref mut imaginary_targets,
+ ref mut imaginary_target,
} => Some(real_target)
.into_iter()
- .chain(&mut imaginary_targets[..]),
+ .chain(slice::from_mut(imaginary_target)),
}
}
Assert { cleanup: None, .. } => vec!["".into()],
Assert { .. } => vec!["success".into(), "unwind".into()],
FalseEdges {
- ref imaginary_targets,
..
} => {
- let mut l = vec!["real".into()];
- l.resize(imaginary_targets.len() + 1, "imaginary".into());
- l
+ vec!["real".into(), "imaginary".into()]
}
FalseUnwind {
unwind: Some(_), ..
Unreachable => Unreachable,
FalseEdges {
real_target,
- ref imaginary_targets,
+ imaginary_target,
} => FalseEdges {
real_target,
- imaginary_targets: imaginary_targets.clone(),
+ imaginary_target,
},
FalseUnwind {
real_target,
| TerminatorKind::Unreachable
| TerminatorKind::FalseEdges {
real_target: _,
- imaginary_targets: _,
+ imaginary_target: _,
}
| TerminatorKind::FalseUnwind {
real_target: _,
| TerminatorKind::Unreachable
| TerminatorKind::FalseEdges {
real_target: _,
- imaginary_targets: _,
+ imaginary_target: _,
}
| TerminatorKind::FalseUnwind {
real_target: _,
}
TerminatorKind::FalseEdges {
real_target,
- ref imaginary_targets,
+ imaginary_target,
} => {
self.assert_iscleanup(body, block_data, real_target, is_cleanup);
- for target in imaginary_targets {
- self.assert_iscleanup(body, block_data, *target, is_cleanup);
- }
+ self.assert_iscleanup(body, block_data, imaginary_target, is_cleanup);
}
TerminatorKind::FalseUnwind {
real_target,
source_info,
TerminatorKind::FalseEdges {
real_target: second_candidate.pre_binding_block,
- imaginary_targets: vec![
- first_candidate.next_candidate_pre_binding_block
- ],
+ imaginary_target: first_candidate.next_candidate_pre_binding_block,
}
)
} else {
source_info,
TerminatorKind::FalseEdges {
real_target: unreachable,
- imaginary_targets: vec![candidate.next_candidate_pre_binding_block],
+ imaginary_targets: candidate.next_candidate_pre_binding_block,
}
);
self.cfg.terminate(unreachable, source_info, TerminatorKind::Unreachable);
source_info,
TerminatorKind::FalseEdges {
real_target: block,
- imaginary_targets: vec![last_candidate.next_candidate_pre_binding_block]
+ imaginary_target: last_candidate.next_candidate_pre_binding_block,
}
);
Some(block)
candidate_source_info,
TerminatorKind::FalseEdges {
real_target: block,
- imaginary_targets: vec![candidate.next_candidate_pre_binding_block],
+ imaginary_target: candidate.next_candidate_pre_binding_block,
},
);
self.ascribe_types(block, &candidate.ascriptions);
self.propagate_bits_into_entry_set_for(in_out, dest_bb, dirty_list);
}
}
- mir::TerminatorKind::FalseEdges { real_target, ref imaginary_targets } => {
+ mir::TerminatorKind::FalseEdges { real_target, imaginary_target } => {
self.propagate_bits_into_entry_set_for(in_out, real_target, dirty_list);
- for target in imaginary_targets {
- self.propagate_bits_into_entry_set_for(in_out, *target, dirty_list);
- }
+ self.propagate_bits_into_entry_set_for(in_out, imaginary_target, dirty_list);
}
mir::TerminatorKind::FalseUnwind { real_target, unwind } => {
self.propagate_bits_into_entry_set_for(in_out, real_target, dirty_list);
}
TerminatorKind::Abort => { }
TerminatorKind::Unreachable => { }
- TerminatorKind::FalseEdges { ref mut real_target, ref mut imaginary_targets } => {
+ TerminatorKind::FalseEdges { ref mut real_target, ref mut imaginary_target } => {
*real_target = self.update_target(*real_target);
- for target in imaginary_targets {
- *target = self.update_target(*target);
- }
+ *imaginary_target = self.update_target(*imaginary_target);
}
TerminatorKind::FalseUnwind { real_target: _ , unwind: _ } =>
// see the ordering of passes in the optimized_mir query.