diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index 58fe4d99c780..e796b465944d 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -1,12 +1,11 @@ use rustc::hir::intravisit as visit; use rustc::hir::{self, *}; 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_typeck::expr_use_visitor::*; use syntax::source_map::Span; use crate::utils::span_lint; @@ -77,8 +76,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxedLocal { }; 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).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( @@ -105,45 +105,49 @@ fn is_argument(map: &hir::map::Map<'_>, id: HirId) -> bool { } impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> { - fn consume(&mut self, cmt: &cmt_<'tcx>, mode: ConsumeMode) { - if let Categorization::Local(lid) = cmt.cat { - 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 Categorization::Local(lid) = cmt.cat { - 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); + 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); + } + } } } } - fn borrow(&mut self, cmt: &cmt_<'tcx>, _: ty::BorrowKind) { - if let Categorization::Local(lid) = cmt.cat { - self.set.remove(&lid); + 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 mutate(&mut self, cmt: &cmt_<'tcx>) { - 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; - } + 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; + } - if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) { - self.set.insert(cmt.hir_id); + if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) { + self.set.insert(cmt.hir_id); + } + return; } - return; } } } diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 0f0323c13aa1..4212f9c1e64f 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -12,13 +12,11 @@ use rustc::{declare_lint_pass, declare_tool_lint}; use crate::consts::{constant, Constant}; use crate::utils::usage::mutated_variables; use crate::utils::{is_type_diagnostic_item, qpath_res, sext, sugg}; -use rustc::middle::expr_use_visitor::*; -use rustc::middle::mem_categorization::cmt_; -use rustc::middle::mem_categorization::Categorization; use rustc::ty::subst::Subst; use rustc::ty::{self, Ty}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::Applicability; +use rustc_typeck::expr_use_visitor::*; use std::iter::{once, Iterator}; use std::mem; use syntax::ast; @@ -1586,11 +1584,11 @@ struct MutatePairDelegate { } impl<'tcx> Delegate<'tcx> for MutatePairDelegate { - fn consume(&mut self, _: &cmt_<'tcx>, _: ConsumeMode) {} + fn consume(&mut self, _: &Place<'tcx>, _: ConsumeMode) {} - fn borrow(&mut self, cmt: &cmt_<'tcx>, bk: ty::BorrowKind) { + fn borrow(&mut self, cmt: &Place<'tcx>, bk: ty::BorrowKind) { if let ty::BorrowKind::MutBorrow = bk { - if let Categorization::Local(id) = cmt.cat { + if let PlaceBase::Local(id) = cmt.base { if Some(id) == self.hir_id_low { self.span_low = Some(cmt.span) } @@ -1601,8 +1599,8 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate { } } - fn mutate(&mut self, cmt: &cmt_<'tcx>) { - if let Categorization::Local(id) = cmt.cat { + fn mutate(&mut self, cmt: &Place<'tcx>) { + if let PlaceBase::Local(id) = cmt.base { if Some(id) == self.hir_id_low { self.span_low = Some(cmt.span) } @@ -1680,16 +1678,9 @@ fn check_for_mutation( span_high: None, }; let def_id = def_id::DefId::local(body.hir_id.owner); - let region_scope_tree = &cx.tcx.region_scope_tree(def_id); - ExprUseVisitor::new( - &mut delegate, - cx.tcx, - def_id, - cx.param_env, - region_scope_tree, - cx.tables, - ) - .walk_expr(body); + cx.tcx.infer_ctxt().enter(|infcx| { + ExprUseVisitor::new(&mut delegate, &infcx, def_id, cx.param_env, cx.tables).walk_expr(body); + }); delegate.mutation_span() } diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs index 80f178289e4d..05894de5cb70 100644 --- a/clippy_lints/src/needless_pass_by_value.rs +++ b/clippy_lints/src/needless_pass_by_value.rs @@ -8,14 +8,13 @@ use matches::matches; use rustc::hir::intravisit::FnKind; use rustc::hir::*; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::middle::expr_use_visitor as euv; -use rustc::middle::mem_categorization as mc; use rustc::traits; use rustc::ty::{self, RegionKind, TypeFoldable}; use rustc::{declare_lint_pass, declare_tool_lint}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::Applicability; use rustc_target::spec::abi::Abi; +use rustc_typeck::expr_use_visitor as euv; use std::borrow::Cow; use syntax::ast::Attribute; use syntax::errors::DiagnosticBuilder; @@ -135,9 +134,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue { .. } = { let mut ctx = MovedVariablesCtxt::default(); - let region_scope_tree = &cx.tcx.region_scope_tree(fn_def_id); - euv::ExprUseVisitor::new(&mut ctx, cx.tcx, fn_def_id, cx.param_env, region_scope_tree, cx.tables) - .consume_body(body); + cx.tcx.infer_ctxt().enter(|infcx| { + euv::ExprUseVisitor::new(&mut ctx, &infcx, fn_def_id, cx.param_env, cx.tables).consume_body(body); + }); ctx }; @@ -326,34 +325,21 @@ struct MovedVariablesCtxt { } impl MovedVariablesCtxt { - fn move_common(&mut self, cmt: &mc::cmt_<'_>) { - let cmt = unwrap_downcast_or_interior(cmt); - - if let mc::Categorization::Local(vid) = cmt.cat { + fn move_common(&mut self, cmt: &euv::Place<'_>) { + if let euv::PlaceBase::Local(vid) = cmt.base { self.moved_vars.insert(vid); } } } impl<'tcx> euv::Delegate<'tcx> for MovedVariablesCtxt { - fn consume(&mut self, cmt: &mc::cmt_<'tcx>, mode: euv::ConsumeMode) { + fn consume(&mut self, cmt: &euv::Place<'tcx>, mode: euv::ConsumeMode) { if let euv::ConsumeMode::Move = mode { self.move_common(cmt); } } - fn borrow(&mut self, _: &mc::cmt_<'tcx>, _: ty::BorrowKind) {} - - fn mutate(&mut self, _: &mc::cmt_<'tcx>) {} -} + fn borrow(&mut self, _: &euv::Place<'tcx>, _: ty::BorrowKind) {} -fn unwrap_downcast_or_interior<'a, 'tcx>(mut cmt: &'a mc::cmt_<'tcx>) -> mc::cmt_<'tcx> { - loop { - match cmt.cat { - mc::Categorization::Downcast(ref c, _) | mc::Categorization::Interior(ref c, _) => { - cmt = c; - }, - _ => return (*cmt).clone(), - } - } + fn mutate(&mut self, _: &euv::Place<'tcx>) {} } diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs index 41662099fd3d..089ebafbb7fd 100644 --- a/clippy_lints/src/utils/usage.rs +++ b/clippy_lints/src/utils/usage.rs @@ -1,11 +1,9 @@ use rustc::hir::def::Res; use rustc::hir::*; use rustc::lint::LateContext; -use rustc::middle::expr_use_visitor::*; -use rustc::middle::mem_categorization::cmt_; -use rustc::middle::mem_categorization::Categorization; use rustc::ty; use rustc_data_structures::fx::FxHashSet; +use rustc_typeck::expr_use_visitor::*; /// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined. pub fn mutated_variables<'a, 'tcx>(expr: &'tcx Expr, cx: &'a LateContext<'a, 'tcx>) -> Option> { @@ -14,16 +12,9 @@ pub fn mutated_variables<'a, 'tcx>(expr: &'tcx Expr, cx: &'a LateContext<'a, 'tc skip: false, }; let def_id = def_id::DefId::local(expr.hir_id.owner); - let region_scope_tree = &cx.tcx.region_scope_tree(def_id); - ExprUseVisitor::new( - &mut delegate, - cx.tcx, - def_id, - cx.param_env, - region_scope_tree, - cx.tables, - ) - .walk_expr(expr); + cx.tcx.infer_ctxt().enter(|infcx| { + ExprUseVisitor::new(&mut delegate, &infcx, def_id, cx.param_env, cx.tables).walk_expr(expr); + }); if delegate.skip { return None; @@ -46,33 +37,32 @@ struct MutVarsDelegate { impl<'tcx> MutVarsDelegate { #[allow(clippy::similar_names)] - fn update(&mut self, cat: &'tcx Categorization<'_>) { - match *cat { - Categorization::Local(id) => { + fn update(&mut self, cat: &Place<'tcx>) { + match cat.base { + PlaceBase::Local(id) => { self.used_mutably.insert(id); }, - Categorization::Upvar(_) => { + PlaceBase::Upvar(_) => { //FIXME: This causes false negatives. We can't get the `NodeId` from //`Categorization::Upvar(_)`. So we search for any `Upvar`s in the //`while`-body, not just the ones in the condition. self.skip = true }, - Categorization::Deref(ref cmt, _) | Categorization::Interior(ref cmt, _) => self.update(&cmt.cat), _ => {}, } } } impl<'tcx> Delegate<'tcx> for MutVarsDelegate { - fn consume(&mut self, _: &cmt_<'tcx>, _: ConsumeMode) {} + fn consume(&mut self, _: &Place<'tcx>, _: ConsumeMode) {} - fn borrow(&mut self, cmt: &cmt_<'tcx>, bk: ty::BorrowKind) { + fn borrow(&mut self, cmt: &Place<'tcx>, bk: ty::BorrowKind) { if let ty::BorrowKind::MutBorrow = bk { - self.update(&cmt.cat) + self.update(&cmt) } } - fn mutate(&mut self, cmt: &cmt_<'tcx>) { - self.update(&cmt.cat) + fn mutate(&mut self, cmt: &Place<'tcx>) { + self.update(&cmt) } }