Skip to content

Commit c1a5329

Browse files
nico-abramnico-abram
committed
Add more functions to size_of_in_element_count
Specifically ptr::{sub, wrapping_sub, add, wrapping_add, offset, wrapping_offset} and slice::{from_raw_parts, from_raw_parts_mut} The lint now also looks for size_of calls through casts (Since offset takes an isize)
1 parent af9685b commit c1a5329

File tree

5 files changed

+127
-42
lines changed

5 files changed

+127
-42
lines changed

‎clippy_lints/src/lib.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -848,6 +848,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
848848
&shadow::SHADOW_SAME,
849849
&shadow::SHADOW_UNRELATED,
850850
&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
851+
&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
851852
&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
852853
&stable_sort_primitive::STABLE_SORT_PRIMITIVE,
853854
&strings::STRING_ADD,
@@ -917,7 +918,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
917918
&unnecessary_wraps::UNNECESSARY_WRAPS,
918919
&unnested_or_patterns::UNNESTED_OR_PATTERNS,
919920
&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
920-
&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
921921
&unused_io_amount::UNUSED_IO_AMOUNT,
922922
&unused_self::UNUSED_SELF,
923923
&unused_unit::UNUSED_UNIT,
@@ -1562,6 +1562,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
15621562
LintId::of(&self_assignment::SELF_ASSIGNMENT),
15631563
LintId::of(&serde_api::SERDE_API_MISUSE),
15641564
LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
1565+
LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
15651566
LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
15661567
LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
15671568
LintId::of(&strings::STRING_FROM_UTF8_AS_BYTES),
@@ -1608,7 +1609,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
16081609
LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
16091610
LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
16101611
LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
1611-
LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
16121612
LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
16131613
LintId::of(&unused_unit::UNUSED_UNIT),
16141614
LintId::of(&unwrap::PANICKING_UNWRAP),
@@ -1872,6 +1872,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
18721872
LintId::of(&regex::INVALID_REGEX),
18731873
LintId::of(&self_assignment::SELF_ASSIGNMENT),
18741874
LintId::of(&serde_api::SERDE_API_MISUSE),
1875+
LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
18751876
LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
18761877
LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
18771878
LintId::of(&swap::ALMOST_SWAPPED),
@@ -1887,7 +1888,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
18871888
LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
18881889
LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
18891890
LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
1890-
LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
18911891
LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
18921892
LintId::of(&unwrap::PANICKING_UNWRAP),
18931893
LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),

‎clippy_lints/src/size_of_in_element_count.rs‎

Lines changed: 28 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -54,31 +54,40 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tc
5454
ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
5555
get_size_of_ty(cx, left).or_else(|| get_size_of_ty(cx, right))
5656
},
57+
ExprKind::Cast(expr, _) => get_size_of_ty(cx, expr),
5758
_ => None,
5859
}
5960
}
6061

61-
const FUNCTIONS: [[&str; 3]; 6] = [
62-
paths::COPY_NONOVERLAPPING,
63-
paths::COPY,
64-
paths::WRITE_BYTES,
65-
paths::PTR_SWAP_NONOVERLAPPING,
66-
paths::PTR_SLICE_FROM_RAW_PARTS,
67-
paths::PTR_SLICE_FROM_RAW_PARTS_MUT,
62+
fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
63+
const FUNCTIONS: [&[&str]; 8] = [
64+
&paths::COPY_NONOVERLAPPING,
65+
&paths::COPY,
66+
&paths::WRITE_BYTES,
67+
&paths::PTR_SWAP_NONOVERLAPPING,
68+
&paths::PTR_SLICE_FROM_RAW_PARTS,
69+
&paths::PTR_SLICE_FROM_RAW_PARTS_MUT,
70+
&paths::SLICE_FROM_RAW_PARTS,
71+
&paths::SLICE_FROM_RAW_PARTS_MUT,
6872
];
69-
const METHODS: [&str; 5] = [
70-
"write_bytes",
71-
"copy_to",
72-
"copy_from",
73-
"copy_to_nonoverlapping",
74-
"copy_from_nonoverlapping",
73+
const METHODS: [&str; 11] = [
74+
"write_bytes",
75+
"copy_to",
76+
"copy_from",
77+
"copy_to_nonoverlapping",
78+
"copy_from_nonoverlapping",
79+
"add",
80+
"wrapping_add",
81+
"sub",
82+
"wrapping_sub",
83+
"offset",
84+
"wrapping_offset",
7585
];
76-
fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
86+
7787
if_chain! {
7888
// Find calls to ptr::{copy, copy_nonoverlapping}
7989
// and ptr::{swap_nonoverlapping, write_bytes},
80-
if let ExprKind::Call(func, args) = expr.kind;
81-
if let [.., count] = args;
90+
if let ExprKind::Call(func, [.., count]) = expr.kind;
8291
if let ExprKind::Path(ref func_qpath) = func.kind;
8392
if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
8493
if FUNCTIONS.iter().any(|func_path| match_def_path(cx, def_id, func_path));
@@ -91,13 +100,12 @@ fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -
91100
};
92101
if_chain! {
93102
// Find calls to copy_{from,to}{,_nonoverlapping} and write_bytes methods
94-
if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind;
95-
if let [ptr_self, _, count] = args;
103+
if let ExprKind::MethodCall(method_path, _, [ptr_self, .., count], _) = expr.kind;
96104
let method_ident = method_path.ident.as_str();
97105
if METHODS.iter().any(|m| *m == &*method_ident);
98106

99107
// Get the pointee type
100-
if let ty::RawPtr(TypeAndMut { ty: pointee_ty, mutbl:_mutability }) =
108+
if let ty::RawPtr(TypeAndMut { ty: pointee_ty, .. }) =
101109
cx.typeck_results().expr_ty(ptr_self).kind();
102110
then {
103111
return Some((pointee_ty, count));
@@ -115,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
115123
instead of a count of elements of T";
116124

117125
if_chain! {
118-
// Find calls to unsafe copy functions and get
126+
// Find calls to functions with an element count parameter and get
119127
// the pointee type and count parameter expression
120128
if let Some((pointee_ty, count_expr)) = get_pointee_ty_and_count_expr(cx, expr);
121129

‎clippy_lints/src/utils/paths.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -128,6 +128,8 @@ pub const RWLOCK_READ_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockReadGu
128128
pub const RWLOCK_WRITE_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockWriteGuard"];
129129
pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
130130
pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
131+
pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
132+
pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
131133
pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
132134
pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
133135
pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];

‎tests/ui/size_of_in_element_count.rs‎

Lines changed: 13 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,11 @@
11
#![warn(clippy::size_of_in_element_count)]
2+
#![allow(clippy::ptr_offset_with_cast)]
23

34
use std::mem::{size_of, size_of_val};
45
use std::ptr::{
5-
copy, copy_nonoverlapping, slice_from_raw_parts,
6-
slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes,
6+
copy, copy_nonoverlapping, slice_from_raw_parts, slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes,
77
};
8+
use std::slice::{from_raw_parts, from_raw_parts_mut};
89

910
fn main() {
1011
const SIZE: usize = 128;
@@ -33,6 +34,16 @@ fn main() {
3334
slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
3435
slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
3536

37+
unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
38+
unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
39+
40+
unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
41+
y.as_ptr().wrapping_sub(size_of::<u8>());
42+
unsafe { y.as_ptr().add(size_of::<u8>()) };
43+
y.as_mut_ptr().wrapping_add(size_of::<u8>());
44+
unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
45+
y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
46+
3647
// Count expression involving multiplication of size_of (Should trigger the lint)
3748
unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
3849

‎tests/ui/size_of_in_element_count.stderr‎

Lines changed: 81 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
error: found a count of bytes instead of a count of elements of T
2-
--> $DIR/size_of_in_element_count.rs:17:68
2+
--> $DIR/size_of_in_element_count.rs:18:68
33
|
44
LL | unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
55
| ^^^^^^^^^^^^^^^
@@ -8,124 +8,188 @@ LL | unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of:
88
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
99

1010
error: found a count of bytes instead of a count of elements of T
11-
--> $DIR/size_of_in_element_count.rs:18:62
11+
--> $DIR/size_of_in_element_count.rs:19:62
1212
|
1313
LL | unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
1414
| ^^^^^^^^^^^^^^^^^^
1515
|
1616
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
1717

1818
error: found a count of bytes instead of a count of elements of T
19-
--> $DIR/size_of_in_element_count.rs:20:49
19+
--> $DIR/size_of_in_element_count.rs:21:49
2020
|
2121
LL | unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
2222
| ^^^^^^^^^^^^^^^
2323
|
2424
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
2525

2626
error: found a count of bytes instead of a count of elements of T
27-
--> $DIR/size_of_in_element_count.rs:21:64
27+
--> $DIR/size_of_in_element_count.rs:22:64
2828
|
2929
LL | unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
3030
| ^^^^^^^^^^^^^^^
3131
|
3232
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
3333

3434
error: found a count of bytes instead of a count of elements of T
35-
--> $DIR/size_of_in_element_count.rs:22:51
35+
--> $DIR/size_of_in_element_count.rs:23:51
3636
|
3737
LL | unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
3838
| ^^^^^^^^^^^^^^^
3939
|
4040
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
4141

4242
error: found a count of bytes instead of a count of elements of T
43-
--> $DIR/size_of_in_element_count.rs:23:66
43+
--> $DIR/size_of_in_element_count.rs:24:66
4444
|
4545
LL | unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
4646
| ^^^^^^^^^^^^^^^
4747
|
4848
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
4949

5050
error: found a count of bytes instead of a count of elements of T
51-
--> $DIR/size_of_in_element_count.rs:25:47
51+
--> $DIR/size_of_in_element_count.rs:26:47
5252
|
5353
LL | unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
5454
| ^^^^^^^^^^^^^^^
5555
|
5656
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
5757

5858
error: found a count of bytes instead of a count of elements of T
59-
--> $DIR/size_of_in_element_count.rs:26:47
59+
--> $DIR/size_of_in_element_count.rs:27:47
6060
|
6161
LL | unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
6262
| ^^^^^^^^^^^^^^^^^^
6363
|
6464
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
6565

6666
error: found a count of bytes instead of a count of elements of T
67-
--> $DIR/size_of_in_element_count.rs:28:46
67+
--> $DIR/size_of_in_element_count.rs:29:46
6868
|
6969
LL | unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
7070
| ^^^^^^^^^^^^^^^^^^^^^^
7171
|
7272
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
7373

7474
error: found a count of bytes instead of a count of elements of T
75-
--> $DIR/size_of_in_element_count.rs:29:47
75+
--> $DIR/size_of_in_element_count.rs:30:47
7676
|
7777
LL | unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
7878
| ^^^^^^^^^^^^^^^^^^^^^^
7979
|
8080
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
8181

8282
error: found a count of bytes instead of a count of elements of T
83-
--> $DIR/size_of_in_element_count.rs:31:66
83+
--> $DIR/size_of_in_element_count.rs:32:66
8484
|
8585
LL | unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
8686
| ^^^^^^^^^^^^^^^^^^^^^^
8787
|
8888
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
8989

9090
error: found a count of bytes instead of a count of elements of T
91-
--> $DIR/size_of_in_element_count.rs:33:46
91+
--> $DIR/size_of_in_element_count.rs:34:46
9292
|
9393
LL | slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
9494
| ^^^^^^^^^^^^^^^^^^^^^^
9595
|
9696
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
9797

9898
error: found a count of bytes instead of a count of elements of T
99-
--> $DIR/size_of_in_element_count.rs:34:38
99+
--> $DIR/size_of_in_element_count.rs:35:38
100100
|
101101
LL | slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
102102
| ^^^^^^^^^^^^^^^^^^^^^^
103103
|
104104
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
105105

106106
error: found a count of bytes instead of a count of elements of T
107-
--> $DIR/size_of_in_element_count.rs:37:62
107+
--> $DIR/size_of_in_element_count.rs:37:49
108+
|
109+
LL | unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
110+
| ^^^^^^^^^^^^^^^^^^^^^^
111+
|
112+
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
113+
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
116+
|
117+
LL | unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
118+
| ^^^^^^^^^^^^^^^^^^^^^^
119+
|
120+
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
121+
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
124+
|
125+
LL | unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
126+
| ^^^^^^^^^^^^^^^
127+
|
128+
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
129+
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
132+
|
133+
LL | y.as_ptr().wrapping_sub(size_of::<u8>());
134+
| ^^^^^^^^^^^^^^^
135+
|
136+
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
137+
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
140+
|
141+
LL | unsafe { y.as_ptr().add(size_of::<u8>()) };
142+
| ^^^^^^^^^^^^^^^
143+
|
144+
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
145+
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
148+
|
149+
LL | y.as_mut_ptr().wrapping_add(size_of::<u8>());
150+
| ^^^^^^^^^^^^^^^
151+
|
152+
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
153+
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
156+
|
157+
LL | unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
158+
| ^^^^^^^^^^^^^^^^^^^^^^^^
159+
|
160+
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
161+
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
164+
|
165+
LL | y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
166+
| ^^^^^^^^^^^^^^^^^^^^^^^^
167+
|
168+
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
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
108172
|
109173
LL | unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
110174
| ^^^^^^^^^^^^^^^^^^^^^^
111175
|
112176
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
113177

114178
error: found a count of bytes instead of a count of elements of T
115-
--> $DIR/size_of_in_element_count.rs:40:62
179+
--> $DIR/size_of_in_element_count.rs:51:62
116180
|
117181
LL | unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
118182
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
119183
|
120184
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
121185

122186
error: found a count of bytes instead of a count of elements of T
123-
--> $DIR/size_of_in_element_count.rs:43:47
187+
--> $DIR/size_of_in_element_count.rs:54:47
124188
|
125189
LL | unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
126190
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
127191
|
128192
= help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
129193

130-
error: aborting due to 16 previous errors
194+
error: aborting due to 24 previous errors
131195

0 commit comments

Comments
 (0)