]>
Commit | Line | Data |
---|---|---|
ea8adc8c XL |
1 | // error-pattern:cargo-clippy |
2 | ||
3 | #![feature(box_syntax)] | |
4 | #![feature(custom_attribute)] | |
5 | #![feature(i128_type)] | |
6 | #![feature(i128)] | |
7 | #![feature(rustc_private)] | |
8 | #![feature(slice_patterns)] | |
9 | #![feature(stmt_expr_attributes)] | |
10 | #![feature(conservative_impl_trait)] | |
abe05a73 XL |
11 | #![feature(inclusive_range_syntax, range_contains)] |
12 | #![feature(macro_vis_matcher)] | |
ea8adc8c | 13 | #![allow(unknown_lints, indexing_slicing, shadow_reuse, missing_docs_in_private_items)] |
abe05a73 | 14 | #![recursion_limit = "256"] |
ea8adc8c | 15 | |
ea8adc8c XL |
16 | #[macro_use] |
17 | extern crate rustc; | |
abe05a73 XL |
18 | extern crate rustc_typeck; |
19 | extern crate syntax; | |
20 | extern crate syntax_pos; | |
ea8adc8c XL |
21 | |
22 | extern crate toml; | |
23 | ||
24 | // for unicode nfc normalization | |
abe05a73 | 25 | |
ea8adc8c XL |
26 | extern crate unicode_normalization; |
27 | ||
28 | // for semver check in attrs.rs | |
abe05a73 | 29 | |
ea8adc8c XL |
30 | extern crate semver; |
31 | ||
32 | // for regex checking | |
abe05a73 | 33 | |
ea8adc8c XL |
34 | extern crate regex_syntax; |
35 | ||
36 | // for finding minimal boolean expressions | |
abe05a73 | 37 | |
ea8adc8c XL |
38 | extern crate quine_mc_cluskey; |
39 | ||
ea8adc8c XL |
40 | extern crate rustc_const_eval; |
41 | extern crate rustc_const_math; | |
abe05a73 XL |
42 | extern crate rustc_errors; |
43 | extern crate rustc_plugin; | |
ea8adc8c XL |
44 | |
45 | #[macro_use] | |
46 | extern crate matches as matches_macro; | |
47 | ||
abe05a73 | 48 | extern crate serde; |
ea8adc8c XL |
49 | #[macro_use] |
50 | extern crate serde_derive; | |
ea8adc8c XL |
51 | |
52 | #[macro_use] | |
53 | extern crate lazy_static; | |
54 | ||
55 | extern crate itertools; | |
56 | extern crate pulldown_cmark; | |
abe05a73 XL |
57 | extern crate url; |
58 | ||
59 | #[macro_use] | |
60 | extern crate if_chain; | |
ea8adc8c XL |
61 | |
62 | macro_rules! declare_restriction_lint { | |
63 | { pub $name:tt, $description:tt } => { | |
64 | declare_lint! { pub $name, Allow, $description } | |
65 | }; | |
66 | } | |
67 | ||
68 | pub mod consts; | |
69 | #[macro_use] | |
70 | pub mod utils; | |
71 | ||
72 | // begin lints modules, do not remove this comment, it’s used in `update_lints` | |
73 | pub mod approx_const; | |
74 | pub mod arithmetic; | |
75 | pub mod array_indexing; | |
76 | pub mod assign_ops; | |
77 | pub mod attrs; | |
78 | pub mod bit_mask; | |
79 | pub mod blacklisted_name; | |
80 | pub mod block_in_if_condition; | |
81 | pub mod booleans; | |
82 | pub mod bytecount; | |
83 | pub mod collapsible_if; | |
abe05a73 | 84 | pub mod const_static_lifetime; |
ea8adc8c XL |
85 | pub mod copies; |
86 | pub mod cyclomatic_complexity; | |
87 | pub mod derive; | |
88 | pub mod doc; | |
89 | pub mod double_parens; | |
90 | pub mod drop_forget_ref; | |
91 | pub mod empty_enum; | |
92 | pub mod entry; | |
93 | pub mod enum_clike; | |
94 | pub mod enum_glob_use; | |
95 | pub mod enum_variants; | |
96 | pub mod eq_op; | |
abe05a73 | 97 | pub mod erasing_op; |
ea8adc8c XL |
98 | pub mod escape; |
99 | pub mod eta_reduction; | |
100 | pub mod eval_order_dependence; | |
abe05a73 XL |
101 | pub mod explicit_write; |
102 | pub mod fallible_impl_from; | |
ea8adc8c XL |
103 | pub mod format; |
104 | pub mod formatting; | |
105 | pub mod functions; | |
abe05a73 | 106 | pub mod identity_conversion; |
ea8adc8c XL |
107 | pub mod identity_op; |
108 | pub mod if_let_redundant_pattern_matching; | |
109 | pub mod if_not_else; | |
110 | pub mod infinite_iter; | |
abe05a73 XL |
111 | pub mod int_plus_one; |
112 | pub mod invalid_ref; | |
ea8adc8c XL |
113 | pub mod is_unit_expr; |
114 | pub mod items_after_statements; | |
115 | pub mod large_enum_variant; | |
116 | pub mod len_zero; | |
117 | pub mod let_if_seq; | |
118 | pub mod lifetimes; | |
119 | pub mod literal_digit_grouping; | |
120 | pub mod loops; | |
121 | pub mod map_clone; | |
122 | pub mod matches; | |
123 | pub mod mem_forget; | |
124 | pub mod methods; | |
125 | pub mod minmax; | |
126 | pub mod misc; | |
127 | pub mod misc_early; | |
128 | pub mod missing_doc; | |
129 | pub mod mut_mut; | |
130 | pub mod mut_reference; | |
131 | pub mod mutex_atomic; | |
132 | pub mod needless_bool; | |
133 | pub mod needless_borrow; | |
134 | pub mod needless_borrowed_ref; | |
135 | pub mod needless_continue; | |
136 | pub mod needless_pass_by_value; | |
137 | pub mod needless_update; | |
138 | pub mod neg_multiply; | |
139 | pub mod new_without_default; | |
140 | pub mod no_effect; | |
141 | pub mod non_expressive_names; | |
142 | pub mod ok_if_let; | |
143 | pub mod open_options; | |
144 | pub mod overflow_check_conditional; | |
145 | pub mod panic; | |
146 | pub mod partialeq_ne_impl; | |
147 | pub mod precedence; | |
148 | pub mod print; | |
149 | pub mod ptr; | |
150 | pub mod ranges; | |
151 | pub mod reference; | |
152 | pub mod regex; | |
153 | pub mod returns; | |
154 | pub mod serde_api; | |
155 | pub mod shadow; | |
ea8adc8c XL |
156 | pub mod strings; |
157 | pub mod swap; | |
158 | pub mod temporary_assignment; | |
159 | pub mod transmute; | |
160 | pub mod types; | |
161 | pub mod unicode; | |
162 | pub mod unsafe_removed_from_name; | |
163 | pub mod unused_io_amount; | |
164 | pub mod unused_label; | |
165 | pub mod use_self; | |
166 | pub mod vec; | |
167 | pub mod zero_div_zero; | |
168 | // end lints modules, do not remove this comment, it’s used in `update_lints` | |
169 | ||
170 | mod reexport { | |
171 | pub use syntax::ast::{Name, NodeId}; | |
172 | } | |
173 | ||
174 | #[cfg_attr(rustfmt, rustfmt_skip)] | |
175 | pub fn register_plugins(reg: &mut rustc_plugin::Registry) { | |
176 | let conf = match utils::conf::file_from_args(reg.args()) { | |
177 | Ok(file_name) => { | |
178 | // if the user specified a file, it must exist, otherwise default to `clippy.toml` but | |
179 | // do not require the file to exist | |
180 | let file_name = if let Some(file_name) = file_name { | |
181 | Some(file_name) | |
182 | } else { | |
183 | match utils::conf::lookup_conf_file() { | |
184 | Ok(path) => path, | |
185 | Err(error) => { | |
abe05a73 | 186 | reg.sess.struct_err(&format!("error finding Clippy's configuration file: {}", error)).emit(); |
ea8adc8c XL |
187 | None |
188 | } | |
189 | } | |
190 | }; | |
191 | ||
abe05a73 XL |
192 | let file_name = file_name.map(|file_name| if file_name.is_relative() { |
193 | reg.sess | |
194 | .local_crate_source_file | |
195 | .as_ref() | |
196 | .and_then(|file| std::path::Path::new(&file).parent().map(std::path::Path::to_path_buf)) | |
197 | .unwrap_or_default() | |
198 | .join(file_name) | |
199 | } else { | |
200 | file_name | |
201 | }); | |
202 | ||
ea8adc8c XL |
203 | let (conf, errors) = utils::conf::read(file_name.as_ref().map(|p| p.as_ref())); |
204 | ||
205 | // all conf errors are non-fatal, we just use the default conf in case of error | |
206 | for error in errors { | |
abe05a73 | 207 | reg.sess.struct_err(&format!("error reading Clippy's configuration file `{}`: {}", file_name.as_ref().and_then(|p| p.to_str()).unwrap_or(""), error)).emit(); |
ea8adc8c XL |
208 | } |
209 | ||
210 | conf | |
211 | } | |
212 | Err((err, span)) => { | |
213 | reg.sess.struct_span_err(span, err) | |
214 | .span_note(span, "Clippy will use default configuration") | |
215 | .emit(); | |
216 | toml::from_str("").expect("we never error on empty config files") | |
217 | } | |
218 | }; | |
219 | ||
220 | let mut store = reg.sess.lint_store.borrow_mut(); | |
abe05a73 XL |
221 | store.register_removed( |
222 | "should_assert_eq", | |
223 | "`assert!()` will be more flexible with RFC 2011", | |
224 | ); | |
ea8adc8c XL |
225 | store.register_removed( |
226 | "extend_from_slice", | |
227 | "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice", | |
228 | ); | |
229 | store.register_removed( | |
230 | "range_step_by_zero", | |
231 | "`iterator.step_by(0)` panics nowadays", | |
232 | ); | |
233 | store.register_removed( | |
234 | "unstable_as_slice", | |
235 | "`Vec::as_slice` has been stabilized in 1.7", | |
236 | ); | |
237 | store.register_removed( | |
238 | "unstable_as_mut_slice", | |
239 | "`Vec::as_mut_slice` has been stabilized in 1.7", | |
240 | ); | |
241 | store.register_removed( | |
242 | "str_to_string", | |
243 | "using `str::to_string` is common even today and specialization will likely happen soon", | |
244 | ); | |
245 | store.register_removed( | |
246 | "string_to_string", | |
247 | "using `string::to_string` is common even today and specialization will likely happen soon", | |
248 | ); | |
249 | // end deprecated lints, do not remove this comment, it’s used in `update_lints` | |
250 | ||
251 | reg.register_late_lint_pass(box serde_api::Serde); | |
252 | reg.register_early_lint_pass(box utils::internal_lints::Clippy); | |
253 | reg.register_late_lint_pass(box utils::internal_lints::LintWithoutLintPass::default()); | |
254 | reg.register_late_lint_pass(box utils::inspector::Pass); | |
255 | reg.register_late_lint_pass(box utils::author::Pass); | |
256 | reg.register_late_lint_pass(box types::TypePass); | |
257 | reg.register_late_lint_pass(box booleans::NonminimalBool); | |
258 | reg.register_late_lint_pass(box eq_op::EqOp); | |
259 | reg.register_early_lint_pass(box enum_variants::EnumVariantNames::new(conf.enum_variant_name_threshold)); | |
260 | reg.register_late_lint_pass(box enum_glob_use::EnumGlobUse); | |
261 | reg.register_late_lint_pass(box enum_clike::UnportableVariant); | |
abe05a73 | 262 | reg.register_late_lint_pass(box bit_mask::BitMask::new(conf.verbose_bit_mask_threshold)); |
ea8adc8c XL |
263 | reg.register_late_lint_pass(box ptr::PointerPass); |
264 | reg.register_late_lint_pass(box needless_bool::NeedlessBool); | |
265 | reg.register_late_lint_pass(box needless_bool::BoolComparison); | |
266 | reg.register_late_lint_pass(box approx_const::Pass); | |
267 | reg.register_late_lint_pass(box misc::Pass); | |
268 | reg.register_early_lint_pass(box precedence::Precedence); | |
269 | reg.register_early_lint_pass(box is_unit_expr::UnitExpr); | |
270 | reg.register_early_lint_pass(box needless_continue::NeedlessContinue); | |
271 | reg.register_late_lint_pass(box eta_reduction::EtaPass); | |
272 | reg.register_late_lint_pass(box identity_op::IdentityOp); | |
abe05a73 | 273 | reg.register_late_lint_pass(box erasing_op::ErasingOp); |
ea8adc8c XL |
274 | reg.register_early_lint_pass(box items_after_statements::ItemsAfterStatements); |
275 | reg.register_late_lint_pass(box mut_mut::MutMut); | |
276 | reg.register_late_lint_pass(box mut_reference::UnnecessaryMutPassed); | |
277 | reg.register_late_lint_pass(box len_zero::LenZero); | |
278 | reg.register_late_lint_pass(box attrs::AttrPass); | |
279 | reg.register_early_lint_pass(box collapsible_if::CollapsibleIf); | |
280 | reg.register_late_lint_pass(box block_in_if_condition::BlockInIfCondition); | |
281 | reg.register_late_lint_pass(box unicode::Unicode); | |
282 | reg.register_late_lint_pass(box strings::StringAdd); | |
283 | reg.register_early_lint_pass(box returns::ReturnPass); | |
284 | reg.register_late_lint_pass(box methods::Pass); | |
285 | reg.register_late_lint_pass(box shadow::Pass); | |
286 | reg.register_late_lint_pass(box types::LetPass); | |
287 | reg.register_late_lint_pass(box types::UnitCmp); | |
288 | reg.register_late_lint_pass(box loops::Pass); | |
289 | reg.register_late_lint_pass(box lifetimes::LifetimePass); | |
290 | reg.register_late_lint_pass(box entry::HashMapLint); | |
abe05a73 | 291 | reg.register_late_lint_pass(box ranges::Pass); |
ea8adc8c XL |
292 | reg.register_late_lint_pass(box types::CastPass); |
293 | reg.register_late_lint_pass(box types::TypeComplexityPass::new(conf.type_complexity_threshold)); | |
294 | reg.register_late_lint_pass(box matches::MatchPass); | |
295 | reg.register_late_lint_pass(box minmax::MinMaxPass); | |
296 | reg.register_late_lint_pass(box open_options::NonSensical); | |
297 | reg.register_late_lint_pass(box zero_div_zero::Pass); | |
298 | reg.register_late_lint_pass(box mutex_atomic::MutexAtomic); | |
299 | reg.register_late_lint_pass(box needless_update::Pass); | |
300 | reg.register_late_lint_pass(box needless_borrow::NeedlessBorrow); | |
301 | reg.register_late_lint_pass(box needless_borrowed_ref::NeedlessBorrowedRef); | |
302 | reg.register_late_lint_pass(box no_effect::Pass); | |
303 | reg.register_late_lint_pass(box map_clone::Pass); | |
304 | reg.register_late_lint_pass(box temporary_assignment::Pass); | |
305 | reg.register_late_lint_pass(box transmute::Transmute); | |
306 | reg.register_late_lint_pass( | |
307 | box cyclomatic_complexity::CyclomaticComplexity::new(conf.cyclomatic_complexity_threshold) | |
308 | ); | |
309 | reg.register_late_lint_pass(box escape::Pass{too_large_for_stack: conf.too_large_for_stack}); | |
310 | reg.register_early_lint_pass(box misc_early::MiscEarly); | |
311 | reg.register_late_lint_pass(box array_indexing::ArrayIndexing); | |
312 | reg.register_late_lint_pass(box panic::Pass); | |
313 | reg.register_late_lint_pass(box strings::StringLitAsBytes); | |
314 | reg.register_late_lint_pass(box derive::Derive); | |
315 | reg.register_late_lint_pass(box types::CharLitAsU8); | |
316 | reg.register_late_lint_pass(box print::Pass); | |
317 | reg.register_late_lint_pass(box vec::Pass); | |
318 | reg.register_early_lint_pass(box non_expressive_names::NonExpressiveNames { | |
319 | single_char_binding_names_threshold: conf.single_char_binding_names_threshold, | |
320 | }); | |
321 | reg.register_late_lint_pass(box drop_forget_ref::Pass); | |
322 | reg.register_late_lint_pass(box empty_enum::EmptyEnum); | |
323 | reg.register_late_lint_pass(box types::AbsurdExtremeComparisons); | |
324 | reg.register_late_lint_pass(box types::InvalidUpcastComparisons); | |
325 | reg.register_late_lint_pass(box regex::Pass::default()); | |
326 | reg.register_late_lint_pass(box copies::CopyAndPaste); | |
327 | reg.register_late_lint_pass(box format::Pass); | |
328 | reg.register_early_lint_pass(box formatting::Formatting); | |
329 | reg.register_late_lint_pass(box swap::Swap); | |
330 | reg.register_early_lint_pass(box if_not_else::IfNotElse); | |
abe05a73 | 331 | reg.register_early_lint_pass(box int_plus_one::IntPlusOne); |
ea8adc8c XL |
332 | reg.register_late_lint_pass(box overflow_check_conditional::OverflowCheckConditional); |
333 | reg.register_late_lint_pass(box unused_label::UnusedLabel); | |
334 | reg.register_late_lint_pass(box new_without_default::NewWithoutDefault); | |
335 | reg.register_late_lint_pass(box blacklisted_name::BlackListedName::new(conf.blacklisted_names)); | |
336 | reg.register_late_lint_pass(box functions::Functions::new(conf.too_many_arguments_threshold)); | |
337 | reg.register_early_lint_pass(box doc::Doc::new(conf.doc_valid_idents)); | |
338 | reg.register_late_lint_pass(box neg_multiply::NegMultiply); | |
339 | reg.register_early_lint_pass(box unsafe_removed_from_name::UnsafeNameRemoval); | |
340 | reg.register_late_lint_pass(box mem_forget::MemForget); | |
341 | reg.register_late_lint_pass(box arithmetic::Arithmetic::default()); | |
342 | reg.register_late_lint_pass(box assign_ops::AssignOps); | |
343 | reg.register_late_lint_pass(box let_if_seq::LetIfSeq); | |
344 | reg.register_late_lint_pass(box eval_order_dependence::EvalOrderDependence); | |
345 | reg.register_late_lint_pass(box missing_doc::MissingDoc::new()); | |
346 | reg.register_late_lint_pass(box ok_if_let::Pass); | |
347 | reg.register_late_lint_pass(box if_let_redundant_pattern_matching::Pass); | |
348 | reg.register_late_lint_pass(box partialeq_ne_impl::Pass); | |
349 | reg.register_early_lint_pass(box reference::Pass); | |
350 | reg.register_early_lint_pass(box double_parens::DoubleParens); | |
351 | reg.register_late_lint_pass(box unused_io_amount::UnusedIoAmount); | |
352 | reg.register_late_lint_pass(box large_enum_variant::LargeEnumVariant::new(conf.enum_variant_size_threshold)); | |
abe05a73 | 353 | reg.register_late_lint_pass(box explicit_write::Pass); |
ea8adc8c XL |
354 | reg.register_late_lint_pass(box needless_pass_by_value::NeedlessPassByValue); |
355 | reg.register_early_lint_pass(box literal_digit_grouping::LiteralDigitGrouping); | |
356 | reg.register_late_lint_pass(box use_self::UseSelf); | |
357 | reg.register_late_lint_pass(box bytecount::ByteCount); | |
358 | reg.register_late_lint_pass(box infinite_iter::Pass); | |
abe05a73 XL |
359 | reg.register_late_lint_pass(box invalid_ref::InvalidRef); |
360 | reg.register_late_lint_pass(box identity_conversion::IdentityConversion::default()); | |
361 | reg.register_late_lint_pass(box types::ImplicitHasher); | |
362 | reg.register_early_lint_pass(box const_static_lifetime::StaticConst); | |
363 | reg.register_late_lint_pass(box fallible_impl_from::FallibleImplFrom); | |
ea8adc8c XL |
364 | |
365 | reg.register_lint_group("clippy_restrictions", vec![ | |
366 | arithmetic::FLOAT_ARITHMETIC, | |
367 | arithmetic::INTEGER_ARITHMETIC, | |
368 | array_indexing::INDEXING_SLICING, | |
369 | assign_ops::ASSIGN_OPS, | |
370 | ]); | |
371 | ||
372 | reg.register_lint_group("clippy_pedantic", vec![ | |
373 | booleans::NONMINIMAL_BOOL, | |
374 | empty_enum::EMPTY_ENUM, | |
375 | enum_glob_use::ENUM_GLOB_USE, | |
376 | enum_variants::PUB_ENUM_VARIANT_NAMES, | |
377 | enum_variants::STUTTER, | |
abe05a73 | 378 | fallible_impl_from::FALLIBLE_IMPL_FROM, |
ea8adc8c XL |
379 | if_not_else::IF_NOT_ELSE, |
380 | infinite_iter::MAYBE_INFINITE_ITER, | |
abe05a73 | 381 | int_plus_one::INT_PLUS_ONE, |
ea8adc8c XL |
382 | items_after_statements::ITEMS_AFTER_STATEMENTS, |
383 | matches::SINGLE_MATCH_ELSE, | |
384 | mem_forget::MEM_FORGET, | |
385 | methods::FILTER_MAP, | |
386 | methods::OPTION_MAP_UNWRAP_OR, | |
387 | methods::OPTION_MAP_UNWRAP_OR_ELSE, | |
388 | methods::OPTION_UNWRAP_USED, | |
abe05a73 | 389 | methods::RESULT_MAP_UNWRAP_OR_ELSE, |
ea8adc8c XL |
390 | methods::RESULT_UNWRAP_USED, |
391 | methods::WRONG_PUB_SELF_CONVENTION, | |
392 | misc::USED_UNDERSCORE_BINDING, | |
393 | misc_early::UNSEPARATED_LITERAL_SUFFIX, | |
394 | missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS, | |
395 | mut_mut::MUT_MUT, | |
396 | mutex_atomic::MUTEX_INTEGER, | |
397 | non_expressive_names::SIMILAR_NAMES, | |
398 | print::PRINT_STDOUT, | |
399 | print::USE_DEBUG, | |
abe05a73 | 400 | ranges::RANGE_PLUS_ONE, |
ea8adc8c XL |
401 | shadow::SHADOW_REUSE, |
402 | shadow::SHADOW_SAME, | |
403 | shadow::SHADOW_UNRELATED, | |
404 | strings::STRING_ADD, | |
405 | strings::STRING_ADD_ASSIGN, | |
406 | types::CAST_POSSIBLE_TRUNCATION, | |
407 | types::CAST_POSSIBLE_WRAP, | |
408 | types::CAST_PRECISION_LOSS, | |
409 | types::CAST_SIGN_LOSS, | |
410 | types::INVALID_UPCAST_COMPARISONS, | |
411 | unicode::NON_ASCII_LITERAL, | |
412 | unicode::UNICODE_NOT_NFC, | |
413 | use_self::USE_SELF, | |
414 | ]); | |
415 | ||
416 | reg.register_lint_group("clippy_internal", vec![ | |
417 | utils::internal_lints::CLIPPY_LINTS_INTERNAL, | |
418 | utils::internal_lints::LINT_WITHOUT_LINT_PASS, | |
419 | ]); | |
420 | ||
421 | reg.register_lint_group("clippy", vec![ | |
422 | approx_const::APPROX_CONSTANT, | |
423 | array_indexing::OUT_OF_BOUNDS_INDEXING, | |
424 | assign_ops::ASSIGN_OP_PATTERN, | |
425 | assign_ops::MISREFACTORED_ASSIGN_OP, | |
426 | attrs::DEPRECATED_SEMVER, | |
427 | attrs::INLINE_ALWAYS, | |
428 | attrs::USELESS_ATTRIBUTE, | |
429 | bit_mask::BAD_BIT_MASK, | |
430 | bit_mask::INEFFECTIVE_BIT_MASK, | |
431 | bit_mask::VERBOSE_BIT_MASK, | |
432 | blacklisted_name::BLACKLISTED_NAME, | |
433 | block_in_if_condition::BLOCK_IN_IF_CONDITION_EXPR, | |
434 | block_in_if_condition::BLOCK_IN_IF_CONDITION_STMT, | |
435 | booleans::LOGIC_BUG, | |
436 | bytecount::NAIVE_BYTECOUNT, | |
437 | collapsible_if::COLLAPSIBLE_IF, | |
abe05a73 | 438 | const_static_lifetime::CONST_STATIC_LIFETIME, |
ea8adc8c XL |
439 | copies::IF_SAME_THEN_ELSE, |
440 | copies::IFS_SAME_COND, | |
441 | copies::MATCH_SAME_ARMS, | |
442 | cyclomatic_complexity::CYCLOMATIC_COMPLEXITY, | |
443 | derive::DERIVE_HASH_XOR_EQ, | |
444 | derive::EXPL_IMPL_CLONE_ON_COPY, | |
445 | doc::DOC_MARKDOWN, | |
446 | double_parens::DOUBLE_PARENS, | |
447 | drop_forget_ref::DROP_COPY, | |
448 | drop_forget_ref::DROP_REF, | |
449 | drop_forget_ref::FORGET_COPY, | |
450 | drop_forget_ref::FORGET_REF, | |
451 | entry::MAP_ENTRY, | |
452 | enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT, | |
453 | enum_variants::ENUM_VARIANT_NAMES, | |
454 | enum_variants::MODULE_INCEPTION, | |
455 | eq_op::EQ_OP, | |
456 | eq_op::OP_REF, | |
abe05a73 | 457 | erasing_op::ERASING_OP, |
ea8adc8c XL |
458 | escape::BOXED_LOCAL, |
459 | eta_reduction::REDUNDANT_CLOSURE, | |
460 | eval_order_dependence::DIVERGING_SUB_EXPRESSION, | |
461 | eval_order_dependence::EVAL_ORDER_DEPENDENCE, | |
abe05a73 | 462 | explicit_write::EXPLICIT_WRITE, |
ea8adc8c XL |
463 | format::USELESS_FORMAT, |
464 | formatting::POSSIBLE_MISSING_COMMA, | |
465 | formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING, | |
466 | formatting::SUSPICIOUS_ELSE_FORMATTING, | |
467 | functions::NOT_UNSAFE_PTR_ARG_DEREF, | |
468 | functions::TOO_MANY_ARGUMENTS, | |
abe05a73 | 469 | identity_conversion::IDENTITY_CONVERSION, |
ea8adc8c XL |
470 | identity_op::IDENTITY_OP, |
471 | if_let_redundant_pattern_matching::IF_LET_REDUNDANT_PATTERN_MATCHING, | |
472 | infinite_iter::INFINITE_ITER, | |
abe05a73 | 473 | invalid_ref::INVALID_REF, |
ea8adc8c XL |
474 | is_unit_expr::UNIT_EXPR, |
475 | large_enum_variant::LARGE_ENUM_VARIANT, | |
476 | len_zero::LEN_WITHOUT_IS_EMPTY, | |
477 | len_zero::LEN_ZERO, | |
478 | let_if_seq::USELESS_LET_IF_SEQ, | |
479 | lifetimes::NEEDLESS_LIFETIMES, | |
480 | lifetimes::UNUSED_LIFETIMES, | |
481 | literal_digit_grouping::INCONSISTENT_DIGIT_GROUPING, | |
482 | literal_digit_grouping::LARGE_DIGIT_GROUPS, | |
483 | literal_digit_grouping::UNREADABLE_LITERAL, | |
484 | loops::EMPTY_LOOP, | |
485 | loops::EXPLICIT_COUNTER_LOOP, | |
486 | loops::EXPLICIT_INTO_ITER_LOOP, | |
487 | loops::EXPLICIT_ITER_LOOP, | |
488 | loops::FOR_KV_MAP, | |
489 | loops::FOR_LOOP_OVER_OPTION, | |
490 | loops::FOR_LOOP_OVER_RESULT, | |
491 | loops::ITER_NEXT_LOOP, | |
abe05a73 XL |
492 | loops::MANUAL_MEMCPY, |
493 | loops::MUT_RANGE_BOUND, | |
ea8adc8c XL |
494 | loops::NEEDLESS_RANGE_LOOP, |
495 | loops::NEVER_LOOP, | |
496 | loops::REVERSE_RANGE_LOOP, | |
497 | loops::UNUSED_COLLECT, | |
498 | loops::WHILE_LET_LOOP, | |
499 | loops::WHILE_LET_ON_ITERATOR, | |
500 | map_clone::MAP_CLONE, | |
501 | matches::MATCH_BOOL, | |
502 | matches::MATCH_OVERLAPPING_ARM, | |
503 | matches::MATCH_REF_PATS, | |
504 | matches::MATCH_WILD_ERR_ARM, | |
505 | matches::SINGLE_MATCH, | |
abe05a73 | 506 | methods::CHARS_LAST_CMP, |
ea8adc8c XL |
507 | methods::CHARS_NEXT_CMP, |
508 | methods::CLONE_DOUBLE_REF, | |
509 | methods::CLONE_ON_COPY, | |
abe05a73 | 510 | methods::CLONE_ON_REF_PTR, |
ea8adc8c XL |
511 | methods::FILTER_NEXT, |
512 | methods::GET_UNWRAP, | |
513 | methods::ITER_CLONED_COLLECT, | |
514 | methods::ITER_NTH, | |
515 | methods::ITER_SKIP_NEXT, | |
516 | methods::NEW_RET_NO_SELF, | |
517 | methods::OK_EXPECT, | |
abe05a73 | 518 | methods::OPTION_MAP_OR_NONE, |
ea8adc8c XL |
519 | methods::OR_FUN_CALL, |
520 | methods::SEARCH_IS_SOME, | |
521 | methods::SHOULD_IMPLEMENT_TRAIT, | |
522 | methods::SINGLE_CHAR_PATTERN, | |
523 | methods::STRING_EXTEND_CHARS, | |
524 | methods::TEMPORARY_CSTRING_AS_PTR, | |
abe05a73 | 525 | methods::USELESS_ASREF, |
ea8adc8c XL |
526 | methods::WRONG_SELF_CONVENTION, |
527 | minmax::MIN_MAX, | |
528 | misc::CMP_NAN, | |
529 | misc::CMP_OWNED, | |
530 | misc::FLOAT_CMP, | |
531 | misc::MODULO_ONE, | |
532 | misc::REDUNDANT_PATTERN, | |
533 | misc::SHORT_CIRCUIT_STATEMENT, | |
534 | misc::TOPLEVEL_REF_ARG, | |
535 | misc::ZERO_PTR, | |
536 | misc_early::BUILTIN_TYPE_SHADOW, | |
537 | misc_early::DOUBLE_NEG, | |
538 | misc_early::DUPLICATE_UNDERSCORE_ARGUMENT, | |
539 | misc_early::MIXED_CASE_HEX_LITERALS, | |
540 | misc_early::REDUNDANT_CLOSURE_CALL, | |
541 | misc_early::UNNEEDED_FIELD_PATTERN, | |
542 | misc_early::ZERO_PREFIXED_LITERAL, | |
543 | mut_reference::UNNECESSARY_MUT_PASSED, | |
544 | mutex_atomic::MUTEX_ATOMIC, | |
545 | needless_bool::BOOL_COMPARISON, | |
546 | needless_bool::NEEDLESS_BOOL, | |
547 | needless_borrow::NEEDLESS_BORROW, | |
548 | needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE, | |
549 | needless_continue::NEEDLESS_CONTINUE, | |
550 | needless_pass_by_value::NEEDLESS_PASS_BY_VALUE, | |
551 | needless_update::NEEDLESS_UPDATE, | |
552 | neg_multiply::NEG_MULTIPLY, | |
553 | new_without_default::NEW_WITHOUT_DEFAULT, | |
554 | new_without_default::NEW_WITHOUT_DEFAULT_DERIVE, | |
555 | no_effect::NO_EFFECT, | |
556 | no_effect::UNNECESSARY_OPERATION, | |
abe05a73 | 557 | non_expressive_names::JUST_UNDERSCORES_AND_DIGITS, |
ea8adc8c XL |
558 | non_expressive_names::MANY_SINGLE_CHAR_NAMES, |
559 | ok_if_let::IF_LET_SOME_RESULT, | |
560 | open_options::NONSENSICAL_OPEN_OPTIONS, | |
561 | overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL, | |
562 | panic::PANIC_PARAMS, | |
563 | partialeq_ne_impl::PARTIALEQ_NE_IMPL, | |
564 | precedence::PRECEDENCE, | |
565 | print::PRINT_WITH_NEWLINE, | |
abe05a73 | 566 | print::PRINTLN_EMPTY_STRING, |
ea8adc8c XL |
567 | ptr::CMP_NULL, |
568 | ptr::MUT_FROM_REF, | |
569 | ptr::PTR_ARG, | |
570 | ranges::ITERATOR_STEP_BY_ZERO, | |
abe05a73 | 571 | ranges::RANGE_MINUS_ONE, |
ea8adc8c XL |
572 | ranges::RANGE_ZIP_WITH_LEN, |
573 | reference::DEREF_ADDROF, | |
574 | regex::INVALID_REGEX, | |
575 | regex::REGEX_MACRO, | |
576 | regex::TRIVIAL_REGEX, | |
577 | returns::LET_AND_RETURN, | |
578 | returns::NEEDLESS_RETURN, | |
579 | serde_api::SERDE_API_MISUSE, | |
ea8adc8c XL |
580 | strings::STRING_LIT_AS_BYTES, |
581 | swap::ALMOST_SWAPPED, | |
582 | swap::MANUAL_SWAP, | |
583 | temporary_assignment::TEMPORARY_ASSIGNMENT, | |
584 | transmute::CROSSPOINTER_TRANSMUTE, | |
abe05a73 XL |
585 | transmute::TRANSMUTE_BYTES_TO_STR, |
586 | transmute::TRANSMUTE_INT_TO_BOOL, | |
587 | transmute::TRANSMUTE_INT_TO_CHAR, | |
588 | transmute::TRANSMUTE_INT_TO_FLOAT, | |
ea8adc8c XL |
589 | transmute::TRANSMUTE_PTR_TO_REF, |
590 | transmute::USELESS_TRANSMUTE, | |
591 | transmute::WRONG_TRANSMUTE, | |
592 | types::ABSURD_EXTREME_COMPARISONS, | |
593 | types::BORROWED_BOX, | |
594 | types::BOX_VEC, | |
595 | types::CAST_LOSSLESS, | |
596 | types::CHAR_LIT_AS_U8, | |
abe05a73 | 597 | types::IMPLICIT_HASHER, |
ea8adc8c XL |
598 | types::LET_UNIT_VALUE, |
599 | types::LINKEDLIST, | |
600 | types::TYPE_COMPLEXITY, | |
601 | types::UNIT_CMP, | |
602 | types::UNNECESSARY_CAST, | |
603 | unicode::ZERO_WIDTH_SPACE, | |
604 | unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME, | |
605 | unused_io_amount::UNUSED_IO_AMOUNT, | |
606 | unused_label::UNUSED_LABEL, | |
607 | vec::USELESS_VEC, | |
608 | zero_div_zero::ZERO_DIVIDED_BY_ZERO, | |
609 | ]); | |
610 | } | |
611 | ||
612 | // only exists to let the dogfood integration test works. | |
613 | // Don't run clippy as an executable directly | |
614 | #[allow(dead_code, print_stdout)] | |
615 | fn main() { | |
616 | panic!("Please use the cargo-clippy executable"); | |
617 | } |