Auto merge of #6578 - MarijnS95:size-in-element-count-divide-by-byte-size, r=flip1995

bors · bors · commit fb0d7f171402 · 2021-01-20T07:24:34.000Z
size_of_in_element_count: Disable lint on division by byte-size Fixes #6511 It is fairly common to divide some length in bytes by the byte-size of a single element before creating a `from_raw_parts` slice or similar operation. This lint would erroneously disallow such expressions. Just in case, instead of simply disabling this lint in the RHS of a division, keep track of the inversion and enable it again on recursive division. --- changelog: Do not trigger size_of_in_element_count when dividing by element size
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
@@ -35,10 +35,11 @@ declare_clippy_lint! {
 
 declare_lint_pass!(SizeOfInElementCount => [SIZE_OF_IN_ELEMENT_COUNT]);
 
-fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tcx>> {
+fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool) -> Option<Ty<'tcx>> {
     match expr.kind {
         ExprKind::Call(count_func, _func_args) => {
             if_chain! {
+                if !inverted;
                 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();
                 if match_def_path(cx, def_id, &paths::MEM_SIZE_OF)
@@ -50,10 +51,13 @@ 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))
+        ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node => {
+            get_size_of_ty(cx, left, inverted).or_else(|| get_size_of_ty(cx, right, inverted))
         },
-        ExprKind::Cast(expr, _) => get_size_of_ty(cx, expr),
+        ExprKind::Binary(op, left, right) if BinOpKind::Div == op.node => {
+            get_size_of_ty(cx, left, inverted).or_else(|| get_size_of_ty(cx, right, !inverted))
+        },
+        ExprKind::Cast(expr, _) => get_size_of_ty(cx, expr, inverted),
         _ => None,
     }
 }
@@ -128,7 +132,7 @@ impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
 
             // Find a size_of call in the count parameter expression and
             // check that it's the same type
-            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr);
+            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr, false);
             if TyS::same_type(pointee_ty, ty_used_for_size_of);
             then {
                 span_lint_and_help(
diff --git a/tests/ui/size_of_in_element_count/expressions.rs b/tests/ui/size_of_in_element_count/expressions.rs
@@ -0,0 +1,37 @@
+#![warn(clippy::size_of_in_element_count)]
+#![allow(clippy::ptr_offset_with_cast)]
+
+use std::mem::{size_of, size_of_val};
+use std::ptr::{copy, copy_nonoverlapping, write_bytes};
+
+fn main() {
+    const SIZE: usize = 128;
+    const HALF_SIZE: usize = SIZE / 2;
+    const DOUBLE_SIZE: usize = SIZE * 2;
+    let mut x = [2u8; SIZE];
+    let mut y = [2u8; 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) };
+
+    // Count expression involving nested multiplications of size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
+
+    // Count expression involving divisions of size_of (Should trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
+
+    // Count expression involving divisions by size_of (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / size_of::<u8>()) };
+
+    // Count expression involving divisions by multiple size_of (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 * size_of::<u8>())) };
+
+    // Count expression involving recursive divisions by size_of (Should trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 / size_of::<u8>())) };
+
+    // No size_of calls (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
+
+    // Different types for pointee and size_of (Should not trigger the lint)
+    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u16>() / 2 * SIZE) };
+}
diff --git a/tests/ui/size_of_in_element_count/expressions.stderr b/tests/ui/size_of_in_element_count/expressions.stderr
@@ -0,0 +1,35 @@
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:15:62
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |                                                              ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::size-of-in-element-count` implied by `-D warnings`
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:18:62
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
+   |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:21:47
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:30:47
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 / size_of::<u8>())) };
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/size_of_in_element_count/functions.rs b/tests/ui/size_of_in_element_count/functions.rs
@@ -43,19 +43,4 @@ fn main() {
     y.as_mut_ptr().wrapping_add(size_of::<u8>());
     unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
     y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
-
-    // 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) };
-
-    // Count expression involving nested multiplications of size_of (Should trigger the lint)
-    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
-
-    // Count expression involving divisions of size_of (Should trigger the lint)
-    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
-
-    // No size_of calls (Should not trigger the lint)
-    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
-
-    // Different types for pointee and size_of (Should not trigger the lint)
-    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u16>() / 2 * SIZE) };
 }
diff --git a/tests/ui/size_of_in_element_count/functions.stderr b/tests/ui/size_of_in_element_count/functions.stderr
@@ -1,5 +1,5 @@
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:18:68
+  --> $DIR/functions.rs:18:68
    |
 LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |                                                                    ^^^^^^^^^^^^^^^
@@ -8,188 +8,164 @@ LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of:
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:19:62
+  --> $DIR/functions.rs:19:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |                                                              ^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:21:49
+  --> $DIR/functions.rs:21:49
    |
 LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
    |                                                 ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:22:64
+  --> $DIR/functions.rs:22:64
    |
 LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
    |                                                                ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:23:51
+  --> $DIR/functions.rs:23:51
    |
 LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
    |                                                   ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:24:66
+  --> $DIR/functions.rs:24:66
    |
 LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
    |                                                                  ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:26:47
+  --> $DIR/functions.rs:26:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |                                               ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:27:47
+  --> $DIR/functions.rs:27:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |                                               ^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:29:46
+  --> $DIR/functions.rs:29:46
    |
 LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
    |                                              ^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:30:47
+  --> $DIR/functions.rs:30:47
    |
 LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
    |                                               ^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:32:66
+  --> $DIR/functions.rs:32:66
    |
 LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |                                                                  ^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:34:46
+  --> $DIR/functions.rs:34:46
    |
 LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
    |                                              ^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:35:38
+  --> $DIR/functions.rs:35:38
    |
 LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
    |                                      ^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:37:49
+  --> $DIR/functions.rs:37:49
    |
 LL |     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:38:41
+  --> $DIR/functions.rs:38:41
    |
 LL |     unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:40:33
+  --> $DIR/functions.rs:40:33
    |
 LL |     unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
    |                                 ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:41:29
+  --> $DIR/functions.rs:41:29
    |
 LL |     y.as_ptr().wrapping_sub(size_of::<u8>());
    |                             ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:42:29
+  --> $DIR/functions.rs:42:29
    |
 LL |     unsafe { y.as_ptr().add(size_of::<u8>()) };
    |                             ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:43:33
+  --> $DIR/functions.rs:43:33
    |
 LL |     y.as_mut_ptr().wrapping_add(size_of::<u8>());
    |                                 ^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:44:32
+  --> $DIR/functions.rs:44:32
    |
 LL |     unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:45:36
+  --> $DIR/functions.rs:45:36
    |
 LL |     y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:48:62
-   |
-LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
-   |                                                              ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
-
-error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:51:62
-   |
-LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
-   |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
-
-error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:54:47
-   |
-LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
-   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
-
-error: aborting due to 24 previous errors
+error: aborting due to 21 previous errors
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error: found a count of bytes instead of a count of elements of `T`
`2`		`- --> $DIR/size_of_in_element_count.rs:18:68`
	`2`	`+ --> $DIR/functions.rs:18:68`
`3`	`3`	`\|`
`4`	`4`	`LL \| unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };`
`5`	`5`	`\| ^^^^^^^^^^^^^^^`
`@@ -8,188 +8,164 @@ LL \| unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of:`
`8`	`8`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`9`	`9`
`10`	`10`	error: found a count of bytes instead of a count of elements of `T`
`11`		`- --> $DIR/size_of_in_element_count.rs:19:62`
	`11`	`+ --> $DIR/functions.rs:19:62`
`12`	`12`	`\|`
`13`	`13`	`LL \| unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };`
`14`	`14`	`\| ^^^^^^^^^^^^^^^^^^`
`15`	`15`	`\|`
`16`	`16`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`17`	`17`
`18`	`18`	error: found a count of bytes instead of a count of elements of `T`
`19`		`- --> $DIR/size_of_in_element_count.rs:21:49`
	`19`	`+ --> $DIR/functions.rs:21:49`
`20`	`20`	`\|`
`21`	`21`	`LL \| unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };`
`22`	`22`	`\| ^^^^^^^^^^^^^^^`
`23`	`23`	`\|`
`24`	`24`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`25`	`25`
`26`	`26`	error: found a count of bytes instead of a count of elements of `T`
`27`		`- --> $DIR/size_of_in_element_count.rs:22:64`
	`27`	`+ --> $DIR/functions.rs:22:64`
`28`	`28`	`\|`
`29`	`29`	`LL \| unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };`
`30`	`30`	`\| ^^^^^^^^^^^^^^^`
`31`	`31`	`\|`
`32`	`32`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`33`	`33`
`34`	`34`	error: found a count of bytes instead of a count of elements of `T`
`35`		`- --> $DIR/size_of_in_element_count.rs:23:51`
	`35`	`+ --> $DIR/functions.rs:23:51`
`36`	`36`	`\|`
`37`	`37`	`LL \| unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };`
`38`	`38`	`\| ^^^^^^^^^^^^^^^`
`39`	`39`	`\|`
`40`	`40`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`41`	`41`
`42`	`42`	error: found a count of bytes instead of a count of elements of `T`
`43`		`- --> $DIR/size_of_in_element_count.rs:24:66`
	`43`	`+ --> $DIR/functions.rs:24:66`
`44`	`44`	`\|`
`45`	`45`	`LL \| unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };`
`46`	`46`	`\| ^^^^^^^^^^^^^^^`
`47`	`47`	`\|`
`48`	`48`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`49`	`49`
`50`	`50`	error: found a count of bytes instead of a count of elements of `T`
`51`		`- --> $DIR/size_of_in_element_count.rs:26:47`
	`51`	`+ --> $DIR/functions.rs:26:47`
`52`	`52`	`\|`
`53`	`53`	`LL \| unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };`
`54`	`54`	`\| ^^^^^^^^^^^^^^^`
`55`	`55`	`\|`
`56`	`56`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`57`	`57`
`58`	`58`	error: found a count of bytes instead of a count of elements of `T`
`59`		`- --> $DIR/size_of_in_element_count.rs:27:47`
	`59`	`+ --> $DIR/functions.rs:27:47`
`60`	`60`	`\|`
`61`	`61`	`LL \| unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };`
`62`	`62`	`\| ^^^^^^^^^^^^^^^^^^`
`63`	`63`	`\|`
`64`	`64`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`65`	`65`
`66`	`66`	error: found a count of bytes instead of a count of elements of `T`
`67`		`- --> $DIR/size_of_in_element_count.rs:29:46`
	`67`	`+ --> $DIR/functions.rs:29:46`
`68`	`68`	`\|`
`69`	`69`	`LL \| unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };`
`70`	`70`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`71`	`71`	`\|`
`72`	`72`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`73`	`73`
`74`	`74`	error: found a count of bytes instead of a count of elements of `T`
`75`		`- --> $DIR/size_of_in_element_count.rs:30:47`
	`75`	`+ --> $DIR/functions.rs:30:47`
`76`	`76`	`\|`
`77`	`77`	`LL \| unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };`
`78`	`78`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`79`	`79`	`\|`
`80`	`80`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`81`	`81`
`82`	`82`	error: found a count of bytes instead of a count of elements of `T`
`83`		`- --> $DIR/size_of_in_element_count.rs:32:66`
	`83`	`+ --> $DIR/functions.rs:32:66`
`84`	`84`	`\|`
`85`	`85`	`LL \| unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };`
`86`	`86`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`87`	`87`	`\|`
`88`	`88`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`89`	`89`
`90`	`90`	error: found a count of bytes instead of a count of elements of `T`
`91`		`- --> $DIR/size_of_in_element_count.rs:34:46`
	`91`	`+ --> $DIR/functions.rs:34:46`
`92`	`92`	`\|`
`93`	`93`	`LL \| slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);`
`94`	`94`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`95`	`95`	`\|`
`96`	`96`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`97`	`97`
`98`	`98`	error: found a count of bytes instead of a count of elements of `T`
`99`		`- --> $DIR/size_of_in_element_count.rs:35:38`
	`99`	`+ --> $DIR/functions.rs:35:38`
`100`	`100`	`\|`
`101`	`101`	`LL \| slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);`
`102`	`102`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`103`	`103`	`\|`
`104`	`104`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`105`	`105`
`106`	`106`	error: found a count of bytes instead of a count of elements of `T`
`107`		`- --> $DIR/size_of_in_element_count.rs:37:49`
	`107`	`+ --> $DIR/functions.rs:37:49`
`108`	`108`	`\|`
`109`	`109`	`LL \| unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };`
`110`	`110`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`111`	`111`	`\|`
`112`	`112`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`113`	`113`
`114`	`114`	error: found a count of bytes instead of a count of elements of `T`
`115`		`- --> $DIR/size_of_in_element_count.rs:38:41`
	`115`	`+ --> $DIR/functions.rs:38:41`
`116`	`116`	`\|`
`117`	`117`	`LL \| unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };`
`118`	`118`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`119`	`119`	`\|`
`120`	`120`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`121`	`121`
`122`	`122`	error: found a count of bytes instead of a count of elements of `T`
`123`		`- --> $DIR/size_of_in_element_count.rs:40:33`
	`123`	`+ --> $DIR/functions.rs:40:33`
`124`	`124`	`\|`
`125`	`125`	`LL \| unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };`
`126`	`126`	`\| ^^^^^^^^^^^^^^^`
`127`	`127`	`\|`
`128`	`128`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`129`	`129`
`130`	`130`	error: found a count of bytes instead of a count of elements of `T`
`131`		`- --> $DIR/size_of_in_element_count.rs:41:29`
	`131`	`+ --> $DIR/functions.rs:41:29`
`132`	`132`	`\|`
`133`	`133`	`LL \| y.as_ptr().wrapping_sub(size_of::<u8>());`
`134`	`134`	`\| ^^^^^^^^^^^^^^^`
`135`	`135`	`\|`
`136`	`136`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`137`	`137`
`138`	`138`	error: found a count of bytes instead of a count of elements of `T`
`139`		`- --> $DIR/size_of_in_element_count.rs:42:29`
	`139`	`+ --> $DIR/functions.rs:42:29`
`140`	`140`	`\|`
`141`	`141`	`LL \| unsafe { y.as_ptr().add(size_of::<u8>()) };`
`142`	`142`	`\| ^^^^^^^^^^^^^^^`
`143`	`143`	`\|`
`144`	`144`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`145`	`145`
`146`	`146`	error: found a count of bytes instead of a count of elements of `T`
`147`		`- --> $DIR/size_of_in_element_count.rs:43:33`
	`147`	`+ --> $DIR/functions.rs:43:33`
`148`	`148`	`\|`
`149`	`149`	`LL \| y.as_mut_ptr().wrapping_add(size_of::<u8>());`
`150`	`150`	`\| ^^^^^^^^^^^^^^^`
`151`	`151`	`\|`
`152`	`152`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`153`	`153`
`154`	`154`	error: found a count of bytes instead of a count of elements of `T`
`155`		`- --> $DIR/size_of_in_element_count.rs:44:32`
	`155`	`+ --> $DIR/functions.rs:44:32`
`156`	`156`	`\|`
`157`	`157`	`LL \| unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };`
`158`	`158`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^`
`159`	`159`	`\|`
`160`	`160`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`161`	`161`
`162`	`162`	error: found a count of bytes instead of a count of elements of `T`
`163`		`- --> $DIR/size_of_in_element_count.rs:45:36`
	`163`	`+ --> $DIR/functions.rs:45:36`
`164`	`164`	`\|`
`165`	`165`	`LL \| y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);`
`166`	`166`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^`
`167`	`167`	`\|`
`168`	`168`	`= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`169`	`169`
`170`		-error: found a count of bytes instead of a count of elements of `T`
`171`		`- --> $DIR/size_of_in_element_count.rs:48:62`
`172`		`- \|`
`173`		`-LL \| unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };`
`174`		`- \| ^^^^^^^^^^^^^^^^^^^^^^`
`175`		`- \|`
`176`		`- = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`177`		`-`
`178`		-error: found a count of bytes instead of a count of elements of `T`
`179`		`- --> $DIR/size_of_in_element_count.rs:51:62`
`180`		`- \|`
`181`		`-LL \| unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };`
`182`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`183`		`- \|`
`184`		`- = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`185`		`-`
`186`		-error: found a count of bytes instead of a count of elements of `T`
`187`		`- --> $DIR/size_of_in_element_count.rs:54:47`
`188`		`- \|`
`189`		`-LL \| unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };`
`190`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`191`		`- \|`
`192`		`- = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type`
`193`		`-`
`194`		`-error: aborting due to 24 previous errors`
	`170`	`+error: aborting due to 21 previous errors`
`195`	`171`