282 lines
9.9 KiB
Rust
282 lines
9.9 KiB
Rust
|
// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
|
||
|
|
// file at the top-level directory of this distribution.
|
||
|
|
//
|
||
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||
|
|
// option. This file may not be copied, modified, or distributed
|
||
|
|
// except according to those terms.
|
||
|
|
|
||
|
|
use crate::rustc::hir::intravisit::FnKind;
|
||
|
|
use crate::rustc::hir::{def_id, Body, FnDecl};
|
||
|
|
use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
|
||
|
|
use crate::rustc::mir::{
|
||
|
|
self, traversal,
|
||
|
|
visit::{PlaceContext, Visitor},
|
||
|
|
TerminatorKind,
|
||
|
|
};
|
||
|
|
use crate::rustc::ty;
|
||
|
|
use crate::rustc::{declare_tool_lint, lint_array};
|
||
|
|
use crate::rustc_errors::Applicability;
|
||
|
|
use crate::syntax::{
|
||
|
|
ast::NodeId,
|
||
|
|
source_map::{BytePos, Span},
|
||
|
|
};
|
||
|
|
use crate::utils::{
|
||
|
|
in_macro, is_copy, match_def_path, match_type, paths, snippet_opt, span_lint, span_lint_and_then,
|
||
|
|
walk_ptrs_ty_depth,
|
||
|
|
};
|
||
|
|
use if_chain::if_chain;
|
||
|
|
use std::convert::TryFrom;
|
||
|
|
|
||
|
|
/// **What it does:** Checks for a redudant `clone()` (and its relatives) which clones an owned
|
||
|
|
/// value that is going to be dropped without further use.
|
||
|
|
///
|
||
|
|
/// **Why is this bad?** It is not always possible for the compiler to eliminate useless
|
||
|
|
/// allocations and deallocations generated by redundant `clone()`s.
|
||
|
|
///
|
||
|
|
/// **Known problems:**
|
||
|
|
///
|
||
|
|
/// * Suggestions made by this lint could require NLL to be enabled.
|
||
|
|
/// * False-positive if there is a borrow preventing the value from moving out.
|
||
|
|
///
|
||
|
|
/// ```rust
|
||
|
|
/// let x = String::new();
|
||
|
|
///
|
||
|
|
/// let y = &x;
|
||
|
|
///
|
||
|
|
/// foo(x.clone()); // This lint suggests to remove this `clone()`
|
||
|
|
/// ```
|
||
|
|
///
|
||
|
|
/// **Example:**
|
||
|
|
/// ```rust
|
||
|
|
/// {
|
||
|
|
/// let x = Foo::new();
|
||
|
|
/// call(x.clone());
|
||
|
|
/// call(x.clone()); // this can just pass `x`
|
||
|
|
/// }
|
||
|
|
///
|
||
|
|
/// ["lorem", "ipsum"].join(" ").to_string()
|
||
|
|
///
|
||
|
|
/// Path::new("/a/b").join("c").to_path_buf()
|
||
|
|
/// ```
|
||
|
|
declare_clippy_lint! {
|
||
|
|
pub REDUNDANT_CLONE,
|
||
|
|
nursery,
|
||
|
|
"`clone()` of an owned value that is going to be dropped immediately"
|
||
|
|
}
|
||
|
|
|
||
|
|
pub struct RedundantClone;
|
||
|
|
|
||
|
|
impl LintPass for RedundantClone {
|
||
|
|
fn get_lints(&self) -> LintArray {
|
||
|
|
lint_array!(REDUNDANT_CLONE)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RedundantClone {
|
||
|
|
fn check_fn(
|
||
|
|
&mut self,
|
||
|
|
cx: &LateContext<'a, 'tcx>,
|
||
|
|
_: FnKind<'tcx>,
|
||
|
|
_: &'tcx FnDecl,
|
||
|
|
body: &'tcx Body,
|
||
|
|
_: Span,
|
||
|
|
_: NodeId,
|
||
|
|
) {
|
||
|
|
let def_id = cx.tcx.hir.body_owner_def_id(body.id());
|
||
|
|
let mir = cx.tcx.optimized_mir(def_id);
|
||
|
|
|
||
|
|
// Looks for `call(&T)` where `T: !Copy`
|
||
|
|
let call = |kind: &mir::TerminatorKind<'tcx>| -> Option<(def_id::DefId, mir::Local, ty::Ty<'tcx>)> {
|
||
|
|
if_chain! {
|
||
|
|
if let TerminatorKind::Call { func, args, .. } = kind;
|
||
|
|
if args.len() == 1;
|
||
|
|
if let mir::Operand::Move(mir::Place::Local(local)) = &args[0];
|
||
|
|
if let ty::FnDef(def_id, _) = func.ty(&*mir, cx.tcx).sty;
|
||
|
|
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))
|
||
|
|
} else {
|
||
|
|
None
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
for (bb, bbdata) in mir.basic_blocks().iter_enumerated() {
|
||
|
|
let terminator = if let Some(terminator) = &bbdata.terminator {
|
||
|
|
terminator
|
||
|
|
} else {
|
||
|
|
continue;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Give up on loops
|
||
|
|
if terminator.successors().any(|s| *s == bb) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
let (fn_def_id, arg, arg_ty) = if let Some(t) = call(&terminator.kind) {
|
||
|
|
t
|
||
|
|
} else {
|
||
|
|
continue;
|
||
|
|
};
|
||
|
|
|
||
|
|
let from_borrow = match_def_path(cx.tcx, fn_def_id, &paths::CLONE_TRAIT_METHOD)
|
||
|
|
|| match_def_path(cx.tcx, fn_def_id, &paths::TO_OWNED_METHOD)
|
||
|
|
|| (match_def_path(cx.tcx, fn_def_id, &paths::TO_STRING_METHOD)
|
||
|
|
&& match_type(cx, arg_ty, &paths::STRING));
|
||
|
|
|
||
|
|
let from_deref = !from_borrow
|
||
|
|
&& (match_def_path(cx.tcx, fn_def_id, &paths::PATH_TO_PATH_BUF)
|
||
|
|
|| match_def_path(cx.tcx, fn_def_id, &paths::OS_STR_TO_OS_STRING));
|
||
|
|
|
||
|
|
if !from_borrow && !from_deref {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// _1 in MIR `{ _2 = &_1; clone(move _2); }` or `{ _2 = _1; to_path_buf(_2); }
|
||
|
|
let cloned = if let Some(referent) = bbdata
|
||
|
|
.statements
|
||
|
|
.iter()
|
||
|
|
.rev()
|
||
|
|
.filter_map(|stmt| {
|
||
|
|
if let mir::StatementKind::Assign(mir::Place::Local(local), v) = &stmt.kind {
|
||
|
|
if *local == arg {
|
||
|
|
if from_deref {
|
||
|
|
// `r` is already a reference.
|
||
|
|
if let mir::Rvalue::Use(mir::Operand::Copy(mir::Place::Local(r))) = **v {
|
||
|
|
return Some(r);
|
||
|
|
}
|
||
|
|
} else if let mir::Rvalue::Ref(_, _, mir::Place::Local(r)) = **v {
|
||
|
|
return Some(r);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
None
|
||
|
|
})
|
||
|
|
.next()
|
||
|
|
{
|
||
|
|
referent
|
||
|
|
} else {
|
||
|
|
continue;
|
||
|
|
};
|
||
|
|
|
||
|
|
// _1 in MIR `{ _2 = &_1; _3 = deref(move _2); } -> { _4 = _3; to_path_buf(move _4); }`
|
||
|
|
let referent = if from_deref {
|
||
|
|
let ps = mir.predecessors_for(bb);
|
||
|
|
let pred_arg = if_chain! {
|
||
|
|
if ps.len() == 1;
|
||
|
|
if let Some(pred_terminator) = &mir[ps[0]].terminator;
|
||
|
|
if let mir::TerminatorKind::Call { destination: Some((res, _)), .. } = &pred_terminator.kind;
|
||
|
|
if *res == mir::Place::Local(cloned);
|
||
|
|
if let Some((pred_fn_def_id, pred_arg, pred_arg_ty)) = call(&pred_terminator.kind);
|
||
|
|
if match_def_path(cx.tcx, 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
|
||
|
|
} else {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
if let Some(referent) = mir[ps[0]]
|
||
|
|
.statements
|
||
|
|
.iter()
|
||
|
|
.rev()
|
||
|
|
.filter_map(|stmt| {
|
||
|
|
if let mir::StatementKind::Assign(mir::Place::Local(l), v) = &stmt.kind {
|
||
|
|
if *l == pred_arg {
|
||
|
|
if let mir::Rvalue::Ref(_, _, mir::Place::Local(referent)) = **v {
|
||
|
|
return Some(referent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
None
|
||
|
|
})
|
||
|
|
.next()
|
||
|
|
{
|
||
|
|
referent
|
||
|
|
} else {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
cloned
|
||
|
|
};
|
||
|
|
|
||
|
|
let used_later = traversal::ReversePostorder::new(&mir, bb).skip(1).any(|(tbb, tdata)| {
|
||
|
|
if let Some(term) = &tdata.terminator {
|
||
|
|
// Give up on loops
|
||
|
|
if term.successors().any(|s| *s == bb) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let mut vis = LocalUseVisitor {
|
||
|
|
local: referent,
|
||
|
|
used_other_than_drop: false,
|
||
|
|
};
|
||
|
|
vis.visit_basic_block_data(tbb, tdata);
|
||
|
|
vis.used_other_than_drop
|
||
|
|
});
|
||
|
|
|
||
|
|
if !used_later {
|
||
|
|
let span = terminator.source_info.span;
|
||
|
|
if_chain! {
|
||
|
|
if !in_macro(span);
|
||
|
|
if let Some(snip) = snippet_opt(cx, span);
|
||
|
|
if let Some(dot) = snip.rfind('.');
|
||
|
|
then {
|
||
|
|
let sugg_span = span.with_lo(
|
||
|
|
span.lo() + BytePos(u32::try_from(dot).unwrap())
|
||
|
|
);
|
||
|
|
|
||
|
|
span_lint_and_then(cx, REDUNDANT_CLONE, sugg_span, "redundant clone", |db| {
|
||
|
|
db.span_suggestion_with_applicability(
|
||
|
|
sugg_span,
|
||
|
|
"remove this",
|
||
|
|
String::new(),
|
||
|
|
Applicability::MaybeIncorrect,
|
||
|
|
);
|
||
|
|
db.span_note(
|
||
|
|
span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
|
||
|
|
"this value is dropped without further use",
|
||
|
|
);
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
span_lint(cx, REDUNDANT_CLONE, span, "redundant clone");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
struct LocalUseVisitor {
|
||
|
|
local: mir::Local,
|
||
|
|
used_other_than_drop: bool,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'tcx> mir::visit::Visitor<'tcx> for LocalUseVisitor {
|
||
|
|
fn visit_statement(&mut self, block: mir::BasicBlock, statement: &mir::Statement<'tcx>, location: mir::Location) {
|
||
|
|
// Once flagged, skip remaining statements
|
||
|
|
if !self.used_other_than_drop {
|
||
|
|
self.super_statement(block, statement, location);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn visit_local(&mut self, local: &mir::Local, ctx: PlaceContext<'tcx>, _: mir::Location) {
|
||
|
|
match ctx {
|
||
|
|
PlaceContext::Drop | PlaceContext::StorageDead => return,
|
||
|
|
_ => {},
|
||
|
|
}
|
||
|
|
|
||
|
|
if *local == self.local {
|
||
|
|
self.used_other_than_drop = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|