use crate::utils::{
- fn_has_unsatisfiable_preds, 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, NonMutatingUseContext, 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::generic::{Analysis, AnalysisDomain, GenKill, GenKillAnalysis, ResultsCursor};
+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;
let def_id = cx.tcx.hir().body_owner_def_id(body.id());
// Building MIR for `fn`s with unsatisfiable preds results in ICE.
- if fn_has_unsatisfiable_preds(cx, def_id) {
+ if fn_has_unsatisfiable_preds(cx, def_id.to_def_id()) {
return;
}
- let mir = cx.tcx.optimized_mir(def_id);
- let mir_read_only = mir.unwrap_read_only();
+ let mir = cx.tcx.optimized_mir(def_id.to_def_id());
let maybe_storage_live_result = MaybeStorageLive
- .into_engine(cx.tcx, mir, def_id)
+ .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)
};
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)
// `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;
}
(local, deref_clone_ret)
};
- // 1. `local` cannot be moved out if it is used later.
- // 2. If `ret_local` is not consumed, we can remove this `clone` call anyway.
- let (used, consumed) = traversal::ReversePostorder::new(&mir, bb).skip(1).fold(
- (false, false),
+ 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) ||
let mut vis = LocalUseVisitor {
used: (local, false),
- consumed: (ret_local, false),
+ consumed_or_mutated: (ret_local, false),
};
vis.visit_basic_block_data(tbb, tdata);
- (used || vis.used.1, consumed || vis.consumed.1)
+ (used || vis.used.1, consumed || vis.consumed_or_mutated.1)
},
);
- if !used || !consumed {
+ 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,
);
if used {
- db.span_note(
+ diag.span_note(
span,
- "cloned value is not consumed",
+ "cloned value is neither consumed nor mutated",
);
} else {
- db.span_note(
+ diag.span_note(
span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
"this value is dropped without further use",
);
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 {
used: (mir::Local, bool),
- consumed: (mir::Local, bool),
+ consumed_or_mutated: (mir::Local, bool),
}
impl<'tcx> mir::visit::Visitor<'tcx> for LocalUseVisitor {
);
}
- fn visit_local(&mut self, local: &mir::Local, ctx: PlaceContext, _: mir::Location) {
- if *local == self.used.0
+ 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.consumed.0 && matches!(ctx, PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)) {
- self.consumed.1 = true;
+ if local == self.consumed_or_mutated.0 {
+ match ctx {
+ PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
+ | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
+ self.consumed_or_mutated.1 = true;
+ },
+ _ => {},
+ }
}
}
}
_block: mir::BasicBlock,
_func: &mir::Operand<'tcx>,
_args: &[mir::Operand<'tcx>],
- _return_place: &mir::Place<'tcx>,
+ _return_place: mir::Place<'tcx>,
) {
// Nothing to do when a call returns successfully
}
}
fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
- use rustc::mir::Rvalue::{Aggregate, BinaryOp, Cast, CheckedBinaryOp, Repeat, UnaryOp, Use};
+ 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),
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_after(at);
+ self.maybe_live.seek_after_primary_effect(at);
self.bitset.0.clear();
let maybe_live = &mut self.maybe_live;