X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fneedless_pass_by_value.rs;h=dc18a745c265127d57b82cddd715f16f6e778d2a;hb=2ff568d746e4641b992c0b74bea046e43a637997;hp=80f178289e4d3d3f87ebc4704c68ee3f0d2c88a6;hpb=bbad77a12a117937fcaa98bab4ab87805419c391;p=rust.git diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs index 80f178289e4..dc18a745c26 100644 --- a/clippy_lints/src/needless_pass_by_value.rs +++ b/clippy_lints/src/needless_pass_by_value.rs @@ -4,22 +4,21 @@ snippet, snippet_opt, span_lint_and_then, }; use if_chain::if_chain; -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::ty::{self, TypeFoldable}; +use rustc_ast::ast::Attribute; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use rustc_errors::Applicability; +use rustc_errors::{Applicability, DiagnosticBuilder}; +use rustc_hir::intravisit::FnKind; +use rustc_hir::{BindingAnnotation, Body, FnDecl, GenericArg, HirId, ItemKind, Node, PatKind, QPath, TyKind}; +use rustc_infer::infer::TyCtxtInferExt; +use rustc_lint::{LateContext, LateLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; +use rustc_span::{Span, Symbol}; use rustc_target::spec::abi::Abi; +use rustc_trait_selection::traits; +use rustc_trait_selection::traits::misc::can_type_implement_copy; +use rustc_typeck::expr_use_visitor as euv; use std::borrow::Cow; -use syntax::ast::Attribute; -use syntax::errors::DiagnosticBuilder; -use syntax_pos::{Span, Symbol}; declare_clippy_lint! { /// **What it does:** Checks for functions taking arguments by value, but not @@ -71,8 +70,8 @@ fn check_fn( &mut self, cx: &LateContext<'a, 'tcx>, kind: FnKind<'tcx>, - decl: &'tcx FnDecl, - body: &'tcx Body, + decl: &'tcx FnDecl<'_>, + body: &'tcx Body<'_>, span: Span, hir_id: HirId, ) { @@ -92,7 +91,7 @@ fn check_fn( // Exclude non-inherent impls if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) { - if matches!(item.kind, ItemKind::Impl(_, _, _, _, Some(_), _, _) | + if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), .. } | ItemKind::Trait(..)) { return; @@ -115,7 +114,7 @@ fn check_fn( let preds = traits::elaborate_predicates(cx.tcx, cx.param_env.caller_bounds.to_vec()) .filter(|p| !p.is_global()) .filter_map(|pred| { - if let ty::Predicate::Trait(poly_trait_ref) = pred { + if let ty::Predicate::Trait(poly_trait_ref, _) = pred { if poly_trait_ref.def_id() == sized_trait || poly_trait_ref.skip_binder().has_escaping_bound_vars() { return None; @@ -135,16 +134,16 @@ fn check_fn( .. } = { 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 }; let fn_sig = cx.tcx.fn_sig(fn_def_id); let fn_sig = cx.tcx.erase_late_bound_regions(&fn_sig); - for (idx, ((input, &ty), arg)) in decl.inputs.iter().zip(fn_sig.inputs()).zip(&body.params).enumerate() { + for (idx, ((input, &ty), arg)) in decl.inputs.iter().zip(fn_sig.inputs()).zip(body.params).enumerate() { // All spans generated from a proc-macro invocation are the same... if span == input.span { return; @@ -171,8 +170,9 @@ fn check_fn( ( preds.iter().any(|t| t.def_id() == borrow_trait), - !preds.is_empty() - && preds.iter().all(|t| { + !preds.is_empty() && { + let ty_empty_region = cx.tcx.mk_imm_ref(cx.tcx.lifetimes.re_root_empty, ty); + preds.iter().all(|t| { let ty_params = &t .skip_binder() .trait_ref @@ -181,8 +181,9 @@ fn check_fn( .skip(1) .cloned() .collect::>(); - implements_trait(cx, cx.tcx.mk_imm_ref(&RegionKind::ReEmpty, ty), t.def_id(), ty_params) - }), + implements_trait(cx, ty_empty_region, t.def_id(), ty_params) + }) + }, ) }; @@ -205,8 +206,8 @@ fn check_fn( let sugg = |db: &mut DiagnosticBuilder<'_>| { if let ty::Adt(def, ..) = ty.kind { if let Some(span) = cx.tcx.hir().span_if_local(def.did) { - if cx.param_env.can_type_implement_copy(cx.tcx, ty).is_ok() { - db.span_help(span, "consider marking this type as Copy"); + if can_type_implement_copy(cx.tcx, cx.param_env, ty).is_ok() { + db.span_help(span, "consider marking this type as `Copy`"); } } } @@ -326,34 +327,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>) {} }