size_of_in_element_count: Separate test file in expressions and functions

MarijnS95 · MarijnS95 · commit 391bb218b5a7 · 2021-01-19T20:05:39.000+01:00
An upcoming test case for new expresssion variants make the stderr file
go over 200 lines. Split this test case in two to have a clear
distinction between checking whether the lint is still applying on
all the functions with member counts as argument, versus validating
various member-count expressions that may or may not be invalid.
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,28 @@
+#![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) };
+
+    // 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,27 @@
+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: aborting due to 3 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`