X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fptr.rs;h=2ecdf983e6bdafd76ad6f91d7a4bdd1bc9d00e69;hb=5d4102ee786dea507dc42e1c4968b959767abdbd;hp=03c94cbf3fbd747b5db7b51cb9bed6000be33b20;hpb=387efd459c0ad3db7af15f1a573057b8587f9748;p=rust.git diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index 03c94cbf3fb..2ecdf983e6b 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -2,16 +2,15 @@ use std::borrow::Cow; use rustc::hir::*; -use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; use rustc::hir::map::NodeItem; +use rustc::hir::QPath; use rustc::lint::*; use rustc::ty; -use syntax::ast::{Name, NodeId}; +use syntax::ast::NodeId; use syntax::codemap::Span; use syntax_pos::MultiSpan; -use utils::{get_pat_name, match_qpath, match_type, match_var, paths, - snippet, snippet_opt, span_lint, span_lint_and_then, - walk_ptrs_hir_ty}; +use crate::utils::{match_qpath, match_type, paths, snippet_opt, span_lint, span_lint_and_then, walk_ptrs_hir_ty}; +use crate::utils::ptr::get_spans; /// **What it does:** This lint checks for function arguments of type `&String` /// or `&Vec` unless the references are mutable. It will also suggest you @@ -43,9 +42,9 @@ /// ```rust /// fn foo(&Vec) { .. } /// ``` -declare_lint! { +declare_clippy_lint! { pub PTR_ARG, - Warn, + style, "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` \ instead, respectively" } @@ -62,9 +61,9 @@ /// ```rust /// if x == ptr::null { .. } /// ``` -declare_lint! { +declare_clippy_lint! { pub CMP_NULL, - Warn, + style, "comparing a pointer to a null pointer, suggesting to use `.is_null()` instead." } @@ -87,9 +86,9 @@ /// ```rust /// fn foo(&Foo) -> &mut Bar { .. } /// ``` -declare_lint! { +declare_clippy_lint! { pub MUT_FROM_REF, - Warn, + correctness, "fns that create mutable refs from immutable ref args" } @@ -104,7 +103,7 @@ fn get_lints(&self) -> LintArray { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PointerPass { fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { - if let ItemFn(ref decl, _, _, _, _, body_id) = item.node { + if let ItemFn(ref decl, _, _, body_id) = item.node { check_fn(cx, decl, item.id, Some(body_id)); } } @@ -122,14 +121,18 @@ fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { if let TraitItemKind::Method(ref sig, ref trait_method) = item.node { - let body_id = if let TraitMethod::Provided(b) = *trait_method { Some(b) } else { None }; + let body_id = if let TraitMethod::Provided(b) = *trait_method { + Some(b) + } else { + None + }; check_fn(cx, &sig.decl, item.id, body_id); } } fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { - if let ExprBinary(ref op, ref l, ref r) = expr.node { - if (op.node == BiEq || op.node == BiNe) && (is_null_path(l) || is_null_path(r)) { + if let ExprKind::Binary(ref op, ref l, ref r) = expr.node { + if (op.node == BinOpKind::Eq || op.node == BinOpKind::Ne) && (is_null_path(l) || is_null_path(r)) { span_lint( cx, CMP_NULL, @@ -149,22 +152,26 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId, opt_body_id: Option< for (idx, (arg, ty)) in decl.inputs.iter().zip(fn_ty.inputs()).enumerate() { if let ty::TyRef( _, - ty::TypeAndMut { - ty, - mutbl: MutImmutable, - }, + ty, + MutImmutable ) = ty.sty { if match_type(cx, ty, &paths::VEC) { let mut ty_snippet = None; - if_let_chain!([ - let TyPath(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).node, - let Some(&PathSegment{parameters: Some(ref parameters), ..}) = path.segments.last(), - parameters.types.len() == 1, - ], { - ty_snippet = snippet_opt(cx, parameters.types[0].span); - }); - if let Ok(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_owned()")]) { + if_chain! { + if let TyPath(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).node; + if let Some(&PathSegment{args: Some(ref parameters), ..}) = path.segments.last(); + then { + let types: Vec<_> = parameters.args.iter().filter_map(|arg| match arg { + GenericArg::Type(ty) => Some(ty), + _ => None, + }).collect(); + if types.len() == 1 { + ty_snippet = snippet_opt(cx, types[0].span); + } + } + }; + if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_owned()")]) { span_lint_and_then( cx, PTR_ARG, @@ -173,39 +180,70 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId, opt_body_id: Option< with non-Vec-based slices.", |db| { if let Some(ref snippet) = ty_snippet { - db.span_suggestion(arg.span, - "change this to", - format!("&[{}]", snippet)); + db.span_suggestion(arg.span, "change this to", format!("&[{}]", snippet)); } for (clonespan, suggestion) in spans { - db.span_suggestion(clonespan, - &snippet_opt(cx, clonespan).map_or("change the call to".into(), - |x| Cow::Owned(format!("change `{}` to", x))), - suggestion.into()); + db.span_suggestion( + clonespan, + &snippet_opt(cx, clonespan).map_or( + "change the call to".into(), + |x| Cow::Owned(format!("change `{}` to", x)), + ), + suggestion.into(), + ); } - } + }, ); } } else if match_type(cx, ty, &paths::STRING) { - if let Ok(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_string()"), ("as_str", "")]) { + if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_string()"), ("as_str", "")]) { span_lint_and_then( cx, PTR_ARG, arg.span, "writing `&String` instead of `&str` involves a new object where a slice will do.", |db| { - db.span_suggestion(arg.span, - "change this to", - "&str".into()); + db.span_suggestion(arg.span, "change this to", "&str".into()); for (clonespan, suggestion) in spans { - db.span_suggestion_short(clonespan, - &snippet_opt(cx, clonespan).map_or("change the call to".into(), - |x| Cow::Owned(format!("change `{}` to", x))), - suggestion.into()); + db.span_suggestion_short( + clonespan, + &snippet_opt(cx, clonespan).map_or( + "change the call to".into(), + |x| Cow::Owned(format!("change `{}` to", x)), + ), + suggestion.into(), + ); } - } + }, ); } + } else if match_type(cx, ty, &paths::COW) { + if_chain! { + if let TyRptr(_, MutTy { ref ty, ..} ) = arg.node; + if let TyPath(ref path) = ty.node; + if let QPath::Resolved(None, ref pp) = *path; + if let [ref bx] = *pp.segments; + if let Some(ref params) = bx.args; + if !params.parenthesized; + if let Some(inner) = params.args.iter().find_map(|arg| match arg { + GenericArg::Type(ty) => Some(ty), + GenericArg::Lifetime(_) => None, + }); + then { + let replacement = snippet_opt(cx, inner.span); + if let Some(r) = replacement { + span_lint_and_then( + cx, + PTR_ARG, + arg.span, + "using a reference to `Cow` is not recommended.", + |db| { + db.span_suggestion(arg.span, "change this to", "&".to_owned() + &r); + }, + ); + } + } + } } } } @@ -234,66 +272,6 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId, opt_body_id: Option< } } -fn get_spans(cx: &LateContext, opt_body_id: Option, idx: usize, replacements: &'static [(&'static str, &'static str)]) -> Result)>, ()> { - if let Some(body) = opt_body_id.map(|id| cx.tcx.hir.body(id)) { - get_binding_name(&body.arguments[idx]).map_or_else(|| Ok(vec![]), - |name| extract_clone_suggestions(cx, name, replacements, body)) - } else { - Ok(vec![]) - } -} - -fn extract_clone_suggestions<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, name: Name, replace: &'static [(&'static str, &'static str)], body: &'tcx Body) -> Result)>, ()> { - let mut visitor = PtrCloneVisitor { - cx, - name, - replace, - spans: vec![], - abort: false, - }; - visitor.visit_body(body); - if visitor.abort { Err(()) } else { Ok(visitor.spans) } -} - -struct PtrCloneVisitor<'a, 'tcx: 'a> { - cx: &'a LateContext<'a, 'tcx>, - name: Name, - replace: &'static [(&'static str, &'static str)], - spans: Vec<(Span, Cow<'static, str>)>, - abort: bool, -} - -impl<'a, 'tcx: 'a> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> { - fn visit_expr(&mut self, expr: &'tcx Expr) { - if self.abort { return; } - if let ExprMethodCall(ref seg, _, ref args) = expr.node { - if args.len() == 1 && match_var(&args[0], self.name) { - if seg.name == "capacity" { - self.abort = true; - return; - } - for &(fn_name, suffix) in self.replace { - if seg.name == fn_name { - self.spans.push((expr.span, snippet(self.cx, args[0].span, "_") + suffix)); - return; - } - } - } - return; - } - walk_expr(self, expr); - } - - fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { - NestedVisitorMap::None - } - -} - -fn get_binding_name(arg: &Arg) -> Option { - get_pat_name(&arg.pat) -} - fn get_rptr_lm(ty: &Ty) -> Option<(&Lifetime, Mutability, Span)> { if let Ty_::TyRptr(ref lt, ref m) = ty.node { Some((lt, m.mutbl, ty.span)) @@ -303,9 +281,9 @@ fn get_rptr_lm(ty: &Ty) -> Option<(&Lifetime, Mutability, Span)> { } fn is_null_path(expr: &Expr) -> bool { - if let ExprCall(ref pathexp, ref args) = expr.node { + if let ExprKind::Call(ref pathexp, ref args) = expr.node { if args.is_empty() { - if let ExprPath(ref path) = pathexp.node { + if let ExprKind::Path(ref path) = pathexp.node { return match_qpath(path, &paths::PTR_NULL) || match_qpath(path, &paths::PTR_NULL_MUT); } }