// variant argument) that does not require visiting, as in
// `is_cleanup` above.
-macro_rules! body_cache_type {
- (mut $a:lifetime, $tcx:lifetime) => {
+macro_rules! body_type {
+ (mut $tcx:lifetime) => {
&mut BodyAndCache<$tcx>
};
- ($a:lifetime, $tcx:lifetime) => {
- ReadOnlyBodyAndCache<$a, $tcx>
+ ($tcx:lifetime) => {
+ &Body<$tcx>
};
}
fn visit_body(
&mut self,
- body: body_cache_type!($($mutability)? '_, 'tcx)
+ body: body_type!($($mutability)? 'tcx)
) {
self.super_body(body);
}
fn super_body(
&mut self,
- $($mutability)? body: body_cache_type!($($mutability)? '_, 'tcx)
+ $($mutability)? body: body_type!($($mutability)? 'tcx)
) {
let span = body.span;
if let Some(yield_ty) = &$($mutability)? body.yield_ty {
fn visit_location(
&mut self,
- body: body_cache_type!($($mutability)? '_, 'tcx),
+ body: body_type!($($mutability)? 'tcx),
location: Location
) {
let basic_block = & $($mutability)? body[location.block];
let mir = fx.mir;
let mut analyzer = LocalAnalyzer::new(fx);
- analyzer.visit_body(mir);
+ analyzer.visit_body(*mir);
for (local, decl) in mir.local_decls.iter_enumerated() {
let ty = fx.monomorphize(&decl.ty);
LocalsStateAtExit::AllAreInvalidated
} else {
let mut has_storage_dead = HasStorageDead(BitSet::new_empty(body.local_decls.len()));
- has_storage_dead.visit_body(body);
+ has_storage_dead.visit_body(*body);
let mut has_storage_dead_or_moved = has_storage_dead.0;
for move_out in &move_data.moves {
if let Some(index) = move_data.base_local(move_out.path) {
}
}
let mut visitor = FakeReadCauseFinder { place, cause: None };
- visitor.visit_body(self.body);
+ visitor.visit_body(*self.body);
match visitor.cause {
Some(FakeReadCause::ForMatchGuard) => Some("match guard"),
Some(FakeReadCause::ForIndex) => Some("indexing expression"),
body: &body,
dominators,
};
- ig.visit_body(body);
+ ig.visit_body(*body);
}
}
live_locals.iter().for_each(|&local| locals_with_use_data[local] = true);
LocalUseMapBuild { local_use_map: &mut local_use_map, elements, locals_with_use_data }
- .visit_body(body);
+ .visit_body(*body);
local_use_map
}
location_table,
move_data,
};
- extractor.visit_body(body);
+ extractor.visit_body(*body);
facts.var_dropped_at.extend(
dropped_at.iter().map(|&(local, location)| (local, location_table.mid_index(location))),
);
let errors_reported = {
let mut verifier = TypeVerifier::new(&mut checker, *body, promoted);
- verifier.visit_body(body);
+ verifier.visit_body(*body);
verifier.errors_reported
};
}
}
- fn visit_body(&mut self, body: ReadOnlyBodyAndCache<'_, 'tcx>) {
+ fn visit_body(&mut self, body: &Body<'tcx>) {
self.sanitize_type(&"return type", body.return_ty());
for local_decl in &body.local_decls {
self.sanitize_type(local_decl, local_decl.ty);
swap_constraints(self);
- self.visit_body(promoted_body);
+ self.visit_body(*promoted_body);
if !self.errors_reported {
// if verifier failed, don't do further checks to avoid ICEs
never_initialized_mut_locals: &mut never_initialized_mut_locals,
mbcx: self,
};
- visitor.visit_body(visitor.mbcx.body);
+ visitor.visit_body(*visitor.mbcx.body);
}
// Take the union of the existed `used_mut` set with those variables we've found were
/// Kill locals that are fully moved and have not been borrowed.
fn check_for_move(&self, trans: &mut impl GenKill<Local>, loc: Location) {
let mut visitor = MoveVisitor { trans, borrowed_locals: &self.borrowed_locals };
- visitor.visit_location(self.body, loc);
+ visitor.visit_location(*self.body, loc);
}
}
debug!("collect_neighbours: {:?}", instance.def_id());
let body = tcx.instance_mir(instance.def);
- MirNeighborCollector { tcx, body: &body, output, instance }.visit_body(body);
+ MirNeighborCollector { tcx, body: &body, output, instance }.visit_body(*body);
}
fn def_id_to_string(tcx: TyCtxt<'_>, def_id: DefId) -> String {
self.check_op_spanned(ops::Loop, body.span);
}
- self.visit_body(body);
+ self.visit_body(*body);
// Ensure that the end result is `Sync` in a non-thread local `static`.
let should_check_for_sync =
// mir_built ensures that body has a computed cache, so we don't (and can't) attempt to
// recompute it here.
let body = body.unwrap_read_only();
- checker.visit_body(body);
+ checker.visit_body(*body);
check_unused_unsafe(tcx, def_id, &checker.used_unsafe, &mut checker.inherited_blocks);
UnsafetyCheckResult {
trace!("local {:?} can't be const propagated because it's not a temporary", local);
}
}
- cpv.visit_body(body);
+ cpv.visit_body(*body);
cpv.can_const_prop
}
}
// Find the MIR locals which do not use StorageLive/StorageDead statements.
// The storage of these locals are always live.
let mut ignored = StorageIgnored(BitSet::new_filled(body.local_decls.len()));
- ignored.visit_body(body);
+ ignored.visit_body(*body);
// Calculate the MIR locals which have been previously
// borrowed (even if they are still active).
let optimizations = {
let read_only_cache = read_only!(body);
let mut optimization_finder = OptimizationFinder::new(body, tcx);
- optimization_finder.visit_body(read_only_cache);
+ optimization_finder.visit_body(*read_only_cache);
optimization_finder.optimizations
};
let locals = {
let read_only_cache = read_only!(body);
let mut marker = DeclMarker { locals: BitSet::new_empty(body.local_decls.len()), body };
- marker.visit_body(read_only_cache);
+ marker.visit_body(*read_only_cache);
// Return pointer and arguments are always live
marker.locals.insert(RETURN_PLACE);
for arg in body.args_iter() {
use rustc::mir::visit::PlaceContext;
use rustc::mir::visit::Visitor;
-use rustc::mir::ReadOnlyBodyAndCache;
-use rustc::mir::{Local, Location};
+use rustc::mir::{Body, Local, Location};
crate trait FindAssignments {
// Finds all statements that assign directly to local (i.e., X = ...)
fn find_assignments(&self, local: Local) -> Vec<Location>;
}
-impl<'a, 'tcx> FindAssignments for ReadOnlyBodyAndCache<'a, 'tcx> {
+impl<'tcx> FindAssignments for Body<'tcx> {
fn find_assignments(&self, local: Local) -> Vec<Location> {
let mut visitor = FindLocalAssignmentVisitor { needle: local, locations: vec![] };
- visitor.visit_body(*self);
+ visitor.visit_body(self);
visitor.locations
}
}
var_debug_info_index: 0,
in_var_debug_info: false,
};
- finder.visit_body(body);
+ finder.visit_body(*body);
self.info = finder.info
}
projects / rust.git / commitdiff