]>
Commit | Line | Data |
---|---|---|
353b0b11 | 1 | // aux-build:proc_macros.rs |
2b03887a | 2 | // run-rustfix |
2b03887a | 3 | #![warn(clippy::uninlined_format_args)] |
353b0b11 | 4 | #![allow(named_arguments_used_positionally, unused)] |
2b03887a FG |
5 | #![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)] |
6 | ||
353b0b11 FG |
7 | extern crate proc_macros; |
8 | use proc_macros::with_span; | |
2b03887a FG |
9 | |
10 | macro_rules! no_param_str { | |
11 | () => { | |
12 | "{}" | |
13 | }; | |
14 | } | |
15 | ||
16 | macro_rules! my_println { | |
17 | ($($args:tt),*) => {{ | |
18 | println!($($args),*) | |
19 | }}; | |
20 | } | |
21 | ||
22 | macro_rules! my_println_args { | |
23 | ($($args:tt),*) => {{ | |
24 | println!("foo: {}", format_args!($($args),*)) | |
25 | }}; | |
26 | } | |
27 | ||
28 | fn tester(fn_arg: i32) { | |
29 | let local_i32 = 1; | |
30 | let local_f64 = 2.0; | |
31 | let local_opt: Option<i32> = Some(3); | |
32 | let width = 4; | |
33 | let prec = 5; | |
34 | let val = 6; | |
35 | ||
36 | // make sure this file hasn't been corrupted with tabs converted to spaces | |
37 | // let _ = ' '; // <- this is a single tab character | |
38 | let _: &[u8; 3] = b" "; // <- <tab><space><tab> | |
39 | ||
40 | println!("val='{local_i32}'"); | |
41 | println!("val='{local_i32}'"); // 3 spaces | |
42 | println!("val='{local_i32}'"); // tab | |
43 | println!("val='{local_i32}'"); // space+tab | |
44 | println!("val='{local_i32}'"); // tab+space | |
45 | println!( | |
487cf647 | 46 | "val='{local_i32}'" |
2b03887a FG |
47 | ); |
48 | println!("{local_i32}"); | |
49 | println!("{fn_arg}"); | |
50 | println!("{local_i32:?}"); | |
51 | println!("{local_i32:#?}"); | |
52 | println!("{local_i32:4}"); | |
53 | println!("{local_i32:04}"); | |
54 | println!("{local_i32:<3}"); | |
55 | println!("{local_i32:#010x}"); | |
56 | println!("{local_f64:.1}"); | |
487cf647 FG |
57 | println!("Hello {} is {:.*}", "x", local_i32, local_f64); |
58 | println!("Hello {} is {:.*}", local_i32, 5, local_f64); | |
59 | println!("Hello {} is {2:.*}", local_i32, 5, local_f64); | |
2b03887a | 60 | println!("{local_i32} {local_f64}"); |
487cf647 | 61 | println!("{}, {}", local_i32, local_opt.unwrap()); |
2b03887a FG |
62 | println!("{val}"); |
63 | println!("{val}"); | |
64 | println!("{} {1}", local_i32, 42); | |
65 | println!("val='{local_i32}'"); | |
66 | println!("val='{local_i32}'"); | |
67 | println!("val='{local_i32}'"); | |
68 | println!("val='{fn_arg}'"); | |
69 | println!("{local_i32}"); | |
70 | println!("{local_i32:?}"); | |
71 | println!("{local_i32:#?}"); | |
72 | println!("{local_i32:04}"); | |
73 | println!("{local_i32:<3}"); | |
74 | println!("{local_i32:#010x}"); | |
75 | println!("{local_f64:.1}"); | |
76 | println!("{local_i32} {local_i32}"); | |
77 | println!("{local_f64} {local_i32} {local_i32} {local_f64}"); | |
78 | println!("{local_i32} {local_f64}"); | |
79 | println!("{local_f64} {local_i32}"); | |
80 | println!("{local_f64} {local_i32} {local_f64} {local_i32}"); | |
81 | println!("{1} {0}", "str", local_i32); | |
82 | println!("{local_i32}"); | |
83 | println!("{local_i32:width$}"); | |
84 | println!("{local_i32:width$}"); | |
85 | println!("{local_i32:.prec$}"); | |
86 | println!("{local_i32:.prec$}"); | |
87 | println!("{val:val$}"); | |
88 | println!("{val:val$}"); | |
89 | println!("{val:val$.val$}"); | |
90 | println!("{val:val$.val$}"); | |
91 | println!("{val:val$.val$}"); | |
92 | println!("{val:val$.val$}"); | |
93 | println!("{val:val$.val$}"); | |
94 | println!("{val:val$.val$}"); | |
95 | println!("{val:val$.val$}"); | |
96 | println!("{val:val$.val$}"); | |
97 | println!("{width:width$}"); | |
98 | println!("{local_i32:width$}"); | |
99 | println!("{width:width$}"); | |
100 | println!("{local_i32:width$}"); | |
101 | println!("{prec:.prec$}"); | |
102 | println!("{local_i32:.prec$}"); | |
103 | println!("{prec:.prec$}"); | |
104 | println!("{local_i32:.prec$}"); | |
105 | println!("{width:width$.prec$}"); | |
106 | println!("{width:width$.prec$}"); | |
107 | println!("{local_f64:width$.prec$}"); | |
108 | println!("{local_f64:width$.prec$} {local_f64} {width} {prec}"); | |
109 | println!( | |
487cf647 | 110 | "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}", |
2b03887a FG |
111 | ); |
112 | println!( | |
113 | "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}", | |
114 | local_i32, | |
115 | width, | |
116 | prec, | |
117 | 1 + 2 | |
118 | ); | |
119 | println!("Width = {local_i32}, value with width = {local_f64:local_i32$}"); | |
120 | println!("{local_i32:width$.prec$}"); | |
121 | println!("{width:width$.prec$}"); | |
353b0b11 | 122 | println!("{}", format!("{}", local_i32)); |
2b03887a FG |
123 | my_println!("{}", local_i32); |
124 | my_println_args!("{}", local_i32); | |
125 | ||
126 | // these should NOT be modified by the lint | |
127 | println!(concat!("nope ", "{}"), local_i32); | |
128 | println!("val='{local_i32}'"); | |
129 | println!("val='{local_i32 }'"); | |
130 | println!("val='{local_i32 }'"); // with tab | |
131 | println!("val='{local_i32\n}'"); | |
132 | println!("{}", usize::MAX); | |
133 | println!("{}", local_opt.unwrap()); | |
134 | println!( | |
135 | "val='{local_i32 | |
136 | }'" | |
137 | ); | |
138 | println!(no_param_str!(), local_i32); | |
139 | ||
140 | println!( | |
487cf647 | 141 | "{val}", |
2b03887a FG |
142 | ); |
143 | println!("{val}"); | |
144 | ||
145 | println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64); | |
146 | println!("{}", with_span!(span val)); | |
147 | ||
148 | if local_i32 > 0 { | |
149 | panic!("p1 {local_i32}"); | |
150 | } | |
151 | if local_i32 > 0 { | |
152 | panic!("p2 {local_i32}"); | |
153 | } | |
154 | if local_i32 > 0 { | |
155 | panic!("p3 {local_i32}"); | |
156 | } | |
157 | if local_i32 > 0 { | |
158 | panic!("p4 {local_i32}"); | |
159 | } | |
160 | } | |
161 | ||
162 | fn main() { | |
163 | tester(42); | |
164 | } | |
165 | ||
487cf647 | 166 | #[clippy::msrv = "1.57"] |
2b03887a | 167 | fn _under_msrv() { |
2b03887a FG |
168 | let local_i32 = 1; |
169 | println!("don't expand='{}'", local_i32); | |
170 | } | |
171 | ||
487cf647 | 172 | #[clippy::msrv = "1.58"] |
2b03887a | 173 | fn _meets_msrv() { |
2b03887a FG |
174 | let local_i32 = 1; |
175 | println!("expand='{local_i32}'"); | |
176 | } | |
9ffffee4 FG |
177 | |
178 | fn _do_not_fire() { | |
179 | println!("{:?}", None::<()>); | |
180 | } | |
353b0b11 FG |
181 | |
182 | macro_rules! _internal { | |
183 | ($($args:tt)*) => { | |
184 | println!("{}", format_args!($($args)*)) | |
185 | }; | |
186 | } | |
187 | ||
188 | macro_rules! my_println2 { | |
189 | ($target:expr, $($args:tt)+) => {{ | |
190 | if $target { | |
191 | _internal!($($args)+) | |
192 | } | |
193 | }}; | |
194 | } | |
195 | ||
196 | macro_rules! my_println2_args { | |
197 | ($target:expr, $($args:tt)+) => {{ | |
198 | if $target { | |
199 | _internal!("foo: {}", format_args!($($args)+)) | |
200 | } | |
201 | }}; | |
202 | } | |
203 | ||
204 | macro_rules! my_concat { | |
205 | ($fmt:literal $(, $e:expr)*) => { | |
206 | println!(concat!("ERROR: ", $fmt), $($e,)*) | |
207 | } | |
208 | } | |
209 | ||
210 | macro_rules! my_good_macro { | |
211 | ($fmt:literal $(, $e:expr)* $(,)?) => { | |
212 | println!($fmt $(, $e)*) | |
213 | } | |
214 | } | |
215 | ||
216 | macro_rules! my_bad_macro { | |
217 | ($fmt:literal, $($e:expr),*) => { | |
218 | println!($fmt, $($e,)*) | |
219 | } | |
220 | } | |
221 | ||
222 | macro_rules! my_bad_macro2 { | |
223 | ($fmt:literal) => { | |
224 | let s = $fmt.clone(); | |
225 | println!("{}", s); | |
226 | }; | |
227 | ($fmt:literal, $($e:expr)+) => { | |
228 | println!($fmt, $($e,)*) | |
229 | }; | |
230 | } | |
231 | ||
232 | // This abomination was suggested by @Alexendoo, may the Rust gods have mercy on their soul... | |
233 | // https://github.com/rust-lang/rust-clippy/pull/9948#issuecomment-1327965962 | |
234 | macro_rules! used_twice { | |
235 | ( | |
236 | large = $large:literal, | |
237 | small = $small:literal, | |
238 | $val:expr, | |
239 | ) => { | |
240 | if $val < 5 { | |
241 | println!($small, $val); | |
242 | } else { | |
243 | println!($large, $val); | |
244 | } | |
245 | }; | |
246 | } | |
247 | ||
248 | fn tester2() { | |
249 | let local_i32 = 1; | |
250 | my_println2_args!(true, "{}", local_i32); | |
251 | my_println2!(true, "{}", local_i32); | |
252 | my_concat!("{}", local_i32); | |
253 | my_good_macro!("{}", local_i32); | |
254 | my_good_macro!("{}", local_i32,); | |
255 | ||
256 | // FIXME: Broken false positives, currently unhandled | |
257 | my_bad_macro!("{}", local_i32); | |
258 | my_bad_macro2!("{}", local_i32); | |
259 | used_twice! { | |
260 | large = "large value: {}", | |
261 | small = "small value: {}", | |
262 | local_i32, | |
263 | }; | |
264 | } |