fixup! Add invalid null pointer usage lint.

Author: boxdot

clippy_lints/src/ptr.rs

@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_the
 use clippy_utils::ptr::get_spans;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
-use clippy_utils::{is_allowed, match_function_call, match_qpath, paths};
+use clippy_utils::{is_allowed, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -174,7 +174,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Binary(ref op, l, r) = expr.kind {
-            if (op.node == BinOpKind::Eq || op.node == BinOpKind::Ne) && (is_null_path(l) || is_null_path(r)) {
+            if (op.node == BinOpKind::Eq || op.node == BinOpKind::Ne) && (is_null_path(cx, l) || is_null_path(cx, r)) {
                 span_lint(
                     cx,
                     CMP_NULL,
@@ -188,47 +188,56 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
     }
 }
 
-fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<()> {
-    // fn_name, arg_idx
-    const INVALID_NULL_PTR_USAGE_TABLE: [(&[&str], usize); 20] = [
-        (&paths::SLICE_FROM_RAW_PARTS, 0),
-        (&paths::SLICE_FROM_RAW_PARTS_MUT, 0),
-        (&paths::PTR_COPY, 0),
-        (&paths::PTR_COPY, 1),
-        (&paths::PTR_COPY_NONOVERLAPPING, 0),
-        (&paths::PTR_COPY_NONOVERLAPPING, 1),
-        (&paths::PTR_READ, 0),
-        (&paths::PTR_READ_UNALIGNED, 0),
-        (&paths::PTR_READ_VOLATILE, 0),
-        (&paths::PTR_REPLACE, 0),
-        (&paths::PTR_SLICE_FROM_RAW_PARTS, 0),
-        (&paths::PTR_SLICE_FROM_RAW_PARTS_MUT, 0),
-        (&paths::PTR_SWAP, 0),
-        (&paths::PTR_SWAP, 1),
-        (&paths::PTR_SWAP_NONOVERLAPPING, 0),
-        (&paths::PTR_SWAP_NONOVERLAPPING, 1),
-        (&paths::PTR_WRITE, 0),
-        (&paths::PTR_WRITE_UNALIGNED, 0),
-        (&paths::PTR_WRITE_VOLATILE, 0),
-        (&paths::PTR_WRITE_BYTES, 0),
+fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    // (fn_path, arg_idx, num_args) -
+    //   `arg_idx` is the `arg` position where null would cause U.B.
+    //   `num_args` is the numbers of arguments of the function
+    const INVALID_NULL_PTR_USAGE_TABLE: [(&[&str], usize, usize); 20] = [
+        (&paths::SLICE_FROM_RAW_PARTS, 0, 2),
+        (&paths::SLICE_FROM_RAW_PARTS_MUT, 0, 2),
+        (&paths::PTR_COPY, 0, 3),
+        (&paths::PTR_COPY, 1, 3),
+        (&paths::PTR_COPY_NONOVERLAPPING, 0, 3),
+        (&paths::PTR_COPY_NONOVERLAPPING, 1, 3),
+        (&paths::PTR_READ, 0, 1),
+        (&paths::PTR_READ_UNALIGNED, 0, 1),
+        (&paths::PTR_READ_VOLATILE, 0, 1),
+        (&paths::PTR_REPLACE, 0, 2),
+        (&paths::PTR_SLICE_FROM_RAW_PARTS, 0, 2),
+        (&paths::PTR_SLICE_FROM_RAW_PARTS_MUT, 0, 2),
+        (&paths::PTR_SWAP, 0, 2),
+        (&paths::PTR_SWAP, 1, 2),
+        (&paths::PTR_SWAP_NONOVERLAPPING, 0, 3),
+        (&paths::PTR_SWAP_NONOVERLAPPING, 1, 3),
+        (&paths::PTR_WRITE, 0, 2),
+        (&paths::PTR_WRITE_UNALIGNED, 0, 2),
+        (&paths::PTR_WRITE_VOLATILE, 0, 2),
+        (&paths::PTR_WRITE_BYTES, 0, 3),
     ];
 
-    let arg = INVALID_NULL_PTR_USAGE_TABLE.iter().find_map(|(fn_name, arg_idx)| {
-        let args = match_function_call(cx, expr, fn_name)?;
-        args.get(*arg_idx).filter(|arg| is_null_path(arg))
-    })?;
-
-    span_lint_and_sugg(
-        cx,
-        INVALID_NULL_PTR_USAGE,
-        arg.span,
-        "pointer must be non-null",
-        "change this to",
-        "core::ptr::NonNull::dangling().as_ptr()".to_string(),
-        Applicability::MachineApplicable,
-    );
-
-    Some(())
+    for (fn_path, arg_idx, num_args) in &INVALID_NULL_PTR_USAGE_TABLE {
+        if_chain! {
+            if let ExprKind::Call(ref fun, ref args) = expr.kind;
+            if args.len() == *num_args;
+            if let ExprKind::Path(ref qpath) = fun.kind;
+            if let Some(arg) = args.get(*arg_idx);
+            if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+            if match_def_path(cx, fun_def_id, fn_path);
+            if is_null_path(cx, arg);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    INVALID_NULL_PTR_USAGE,
+                    arg.span,
+                    "pointer must be non-null",
+                    "change this to",
+                    "core::ptr::NonNull::dangling().as_ptr()".to_string(),
+                    Applicability::MachineApplicable,
+                );
+                return;
+            }
+        }
+    }
 }
 
 #[allow(clippy::too_many_lines)]
@@ -411,16 +420,16 @@ fn get_rptr_lm<'tcx>(ty: &'tcx Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability,
     }
 }
 
-fn is_null_path(expr: &Expr<'_>) -> bool {
-    if let ExprKind::Call(pathexp, args) = expr.kind {
-        if args.is_empty() {
-            if let ExprKind::Path(ref path) = pathexp.kind {
-                return match_qpath(path, &paths::PTR_NULL)
-                    || match_qpath(path, &paths::PTR_NULL_MUT)
-                    || match_qpath(path, &paths::STD_PTR_NULL)
-                    || match_qpath(path, &paths::STD_PTR_NULL_MUT);
-            }
+fn is_null_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if_chain! {
+        if let ExprKind::Call(path, args) = expr.kind;
+        if args.is_empty();
+        if let ExprKind::Path(ref qpath) = path.kind;
+        if let Some(fn_def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
+        then {
+            match_def_path(cx, fn_def_id, &paths::PTR_NULL) || match_def_path(cx, fn_def_id, &paths::PTR_NULL_MUT)
+        } else {
+            false
         }
     }
-    false
 }