Make the unsafe_sizeof_count_copies lint work with more functions

Specifically:
 - find std::ptr::write_bytes
 - find std::ptr::swap_nonoverlapping
 - find std::ptr::slice_from_raw_parts
 - find std::ptr::slice_from_raw_parts_mut
 - pointer_primitive::write_bytes

Author: nico-abram

clippy_lints/src/unsafe_sizeof_count_copies.rs

@@ -41,8 +41,8 @@ declare_clippy_lint! {
 declare_lint_pass!(UnsafeSizeofCountCopies => [UNSAFE_SIZEOF_COUNT_COPIES]);
 
 fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tcx>> {
-    match &expr.kind {
-        ExprKind::Call(ref count_func, _func_args) => {
+    match expr.kind {
+        ExprKind::Call(count_func, _func_args) => {
             if_chain! {
                 if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
                 if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
@@ -56,21 +56,24 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tc
             }
         },
         ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
-            get_size_of_ty(cx, &*left).or_else(|| get_size_of_ty(cx, &*right))
+            get_size_of_ty(cx, left).or_else(|| get_size_of_ty(cx, right))
         },
         _ => None,
     }
 }
 
 fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
     if_chain! {
-        // Find calls to ptr::copy and copy_nonoverlapping
-        if let ExprKind::Call(ref func, ref args) = expr.kind;
-        if let [_src, _dest, count] = &**args;
+        // Find calls to ptr::{copy, copy_nonoverlapping}
+        // and ptr::{swap_nonoverlapping, write_bytes},
+        if let ExprKind::Call(func, args) = expr.kind;
+        if let [_, _, count] = args;
         if let ExprKind::Path(ref func_qpath) = func.kind;
         if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
         if match_def_path(cx, def_id, &paths::COPY_NONOVERLAPPING)
-            || match_def_path(cx, def_id, &paths::COPY);
+            || match_def_path(cx, def_id, &paths::COPY)
+            || match_def_path(cx, def_id, &paths::WRITE_BYTES)
+            || match_def_path(cx, def_id, &paths::PTR_SWAP_NONOVERLAPPING);
 
         // Get the pointee type
         if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
@@ -79,11 +82,11 @@ fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -
         }
     };
     if_chain! {
-        // Find calls to copy_{from,to}{,_nonoverlapping}
-        if let ExprKind::MethodCall(ref method_path, _, ref args, _) = expr.kind;
-        if let [ptr_self, _, count] = &**args;
+        // Find calls to copy_{from,to}{,_nonoverlapping} and write_bytes methods
+        if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind;
+        if let [ptr_self, _, count] = args;
         let method_ident = method_path.ident.as_str();
-        if method_ident== "copy_to" || method_ident == "copy_from"
+        if method_ident == "write_bytes" || method_ident == "copy_to" || method_ident == "copy_from"
             || method_ident == "copy_to_nonoverlapping" || method_ident == "copy_from_nonoverlapping";
 
         // Get the pointee type
@@ -93,6 +96,21 @@ fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -
             return Some((pointee_ty, count));
         }
     };
+    if_chain! {
+        // Find calls to ptr::copy and copy_nonoverlapping
+        if let ExprKind::Call(func, args) = expr.kind;
+        if let [_data, count] = args;
+        if let ExprKind::Path(ref func_qpath) = func.kind;
+        if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
+        if match_def_path(cx, def_id, &paths::PTR_SLICE_FROM_RAW_PARTS)
+            || match_def_path(cx, def_id, &paths::PTR_SLICE_FROM_RAW_PARTS_MUT);
+
+        // Get the pointee type
+        if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
+        then {
+            return Some((pointee_ty, count));
+        }
+    };
     None
 }
 
@@ -102,7 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for UnsafeSizeofCountCopies {
             for the count parameter, it already gets multiplied by the size of the pointed to type";
 
         const LINT_MSG: &str = "unsafe memory copying using a byte count \
-            (Multiplied by size_of::<T>) instead of a count of T";
+            (multiplied by size_of/size_of_val::<T>) instead of a count of T";
 
         if_chain! {
             // Find calls to unsafe copy functions and get

clippy_lints/src/utils/paths.rs

@@ -101,6 +101,9 @@ pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
 pub const PTR_NULL: [&str; 3] = ["core", "ptr", "null"];
 pub const PTR_NULL_MUT: [&str; 3] = ["core", "ptr", "null_mut"];
+pub const PTR_SLICE_FROM_RAW_PARTS: [&str; 3] = ["core", "ptr", "slice_from_raw_parts"];
+pub const PTR_SLICE_FROM_RAW_PARTS_MUT: [&str; 3] = ["core", "ptr", "slice_from_raw_parts_mut"];
+pub const PTR_SWAP_NONOVERLAPPING: [&str; 3] = ["core", "ptr", "swap_nonoverlapping"];
 pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RC: [&str; 3] = ["alloc", "rc", "Rc"];
@@ -154,3 +157,4 @@ pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
+pub const WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];

tests/ui/unsafe_sizeof_count_copies.rs

@@ -1,7 +1,9 @@
 #![warn(clippy::unsafe_sizeof_count_copies)]
 
 use std::mem::{size_of, size_of_val};
-use std::ptr::{copy, copy_nonoverlapping};
+use std::ptr::{
+    copy, copy_nonoverlapping, slice_from_raw_parts, slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes,
+};
 
 fn main() {
     const SIZE: usize = 128;
@@ -22,6 +24,14 @@ fn main() {
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
 
+    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
+    unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
+
+    unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
+
+    unsafe { slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+    unsafe { slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
+
     // Count expression involving multiplication of size_of (Should trigger the lint)
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };