X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fescape.rs;h=c44f2c696580c311700f3a7bd4a51c0bde8b1187;hb=6d1225981177587fbb68d9c4902c770c3dbaafb0;hp=e174cdfb86033f92095752bcc83bb53de3dabc7d;hpb=2c282252a93effa847517a4ced1b24036372dd46;p=rust.git diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index e174cdfb860..c44f2c69658 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -1,12 +1,12 @@ use rustc::hir::intravisit as visit; use rustc::hir::{self, *}; +use rustc::impl_lint_pass; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::middle::expr_use_visitor::*; -use rustc::middle::mem_categorization::{cmt_, Categorization}; use rustc::ty::layout::LayoutOf; use rustc::ty::{self, Ty}; use rustc::util::nodemap::HirIdSet; -use rustc::{declare_tool_lint, impl_lint_pass}; +use rustc_session::declare_tool_lint; +use rustc_typeck::expr_use_visitor::*; use syntax::source_map::Span; use crate::utils::span_lint; @@ -56,7 +56,7 @@ fn check_fn( cx: &LateContext<'a, 'tcx>, _: visit::FnKind<'tcx>, _: &'tcx FnDecl, - body: &'tcx Body, + body: &'tcx Body<'_>, _: Span, hir_id: HirId, ) { @@ -65,7 +65,7 @@ fn check_fn( let parent_node = cx.tcx.hir().find(parent_id); if let Some(Node::Item(item)) = parent_node { - if let ItemKind::Impl(_, _, _, _, Some(..), _, _) = item.node { + if let ItemKind::Impl(_, _, _, _, Some(..), _, _) = item.kind { return; } } @@ -77,17 +77,9 @@ fn check_fn( }; let fn_def_id = cx.tcx.hir().local_def_id(hir_id); - let region_scope_tree = &cx.tcx.region_scope_tree(fn_def_id); - ExprUseVisitor::new( - &mut v, - cx.tcx, - fn_def_id, - cx.param_env, - region_scope_tree, - cx.tables, - None, - ) - .consume_body(body); + cx.tcx.infer_ctxt().enter(|infcx| { + ExprUseVisitor::new(&mut v, &infcx, fn_def_id, cx.param_env, cx.tables).consume_body(body); + }); for node in v.set { span_lint( @@ -114,93 +106,58 @@ fn is_argument(map: &hir::map::Map<'_>, id: HirId) -> bool { } impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> { - fn consume(&mut self, _: HirId, _: Span, cmt: &cmt_<'tcx>, mode: ConsumeMode) { - if let Categorization::Local(lid) = cmt.cat { - if let Move(DirectRefMove) | Move(CaptureMove) = mode { - // moved out or in. clearly can't be localized - self.set.remove(&lid); - } - } - } - fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {} - fn consume_pat(&mut self, consume_pat: &Pat, cmt: &cmt_<'tcx>, _: ConsumeMode) { - let map = &self.cx.tcx.hir(); - if is_argument(map, consume_pat.hir_id) { - // Skip closure arguments - let parent_id = map.get_parent_node(consume_pat.hir_id); - if let Some(Node::Expr(..)) = map.find(map.get_parent_node(parent_id)) { - return; - } - - if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) { - self.set.insert(consume_pat.hir_id); - } - return; - } - if let Categorization::Rvalue(..) = cmt.cat { - if let Some(Node::Stmt(st)) = map.find(map.get_parent_node(cmt.hir_id)) { - if let StmtKind::Local(ref loc) = st.node { - if let Some(ref ex) = loc.init { - if let ExprKind::Box(..) = ex.node { - if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) { - // let x = box (...) - self.set.insert(consume_pat.hir_id); - } - // TODO Box::new - // TODO vec![] - // TODO "foo".to_owned() and friends - } + fn consume(&mut self, cmt: &Place<'tcx>, mode: ConsumeMode) { + if cmt.projections.is_empty() { + if let PlaceBase::Local(lid) = cmt.base { + if let ConsumeMode::Move = mode { + // moved out or in. clearly can't be localized + self.set.remove(&lid); + } + let map = &self.cx.tcx.hir(); + if let Some(Node::Binding(_)) = map.find(cmt.hir_id) { + if self.set.contains(&lid) { + // let y = x where x is known + // remove x, insert y + self.set.insert(cmt.hir_id); + self.set.remove(&lid); } } } } - if let Categorization::Local(lid) = cmt.cat { - if self.set.contains(&lid) { - // let y = x where x is known - // remove x, insert y - self.set.insert(consume_pat.hir_id); + } + + fn borrow(&mut self, cmt: &Place<'tcx>, _: ty::BorrowKind) { + if cmt.projections.is_empty() { + if let PlaceBase::Local(lid) = cmt.base { self.set.remove(&lid); } } } - fn borrow( - &mut self, - _: HirId, - _: Span, - cmt: &cmt_<'tcx>, - _: ty::Region<'_>, - _: ty::BorrowKind, - loan_cause: LoanCause, - ) { - if let Categorization::Local(lid) = cmt.cat { - match loan_cause { - // `x.foo()` - // Used without autoderef-ing (i.e., `x.clone()`). - LoanCause::AutoRef | - - // `&x` - // `foo(&x)` where no extra autoref-ing is happening. - LoanCause::AddrOf | - - // `match x` can move. - LoanCause::MatchDiscriminant => { - self.set.remove(&lid); + + fn mutate(&mut self, cmt: &Place<'tcx>) { + if cmt.projections.is_empty() { + let map = &self.cx.tcx.hir(); + if is_argument(map, cmt.hir_id) { + // Skip closure arguments + let parent_id = map.get_parent_node(cmt.hir_id); + if let Some(Node::Expr(..)) = map.find(map.get_parent_node(parent_id)) { + return; } - // Do nothing for matches, etc. These can't escape. - _ => {} + if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) { + self.set.insert(cmt.hir_id); + } + return; } } } - fn decl_without_init(&mut self, _: HirId, _: Span) {} - fn mutate(&mut self, _: HirId, _: Span, _: &cmt_<'tcx>, _: MutateMode) {} } impl<'a, 'tcx> EscapeDelegate<'a, 'tcx> { fn is_large_box(&self, ty: Ty<'tcx>) -> bool { // Large types need to be boxed to avoid stack overflows. if ty.is_box() { - self.cx.layout_of(ty.boxed_ty()).ok().map_or(0, |l| l.size.bytes()) > self.too_large_for_stack + self.cx.layout_of(ty.boxed_ty()).map_or(0, |l| l.size.bytes()) > self.too_large_for_stack } else { false }