use crate::utils::{
- has_drop, is_copy, match_def_path, match_type, paths, snippet_opt, span_lint_hir, span_lint_hir_and_then,
- walk_ptrs_ty_depth,
+ fn_has_unsatisfiable_preds, has_drop, is_copy, is_type_diagnostic_item, match_def_path, match_type, paths,
+ snippet_opt, span_lint_hir, span_lint_hir_and_then, walk_ptrs_ty_depth,
};
use if_chain::if_chain;
-use matches::matches;
-use rustc::mir::{
- self, traversal,
- visit::{MutatingUseContext, PlaceContext, Visitor as _},
-};
-use rustc::ty::{self, fold::TypeVisitor, Ty};
use rustc_data_structures::{fx::FxHashMap, transitive_relation::TransitiveRelation};
use rustc_errors::Applicability;
use rustc_hir::intravisit::FnKind;
use rustc_hir::{def_id, Body, FnDecl, HirId};
use rustc_index::bit_set::{BitSet, HybridBitSet};
use rustc_lint::{LateContext, LateLintPass};
-use rustc_mir::dataflow::{
- do_dataflow, BitDenotation, BottomValue, DataflowResults, DataflowResultsCursor, DebugFormatted, GenKillSet,
+use rustc_middle::mir::{
+ self, traversal,
+ visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor as _},
};
+use rustc_middle::ty::{self, fold::TypeVisitor, Ty};
+use rustc_mir::dataflow::BottomValue;
+use rustc_mir::dataflow::{Analysis, AnalysisDomain, GenKill, GenKillAnalysis, ResultsCursor};
use rustc_session::{declare_lint_pass, declare_tool_lint};
use rustc_span::source_map::{BytePos, Span};
use std::convert::TryFrom;
_: HirId,
) {
let def_id = cx.tcx.hir().body_owner_def_id(body.id());
- let mir = cx.tcx.optimized_mir(def_id);
- let mir_read_only = mir.unwrap_read_only();
-
- let dead_unwinds = BitSet::new_empty(mir.basic_blocks().len());
- let maybe_storage_live_result = do_dataflow(
- cx.tcx,
- mir,
- def_id,
- &[],
- &dead_unwinds,
- MaybeStorageLive::new(mir),
- |bd, p| DebugFormatted::new(&bd.body.local_decls[p]),
- );
+
+ // Building MIR for `fn`s with unsatisfiable preds results in ICE.
+ if fn_has_unsatisfiable_preds(cx, def_id.to_def_id()) {
+ return;
+ }
+
+ let mir = cx.tcx.optimized_mir(def_id.to_def_id());
+
+ let maybe_storage_live_result = MaybeStorageLive
+ .into_engine(cx.tcx, mir, def_id.to_def_id())
+ .iterate_to_fixpoint()
+ .into_results_cursor(mir);
let mut possible_borrower = {
let mut vis = PossibleBorrowerVisitor::new(cx, mir);
- vis.visit_body(mir_read_only);
+ vis.visit_body(&mir);
vis.into_map(cx, maybe_storage_live_result)
};
continue;
}
- let (fn_def_id, arg, arg_ty, _) = unwrap_or_continue!(is_call_with_ref_arg(cx, mir, &terminator.kind));
+ let (fn_def_id, arg, arg_ty, clone_ret) =
+ unwrap_or_continue!(is_call_with_ref_arg(cx, mir, &terminator.kind));
let from_borrow = match_def_path(cx, fn_def_id, &paths::CLONE_TRAIT_METHOD)
|| match_def_path(cx, fn_def_id, &paths::TO_OWNED_METHOD)
- || (match_def_path(cx, fn_def_id, &paths::TO_STRING_METHOD) && match_type(cx, arg_ty, &paths::STRING));
+ || (match_def_path(cx, fn_def_id, &paths::TO_STRING_METHOD)
+ && is_type_diagnostic_item(cx, arg_ty, sym!(string_type)));
let from_deref = !from_borrow
&& (match_def_path(cx, fn_def_id, &paths::PATH_TO_PATH_BUF)
statement_index: bbdata.statements.len(),
};
- // Cloned local
- let local = if from_borrow {
+ // `Local` to be cloned, and a local of `clone` call's destination
+ let (local, ret_local) = if from_borrow {
// `res = clone(arg)` can be turned into `res = move arg;`
// if `arg` is the only borrow of `cloned` at this point.
continue;
}
- cloned
+ (cloned, clone_ret)
} else {
// `arg` is a reference as it is `.deref()`ed in the previous block.
// Look into the predecessor block and find out the source of deref.
- let ps = mir_read_only.predecessors_for(bb);
+ let ps = &mir.predecessors()[bb];
if ps.len() != 1 {
continue;
}
let pred_terminator = mir[ps[0]].terminator();
// receiver of the `deref()` call
- let pred_arg = if_chain! {
- if let Some((pred_fn_def_id, pred_arg, pred_arg_ty, Some(res))) =
+ let (pred_arg, deref_clone_ret) = if_chain! {
+ if let Some((pred_fn_def_id, pred_arg, pred_arg_ty, res)) =
is_call_with_ref_arg(cx, mir, &pred_terminator.kind);
- if res.local == cloned;
+ if res == cloned;
if match_def_path(cx, pred_fn_def_id, &paths::DEREF_TRAIT_METHOD);
if match_type(cx, pred_arg_ty, &paths::PATH_BUF)
|| match_type(cx, pred_arg_ty, &paths::OS_STRING);
then {
- pred_arg
+ (pred_arg, res)
} else {
continue;
}
continue;
}
- local
+ (local, deref_clone_ret)
};
- // `local` cannot be moved out if it is used later
- let used_later = traversal::ReversePostorder::new(&mir, bb).skip(1).any(|(tbb, tdata)| {
- // Give up on loops
- if tdata.terminator().successors().any(|s| *s == bb) {
- return true;
- }
+ let is_temp = mir.local_kind(ret_local) == mir::LocalKind::Temp;
+
+ // 1. `local` can be moved out if it is not used later.
+ // 2. If `ret_local` is a temporary and is neither consumed nor mutated, we can remove this `clone`
+ // call anyway.
+ let (used, consumed_or_mutated) = traversal::ReversePostorder::new(&mir, bb).skip(1).fold(
+ (false, !is_temp),
+ |(used, consumed), (tbb, tdata)| {
+ // Short-circuit
+ if (used && consumed) ||
+ // Give up on loops
+ tdata.terminator().successors().any(|s| *s == bb)
+ {
+ return (true, true);
+ }
- let mut vis = LocalUseVisitor {
- local,
- used_other_than_drop: false,
- };
- vis.visit_basic_block_data(tbb, tdata);
- vis.used_other_than_drop
- });
+ let mut vis = LocalUseVisitor {
+ used: (local, false),
+ consumed_or_mutated: (ret_local, false),
+ };
+ vis.visit_basic_block_data(tbb, tdata);
+ (used || vis.used.1, consumed || vis.consumed_or_mutated.1)
+ },
+ );
- if !used_later {
+ if !used || !consumed_or_mutated {
let span = terminator.source_info.span;
let scope = terminator.source_info.scope;
let node = mir.source_scopes[scope]
}
}
- span_lint_hir_and_then(cx, REDUNDANT_CLONE, node, sugg_span, "redundant clone", |db| {
- db.span_suggestion(
+ span_lint_hir_and_then(cx, REDUNDANT_CLONE, node, sugg_span, "redundant clone", |diag| {
+ diag.span_suggestion(
sugg_span,
"remove this",
String::new(),
app,
);
- db.span_note(
- span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
- "this value is dropped without further use",
- );
+ if used {
+ diag.span_note(
+ span,
+ "cloned value is neither consumed nor mutated",
+ );
+ } else {
+ diag.span_note(
+ span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
+ "this value is dropped without further use",
+ );
+ }
});
} else {
span_lint_hir(cx, REDUNDANT_CLONE, node, span, "redundant clone");
cx: &LateContext<'_, 'tcx>,
mir: &'tcx mir::Body<'tcx>,
kind: &'tcx mir::TerminatorKind<'tcx>,
-) -> Option<(def_id::DefId, mir::Local, Ty<'tcx>, Option<&'tcx mir::Place<'tcx>>)> {
+) -> Option<(def_id::DefId, mir::Local, Ty<'tcx>, mir::Local)> {
if_chain! {
if let mir::TerminatorKind::Call { func, args, destination, .. } = kind;
if args.len() == 1;
if let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].ty(&*mir, cx.tcx));
if !is_copy(cx, inner_ty);
then {
- Some((def_id, *local, inner_ty, destination.as_ref().map(|(dest, _)| dest)))
+ Some((def_id, *local, inner_ty, destination.as_ref().map(|(dest, _)| dest)?.as_local()?))
} else {
None
}
mir: &mir::Body<'tcx>,
place: mir::Place<'tcx>,
) -> Option<(mir::Local, CannotMoveOut)> {
- use rustc::mir::PlaceRef;
+ use rustc_middle::mir::PlaceRef;
// Dereference. You cannot move things out from a borrowed value.
let mut deref = false;
// Accessing a field of an ADT that has `Drop`. Moving the field out will cause E0509.
let mut field = false;
+ // If projection is a slice index then clone can be removed only if the
+ // underlying type implements Copy
+ let mut slice = false;
let PlaceRef { local, mut projection } = place.as_ref();
while let [base @ .., elem] = projection {
deref |= matches!(elem, mir::ProjectionElem::Deref);
field |= matches!(elem, mir::ProjectionElem::Field(..))
&& has_drop(cx, mir::Place::ty_from(local, projection, &mir.local_decls, cx.tcx).ty);
+ slice |= matches!(elem, mir::ProjectionElem::Index(..))
+ && !is_copy(cx, mir::Place::ty_from(local, projection, &mir.local_decls, cx.tcx).ty);
}
- Some((*local, deref || field))
+ Some((local, deref || field || slice))
}
struct LocalUseVisitor {
- local: mir::Local,
- used_other_than_drop: bool,
+ used: (mir::Local, bool),
+ consumed_or_mutated: (mir::Local, bool),
}
impl<'tcx> mir::visit::Visitor<'tcx> for LocalUseVisitor {
let statements = &data.statements;
for (statement_index, statement) in statements.iter().enumerate() {
self.visit_statement(statement, mir::Location { block, statement_index });
-
- // Once flagged, skip remaining statements
- if self.used_other_than_drop {
- return;
- }
}
self.visit_terminator(
);
}
- fn visit_local(&mut self, local: &mir::Local, ctx: PlaceContext, _: mir::Location) {
- match ctx {
- PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_) => return,
- _ => {},
+ fn visit_place(&mut self, place: &mir::Place<'tcx>, ctx: PlaceContext, _: mir::Location) {
+ let local = place.local;
+
+ if local == self.used.0
+ && !matches!(ctx, PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_))
+ {
+ self.used.1 = true;
}
- if *local == self.local {
- self.used_other_than_drop = true;
+ if local == self.consumed_or_mutated.0 {
+ match ctx {
+ PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
+ | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
+ self.consumed_or_mutated.1 = true;
+ },
+ _ => {},
+ }
}
}
}
/// Determines liveness of each local purely based on `StorageLive`/`Dead`.
#[derive(Copy, Clone)]
-struct MaybeStorageLive<'a, 'tcx> {
- body: &'a mir::Body<'tcx>,
-}
-
-impl<'a, 'tcx> MaybeStorageLive<'a, 'tcx> {
- fn new(body: &'a mir::Body<'tcx>) -> Self {
- MaybeStorageLive { body }
- }
-}
+struct MaybeStorageLive;
-impl<'a, 'tcx> BitDenotation<'tcx> for MaybeStorageLive<'a, 'tcx> {
+impl<'tcx> AnalysisDomain<'tcx> for MaybeStorageLive {
type Idx = mir::Local;
- fn name() -> &'static str {
- "maybe_storage_live"
- }
- fn bits_per_block(&self) -> usize {
- self.body.local_decls.len()
+ const NAME: &'static str = "maybe_storage_live";
+
+ fn bits_per_block(&self, body: &mir::Body<'tcx>) -> usize {
+ body.local_decls.len()
}
- fn start_block_effect(&self, on_entry: &mut BitSet<mir::Local>) {
- for arg in self.body.args_iter() {
- on_entry.insert(arg);
+ fn initialize_start_block(&self, body: &mir::Body<'tcx>, state: &mut BitSet<Self::Idx>) {
+ for arg in body.args_iter() {
+ state.insert(arg);
}
}
+}
- fn statement_effect(&self, trans: &mut GenKillSet<mir::Local>, loc: mir::Location) {
- let stmt = &self.body[loc.block].statements[loc.statement_index];
-
+impl<'tcx> GenKillAnalysis<'tcx> for MaybeStorageLive {
+ fn statement_effect(&self, trans: &mut impl GenKill<Self::Idx>, stmt: &mir::Statement<'tcx>, _: mir::Location) {
match stmt.kind {
mir::StatementKind::StorageLive(l) => trans.gen(l),
mir::StatementKind::StorageDead(l) => trans.kill(l),
}
}
- fn terminator_effect(&self, _trans: &mut GenKillSet<mir::Local>, _loc: mir::Location) {}
+ fn terminator_effect(
+ &self,
+ _trans: &mut impl GenKill<Self::Idx>,
+ _terminator: &mir::Terminator<'tcx>,
+ _loc: mir::Location,
+ ) {
+ }
- fn propagate_call_return(
+ fn call_return_effect(
&self,
- _in_out: &mut BitSet<mir::Local>,
- _call_bb: mir::BasicBlock,
- _dest_bb: mir::BasicBlock,
- _dest_place: &mir::Place<'tcx>,
+ _in_out: &mut impl GenKill<Self::Idx>,
+ _block: mir::BasicBlock,
+ _func: &mir::Operand<'tcx>,
+ _args: &[mir::Operand<'tcx>],
+ _return_place: mir::Place<'tcx>,
) {
// Nothing to do when a call returns successfully
}
}
-impl<'a, 'tcx> BottomValue for MaybeStorageLive<'a, 'tcx> {
+impl BottomValue for MaybeStorageLive {
/// bottom = dead
const BOTTOM_VALUE: bool = false;
}
fn into_map(
self,
cx: &LateContext<'a, 'tcx>,
- maybe_live: DataflowResults<'tcx, MaybeStorageLive<'a, 'tcx>>,
- ) -> PossibleBorrower<'a, 'tcx> {
+ maybe_live: ResultsCursor<'tcx, 'tcx, MaybeStorageLive>,
+ ) -> PossibleBorrowerMap<'a, 'tcx> {
let mut map = FxHashMap::default();
for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
if is_copy(cx, self.body.local_decls[row].ty) {
}
let bs = BitSet::new_empty(self.body.local_decls.len());
- PossibleBorrower {
+ PossibleBorrowerMap {
map,
- maybe_live: DataflowResultsCursor::new(maybe_live, self.body),
+ maybe_live,
bitset: (bs.clone(), bs),
}
}
}
fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
- use rustc::mir::Rvalue::*;
+ use rustc_middle::mir::Rvalue::{Aggregate, BinaryOp, Cast, CheckedBinaryOp, Repeat, UnaryOp, Use};
let mut visit_op = |op: &mir::Operand<'_>| match op {
mir::Operand::Copy(p) | mir::Operand::Move(p) => visit(p.local),
}
/// Result of `PossibleBorrowerVisitor`.
-struct PossibleBorrower<'a, 'tcx> {
+struct PossibleBorrowerMap<'a, 'tcx> {
/// Mapping `Local -> its possible borrowers`
map: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
- maybe_live: DataflowResultsCursor<'a, 'tcx, MaybeStorageLive<'a, 'tcx>>,
+ maybe_live: ResultsCursor<'a, 'tcx, MaybeStorageLive>,
// Caches to avoid allocation of `BitSet` on every query
bitset: (BitSet<mir::Local>, BitSet<mir::Local>),
}
-impl PossibleBorrower<'_, '_> {
+impl PossibleBorrowerMap<'_, '_> {
/// Returns true if the set of borrowers of `borrowed` living at `at` matches with `borrowers`.
fn only_borrowers(&mut self, borrowers: &[mir::Local], borrowed: mir::Local, at: mir::Location) -> bool {
- self.maybe_live.seek(at);
+ self.maybe_live.seek_after_primary_effect(at);
self.bitset.0.clear();
let maybe_live = &mut self.maybe_live;
projects / rust.git / blobdiff