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);
}
}
}
dataflow::visit_results(
- &*body,
- traversal::reverse_postorder(&*body).map(|(bb, _)| bb),
+ &body,
+ traversal::reverse_postorder(&body).map(|(bb, _)| bb),
&results,
&mut mbcx,
);
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
};
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
);
let res = ecx.load_mir(cid.instance.def, cid.promoted);
- res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, *body))
+ res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, &body))
.and_then(|place| {
Ok(RawConst { alloc_id: place.ptr.assert_ptr().alloc_id, ty: place.layout.ty })
})
) -> Self {
MaybeRequiresStorage {
body,
- borrowed_locals: RefCell::new(ResultsRefCursor::new(*body, borrowed_locals)),
+ borrowed_locals: RefCell::new(ResultsRefCursor::new(&body, borrowed_locals)),
}
}
}
/// 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() {
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