clippy_lints/src/lib.rs

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