1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
#![feature(box_syntax)]
#![feature(lint_reasons)]
#![allow(
clippy::borrowed_box,
clippy::needless_pass_by_value,
clippy::unused_unit,
clippy::redundant_clone,
clippy::match_single_binding
)]
#![warn(clippy::boxed_local)]
#[derive(Clone)]
struct A;
impl A {
fn foo(&self) {}
}
trait Z {
fn bar(&self);
}
impl Z for A {
fn bar(&self) {
//nothing
}
}
fn main() {}
fn ok_box_trait(boxed_trait: &Box<dyn Z>) {
let boxed_local = boxed_trait;
// done
}
fn warn_call() {
let x = box A;
x.foo();
}
fn warn_arg(x: Box<A>) {
x.foo();
}
fn nowarn_closure_arg() {
let x = Some(box A);
x.map_or((), |x| take_ref(&x));
}
fn warn_rename_call() {
let x = box A;
let y = x;
y.foo(); // via autoderef
}
fn warn_notuse() {
let bz = box A;
}
fn warn_pass() {
let bz = box A;
take_ref(&bz); // via deref coercion
}
fn nowarn_return() -> Box<A> {
box A // moved out, "escapes"
}
fn nowarn_move() {
let bx = box A;
drop(bx) // moved in, "escapes"
}
fn nowarn_call() {
let bx = box A;
bx.clone(); // method only available to Box, not via autoderef
}
fn nowarn_pass() {
let bx = box A;
take_box(&bx); // fn needs &Box
}
fn take_box(x: &Box<A>) {}
fn take_ref(x: &A) {}
fn nowarn_ref_take() {
// false positive, should actually warn
let x = box A;
let y = &x;
take_box(y);
}
fn nowarn_match() {
let x = box A; // moved into a match
match x {
y => drop(y),
}
}
fn warn_match() {
let x = box A;
match &x {
// not moved
y => (),
}
}
fn nowarn_large_array() {
// should not warn, is large array
// and should not be on stack
let x = box [1; 10000];
match &x {
// not moved
y => (),
}
}
/// ICE regression test
pub trait Foo {
type Item;
}
impl<'a> Foo for &'a () {
type Item = ();
}
pub struct PeekableSeekable<I: Foo> {
_peeked: I::Item,
}
pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
/// Regression for #916, #1123
///
/// This shouldn't warn for `boxed_local`as the implementation of a trait
/// can't change much about the trait definition.
trait BoxedAction {
fn do_sth(self: Box<Self>);
}
impl BoxedAction for u64 {
fn do_sth(self: Box<Self>) {
println!("{}", *self)
}
}
/// Regression for #1478
///
/// This shouldn't warn for `boxed_local`as self itself is a box type.
trait MyTrait {
fn do_sth(self);
}
impl<T> MyTrait for Box<T> {
fn do_sth(self) {}
}
// Issue #3739 - capture in closures
mod issue_3739 {
use super::A;
fn consume<T>(_: T) {}
fn borrow<T>(_: &T) {}
fn closure_consume(x: Box<A>) {
let _ = move || {
consume(x);
};
}
fn closure_borrow(x: Box<A>) {
let _ = || {
borrow(&x);
};
}
}
/// Issue #5542
///
/// This shouldn't warn for `boxed_local` as it is intended to called from non-Rust code.
pub extern "C" fn do_not_warn_me(_c_pointer: Box<String>) -> () {}
#[rustfmt::skip] // Forces rustfmt to not add ABI
pub extern fn do_not_warn_me_no_abi(_c_pointer: Box<String>) -> () {}
// Issue #4804 - default implementation in trait
mod issue4804 {
trait DefaultTraitImplTest {
// don't warn on `self`
fn default_impl(self: Box<Self>) -> u32 {
5
}
// warn on `x: Box<u32>`
fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
4
}
}
trait WarnTrait {
// warn on `x: Box<u32>`
fn foo(x: Box<u32>) {}
}
}
fn check_expect(#[expect(clippy::boxed_local)] x: Box<A>) {
x.foo();
}
|
