clippy_lints/src/lib.rs

   1 // error-pattern:cargo-clippy
   2
   3 #![feature(box_patterns)]
   4 #![feature(drain_filter)]
   5 #![feature(in_band_lifetimes)]
   6 #![feature(iter_zip)]
   7 #![feature(once_cell)]
   8 #![feature(rustc_private)]
   9 #![feature(stmt_expr_attributes)]
  10 #![feature(control_flow_enum)]
  11 #![recursion_limit = "512"]
  12 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
  13 #![allow(clippy::missing_docs_in_private_items, clippy::must_use_candidate)]
  14 #![warn(trivial_casts, trivial_numeric_casts)]
  15 // warn on lints, that are included in `rust-lang/rust`s bootstrap
  16 #![warn(rust_2018_idioms, unused_lifetimes)]
  17 // warn on rustc internal lints
  18 #![warn(rustc::internal)]
  19
  20 // FIXME: switch to something more ergonomic here, once available.
  21 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
  22 extern crate rustc_ast;
  23 extern crate rustc_ast_pretty;
  24 extern crate rustc_data_structures;
  25 extern crate rustc_driver;
  26 extern crate rustc_errors;
  27 extern crate rustc_hir;
  28 extern crate rustc_hir_pretty;
  29 extern crate rustc_index;
  30 extern crate rustc_infer;
  31 extern crate rustc_lexer;
  32 extern crate rustc_lint;
  33 extern crate rustc_middle;
  34 extern crate rustc_mir_dataflow;
  35 extern crate rustc_parse;
  36 extern crate rustc_parse_format;
  37 extern crate rustc_session;
  38 extern crate rustc_span;
  39 extern crate rustc_target;
  40 extern crate rustc_trait_selection;
  41 extern crate rustc_typeck;
  42
  43 #[macro_use]
  44 extern crate clippy_utils;
  45
  46 use clippy_utils::parse_msrv;
  47 use rustc_data_structures::fx::FxHashSet;
  48 use rustc_lint::LintId;
  49 use rustc_session::Session;
  50
  51 /// Macro used to declare a Clippy lint.
  52 ///
  53 /// Every lint declaration consists of 4 parts:
  54 ///
  55 /// 1. The documentation, which is used for the website
  56 /// 2. The `LINT_NAME`. See [lint naming][lint_naming] on lint naming conventions.
  57 /// 3. The `lint_level`, which is a mapping from *one* of our lint groups to `Allow`, `Warn` or
  58 ///    `Deny`. The lint level here has nothing to do with what lint groups the lint is a part of.
  59 /// 4. The `description` that contains a short explanation on what's wrong with code where the
  60 ///    lint is triggered.
  61 ///
  62 /// Currently the categories `style`, `correctness`, `suspicious`, `complexity` and `perf` are
  63 /// enabled by default. As said in the README.md of this repository, if the lint level mapping
  64 /// changes, please update README.md.
  65 ///
  66 /// # Example
  67 ///
  68 /// ```
  69 /// #![feature(rustc_private)]
  70 /// extern crate rustc_session;
  71 /// use rustc_session::declare_tool_lint;
  72 /// use clippy_lints::declare_clippy_lint;
  73 ///
  74 /// declare_clippy_lint! {
  75 ///     /// ### What it does
  76 ///     /// Checks for ... (describe what the lint matches).
  77 ///     ///
  78 ///     /// ### Why is this bad?
  79 ///     /// Supply the reason for linting the code.
  80 ///     ///
  81 ///     /// ### Example
  82 ///     /// ```rust
  83 ///     /// // Bad
  84 ///     /// Insert a short example of code that triggers the lint
  85 ///     ///
  86 ///     /// // Good
  87 ///     /// Insert a short example of improved code that doesn't trigger the lint
  88 ///     /// ```
  89 ///     pub LINT_NAME,
  90 ///     pedantic,
  91 ///     "description"
  92 /// }
  93 /// ```
  94 /// [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
  95 #[macro_export]
  96 macro_rules! declare_clippy_lint {
  97     { $(#[$attr:meta])* pub $name:tt, style, $description:tt } => {
  98         declare_tool_lint! {
  99             $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
 100         }
 101     };
 102     { $(#[$attr:meta])* pub $name:tt, correctness, $description:tt } => {
 103         declare_tool_lint! {
 104             $(#[$attr])* pub clippy::$name, Deny, $description, report_in_external_macro: true
 105         }
 106     };
 107     { $(#[$attr:meta])* pub $name:tt, suspicious, $description:tt } => {
 108         declare_tool_lint! {
 109             $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
 110         }
 111     };
 112     { $(#[$attr:meta])* pub $name:tt, complexity, $description:tt } => {
 113         declare_tool_lint! {
 114             $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
 115         }
 116     };
 117     { $(#[$attr:meta])* pub $name:tt, perf, $description:tt } => {
 118         declare_tool_lint! {
 119             $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
 120         }
 121     };
 122     { $(#[$attr:meta])* pub $name:tt, pedantic, $description:tt } => {
 123         declare_tool_lint! {
 124             $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
 125         }
 126     };
 127     { $(#[$attr:meta])* pub $name:tt, restriction, $description:tt } => {
 128         declare_tool_lint! {
 129             $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
 130         }
 131     };
 132     { $(#[$attr:meta])* pub $name:tt, cargo, $description:tt } => {
 133         declare_tool_lint! {
 134             $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
 135         }
 136     };
 137     { $(#[$attr:meta])* pub $name:tt, nursery, $description:tt } => {
 138         declare_tool_lint! {
 139             $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
 140         }
 141     };
 142     { $(#[$attr:meta])* pub $name:tt, internal, $description:tt } => {
 143         declare_tool_lint! {
 144             $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
 145         }
 146     };
 147     { $(#[$attr:meta])* pub $name:tt, internal_warn, $description:tt } => {
 148         declare_tool_lint! {
 149             $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
 150         }
 151     };
 152 }
 153
 154 #[cfg(feature = "metadata-collector-lint")]
 155 mod deprecated_lints;
 156 mod utils;
 157
 158 include!("lib.mods.rs");
 159
 160 pub use crate::utils::conf::Conf;
 161 use crate::utils::conf::TryConf;
 162
 163 /// Register all pre expansion lints
 164 ///
 165 /// Pre-expansion lints run before any macro expansion has happened.
 166 ///
 167 /// Note that due to the architecture of the compiler, currently `cfg_attr` attributes on crate
 168 /// level (i.e `#![cfg_attr(...)]`) will still be expanded even when using a pre-expansion pass.
 169 ///
 170 /// Used in `./src/driver.rs`.
 171 pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore) {
 172     // NOTE: Do not add any more pre-expansion passes. These should be removed eventually.
 173     store.register_pre_expansion_pass(|| Box::new(write::Write::default()));
 174     store.register_pre_expansion_pass(|| Box::new(attrs::EarlyAttributes));
 175     store.register_pre_expansion_pass(|| Box::new(dbg_macro::DbgMacro));
 176 }
 177
 178 #[doc(hidden)]
 179 pub fn read_conf(sess: &Session) -> Conf {
 180     let file_name = match utils::conf::lookup_conf_file() {
 181         Ok(Some(path)) => path,
 182         Ok(None) => return Conf::default(),
 183         Err(error) => {
 184             sess.struct_err(&format!("error finding Clippy's configuration file: {}", error))
 185                 .emit();
 186             return Conf::default();
 187         },
 188     };
 189
 190     let TryConf { conf, errors } = utils::conf::read(&file_name);
 191     // all conf errors are non-fatal, we just use the default conf in case of error
 192     for error in errors {
 193         sess.struct_err(&format!(
 194             "error reading Clippy's configuration file `{}`: {}",
 195             file_name.display(),
 196             error
 197         ))
 198         .emit();
 199     }
 200
 201     conf
 202 }
 203
 204 /// Register all lints and lint groups with the rustc plugin registry
 205 ///
 206 /// Used in `./src/driver.rs`.
 207 #[allow(clippy::too_many_lines)]
 208 #[rustfmt::skip]
 209 pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
 210     register_removed_non_tool_lints(store);
 211
 212     include!("lib.deprecated.rs");
 213
 214     include!("lib.register_lints.rs");
 215     include!("lib.register_restriction.rs");
 216     include!("lib.register_pedantic.rs");
 217
 218     #[cfg(feature = "internal-lints")]
 219     include!("lib.register_internal.rs");
 220
 221     include!("lib.register_all.rs");
 222     include!("lib.register_style.rs");
 223     include!("lib.register_complexity.rs");
 224     include!("lib.register_correctness.rs");
 225     include!("lib.register_suspicious.rs");
 226     include!("lib.register_perf.rs");
 227     include!("lib.register_cargo.rs");
 228     include!("lib.register_nursery.rs");
 229
 230     #[cfg(feature = "metadata-collector-lint")]
 231     {
 232         if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
 233             store.register_late_pass(|| Box::new(utils::internal_lints::metadata_collector::MetadataCollector::new()));
 234             return;
 235         }
 236     }
 237
 238     // all the internal lints
 239     #[cfg(feature = "internal-lints")]
 240     {
 241         store.register_early_pass(|| Box::new(utils::internal_lints::ClippyLintsInternal));
 242         store.register_early_pass(|| Box::new(utils::internal_lints::ProduceIce));
 243         store.register_late_pass(|| Box::new(utils::inspector::DeepCodeInspector));
 244         store.register_late_pass(|| Box::new(utils::internal_lints::CollapsibleCalls));
 245         store.register_late_pass(|| Box::new(utils::internal_lints::CompilerLintFunctions::new()));
 246         store.register_late_pass(|| Box::new(utils::internal_lints::IfChainStyle));
 247         store.register_late_pass(|| Box::new(utils::internal_lints::InvalidPaths));
 248         store.register_late_pass(|| Box::new(utils::internal_lints::InterningDefinedSymbol::default()));
 249         store.register_late_pass(|| Box::new(utils::internal_lints::LintWithoutLintPass::default()));
 250         store.register_late_pass(|| Box::new(utils::internal_lints::MatchTypeOnDiagItem));
 251         store.register_late_pass(|| Box::new(utils::internal_lints::OuterExpnDataPass));
 252     }
 253
 254     store.register_late_pass(|| Box::new(utils::author::Author));
 255     store.register_late_pass(|| Box::new(await_holding_invalid::AwaitHolding));
 256     store.register_late_pass(|| Box::new(serde_api::SerdeApi));
 257     let vec_box_size_threshold = conf.vec_box_size_threshold;
 258     let type_complexity_threshold = conf.type_complexity_threshold;
 259     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
 260     store.register_late_pass(move || Box::new(types::Types::new(
 261         vec_box_size_threshold,
 262         type_complexity_threshold,
 263         avoid_breaking_exported_api,
 264     )));
 265     store.register_late_pass(|| Box::new(booleans::NonminimalBool));
 266     store.register_late_pass(|| Box::new(needless_bitwise_bool::NeedlessBitwiseBool));
 267     store.register_late_pass(|| Box::new(eq_op::EqOp));
 268     store.register_late_pass(|| Box::new(enum_clike::UnportableVariant));
 269     store.register_late_pass(|| Box::new(float_literal::FloatLiteral));
 270     let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
 271     store.register_late_pass(move || Box::new(bit_mask::BitMask::new(verbose_bit_mask_threshold)));
 272     store.register_late_pass(|| Box::new(ptr::Ptr));
 273     store.register_late_pass(|| Box::new(ptr_eq::PtrEq));
 274     store.register_late_pass(|| Box::new(needless_bool::NeedlessBool));
 275     store.register_late_pass(|| Box::new(needless_option_as_deref::OptionNeedlessDeref));
 276     store.register_late_pass(|| Box::new(needless_bool::BoolComparison));
 277     store.register_late_pass(|| Box::new(needless_for_each::NeedlessForEach));
 278     store.register_late_pass(|| Box::new(misc::MiscLints));
 279     store.register_late_pass(|| Box::new(eta_reduction::EtaReduction));
 280     store.register_late_pass(|| Box::new(identity_op::IdentityOp));
 281     store.register_late_pass(|| Box::new(erasing_op::ErasingOp));
 282     store.register_late_pass(|| Box::new(mut_mut::MutMut));
 283     store.register_late_pass(|| Box::new(mut_reference::UnnecessaryMutPassed));
 284     store.register_late_pass(|| Box::new(len_zero::LenZero));
 285     store.register_late_pass(|| Box::new(attrs::Attributes));
 286     store.register_late_pass(|| Box::new(blocks_in_if_conditions::BlocksInIfConditions));
 287     store.register_late_pass(|| Box::new(collapsible_match::CollapsibleMatch));
 288     store.register_late_pass(|| Box::new(unicode::Unicode));
 289     store.register_late_pass(|| Box::new(unit_return_expecting_ord::UnitReturnExpectingOrd));
 290     store.register_late_pass(|| Box::new(strings::StringAdd));
 291     store.register_late_pass(|| Box::new(implicit_return::ImplicitReturn));
 292     store.register_late_pass(|| Box::new(implicit_saturating_sub::ImplicitSaturatingSub));
 293     store.register_late_pass(|| Box::new(default_numeric_fallback::DefaultNumericFallback));
 294     store.register_late_pass(|| Box::new(inconsistent_struct_constructor::InconsistentStructConstructor));
 295     store.register_late_pass(|| Box::new(non_octal_unix_permissions::NonOctalUnixPermissions));
 296     store.register_early_pass(|| Box::new(unnecessary_self_imports::UnnecessarySelfImports));
 297
 298     let msrv = conf.msrv.as_ref().and_then(|s| {
 299         parse_msrv(s, None, None).or_else(|| {
 300             sess.err(&format!("error reading Clippy's configuration file. `{}` is not a valid Rust version", s));
 301             None
 302         })
 303     });
 304
 305     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
 306     store.register_late_pass(move || Box::new(approx_const::ApproxConstant::new(msrv)));
 307     store.register_late_pass(move || Box::new(methods::Methods::new(avoid_breaking_exported_api, msrv)));
 308     store.register_late_pass(move || Box::new(matches::Matches::new(msrv)));
 309     store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustive::new(msrv)));
 310     store.register_late_pass(move || Box::new(manual_strip::ManualStrip::new(msrv)));
 311     store.register_early_pass(move || Box::new(redundant_static_lifetimes::RedundantStaticLifetimes::new(msrv)));
 312     store.register_early_pass(move || Box::new(redundant_field_names::RedundantFieldNames::new(msrv)));
 313     store.register_late_pass(move || Box::new(checked_conversions::CheckedConversions::new(msrv)));
 314     store.register_late_pass(move || Box::new(mem_replace::MemReplace::new(msrv)));
 315     store.register_late_pass(move || Box::new(ranges::Ranges::new(msrv)));
 316     store.register_late_pass(move || Box::new(from_over_into::FromOverInto::new(msrv)));
 317     store.register_late_pass(move || Box::new(use_self::UseSelf::new(msrv)));
 318     store.register_late_pass(move || Box::new(missing_const_for_fn::MissingConstForFn::new(msrv)));
 319     store.register_late_pass(move || Box::new(needless_question_mark::NeedlessQuestionMark));
 320     store.register_late_pass(move || Box::new(casts::Casts::new(msrv)));
 321     store.register_early_pass(move || Box::new(unnested_or_patterns::UnnestedOrPatterns::new(msrv)));
 322
 323     store.register_late_pass(|| Box::new(size_of_in_element_count::SizeOfInElementCount));
 324     store.register_late_pass(|| Box::new(same_name_method::SameNameMethod));
 325     store.register_late_pass(|| Box::new(map_clone::MapClone));
 326     store.register_late_pass(|| Box::new(map_err_ignore::MapErrIgnore));
 327     store.register_late_pass(|| Box::new(shadow::Shadow::default()));
 328     store.register_late_pass(|| Box::new(unit_types::UnitTypes));
 329     store.register_late_pass(|| Box::new(loops::Loops));
 330     store.register_late_pass(|| Box::new(main_recursion::MainRecursion::default()));
 331     store.register_late_pass(|| Box::new(lifetimes::Lifetimes));
 332     store.register_late_pass(|| Box::new(entry::HashMapPass));
 333     store.register_late_pass(|| Box::new(minmax::MinMaxPass));
 334     store.register_late_pass(|| Box::new(open_options::OpenOptions));
 335     store.register_late_pass(|| Box::new(zero_div_zero::ZeroDiv));
 336     store.register_late_pass(|| Box::new(mutex_atomic::Mutex));
 337     store.register_late_pass(|| Box::new(needless_update::NeedlessUpdate));
 338     store.register_late_pass(|| Box::new(needless_borrow::NeedlessBorrow::default()));
 339     store.register_late_pass(|| Box::new(needless_borrowed_ref::NeedlessBorrowedRef));
 340     store.register_late_pass(|| Box::new(no_effect::NoEffect));
 341     store.register_late_pass(|| Box::new(temporary_assignment::TemporaryAssignment));
 342     store.register_late_pass(|| Box::new(transmute::Transmute));
 343     let cognitive_complexity_threshold = conf.cognitive_complexity_threshold;
 344     store.register_late_pass(move || Box::new(cognitive_complexity::CognitiveComplexity::new(cognitive_complexity_threshold)));
 345     let too_large_for_stack = conf.too_large_for_stack;
 346     store.register_late_pass(move || Box::new(escape::BoxedLocal{too_large_for_stack}));
 347     store.register_late_pass(move || Box::new(vec::UselessVec{too_large_for_stack}));
 348     store.register_late_pass(|| Box::new(panic_unimplemented::PanicUnimplemented));
 349     store.register_late_pass(|| Box::new(strings::StringLitAsBytes));
 350     store.register_late_pass(|| Box::new(derive::Derive));
 351     store.register_late_pass(|| Box::new(derivable_impls::DerivableImpls));
 352     store.register_late_pass(|| Box::new(get_last_with_len::GetLastWithLen));
 353     store.register_late_pass(|| Box::new(drop_forget_ref::DropForgetRef));
 354     store.register_late_pass(|| Box::new(empty_enum::EmptyEnum));
 355     store.register_late_pass(|| Box::new(absurd_extreme_comparisons::AbsurdExtremeComparisons));
 356     store.register_late_pass(|| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
 357     store.register_late_pass(|| Box::new(regex::Regex));
 358     store.register_late_pass(|| Box::new(copies::CopyAndPaste));
 359     store.register_late_pass(|| Box::new(copy_iterator::CopyIterator));
 360     store.register_late_pass(|| Box::new(format::UselessFormat));
 361     store.register_late_pass(|| Box::new(swap::Swap));
 362     store.register_late_pass(|| Box::new(overflow_check_conditional::OverflowCheckConditional));
 363     store.register_late_pass(|| Box::new(new_without_default::NewWithoutDefault::default()));
 364     let blacklisted_names = conf.blacklisted_names.iter().cloned().collect::<FxHashSet<_>>();
 365     store.register_late_pass(move || Box::new(blacklisted_name::BlacklistedName::new(blacklisted_names.clone())));
 366     let too_many_arguments_threshold = conf.too_many_arguments_threshold;
 367     let too_many_lines_threshold = conf.too_many_lines_threshold;
 368     store.register_late_pass(move || Box::new(functions::Functions::new(too_many_arguments_threshold, too_many_lines_threshold)));
 369     let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
 370     store.register_late_pass(move || Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
 371     store.register_late_pass(|| Box::new(neg_multiply::NegMultiply));
 372     store.register_late_pass(|| Box::new(mem_discriminant::MemDiscriminant));
 373     store.register_late_pass(|| Box::new(mem_forget::MemForget));
 374     store.register_late_pass(|| Box::new(arithmetic::Arithmetic::default()));
 375     store.register_late_pass(|| Box::new(assign_ops::AssignOps));
 376     store.register_late_pass(|| Box::new(let_if_seq::LetIfSeq));
 377     store.register_late_pass(|| Box::new(eval_order_dependence::EvalOrderDependence));
 378     store.register_late_pass(|| Box::new(missing_doc::MissingDoc::new()));
 379     store.register_late_pass(|| Box::new(missing_inline::MissingInline));
 380     store.register_late_pass(move || Box::new(exhaustive_items::ExhaustiveItems));
 381     store.register_late_pass(|| Box::new(match_result_ok::MatchResultOk));
 382     store.register_late_pass(|| Box::new(partialeq_ne_impl::PartialEqNeImpl));
 383     store.register_late_pass(|| Box::new(unused_io_amount::UnusedIoAmount));
 384     let enum_variant_size_threshold = conf.enum_variant_size_threshold;
 385     store.register_late_pass(move || Box::new(large_enum_variant::LargeEnumVariant::new(enum_variant_size_threshold)));
 386     store.register_late_pass(|| Box::new(explicit_write::ExplicitWrite));
 387     store.register_late_pass(|| Box::new(needless_pass_by_value::NeedlessPassByValue));
 388     let pass_by_ref_or_value = pass_by_ref_or_value::PassByRefOrValue::new(
 389         conf.trivial_copy_size_limit,
 390         conf.pass_by_value_size_limit,
 391         conf.avoid_breaking_exported_api,
 392         &sess.target,
 393     );
 394     store.register_late_pass(move || Box::new(pass_by_ref_or_value));
 395     store.register_late_pass(|| Box::new(ref_option_ref::RefOptionRef));
 396     store.register_late_pass(|| Box::new(try_err::TryErr));
 397     store.register_late_pass(|| Box::new(bytecount::ByteCount));
 398     store.register_late_pass(|| Box::new(infinite_iter::InfiniteIter));
 399     store.register_late_pass(|| Box::new(inline_fn_without_body::InlineFnWithoutBody));
 400     store.register_late_pass(|| Box::new(useless_conversion::UselessConversion::default()));
 401     store.register_late_pass(|| Box::new(implicit_hasher::ImplicitHasher));
 402     store.register_late_pass(|| Box::new(fallible_impl_from::FallibleImplFrom));
 403     store.register_late_pass(|| Box::new(double_comparison::DoubleComparisons));
 404     store.register_late_pass(|| Box::new(question_mark::QuestionMark));
 405     store.register_early_pass(|| Box::new(suspicious_operation_groupings::SuspiciousOperationGroupings));
 406     store.register_late_pass(|| Box::new(suspicious_trait_impl::SuspiciousImpl));
 407     store.register_late_pass(|| Box::new(map_unit_fn::MapUnit));
 408     store.register_late_pass(|| Box::new(inherent_impl::MultipleInherentImpl));
 409     store.register_late_pass(|| Box::new(neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd));
 410     store.register_late_pass(|| Box::new(unwrap::Unwrap));
 411     store.register_late_pass(|| Box::new(duration_subsec::DurationSubsec));
 412     store.register_late_pass(|| Box::new(indexing_slicing::IndexingSlicing));
 413     store.register_late_pass(|| Box::new(non_copy_const::NonCopyConst));
 414     store.register_late_pass(|| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
 415     store.register_late_pass(|| Box::new(redundant_clone::RedundantClone));
 416     store.register_late_pass(|| Box::new(slow_vector_initialization::SlowVectorInit));
 417     store.register_late_pass(|| Box::new(unnecessary_sort_by::UnnecessarySortBy));
 418     store.register_late_pass(move || Box::new(unnecessary_wraps::UnnecessaryWraps::new(avoid_breaking_exported_api)));
 419     store.register_late_pass(|| Box::new(assertions_on_constants::AssertionsOnConstants));
 420     store.register_late_pass(|| Box::new(transmuting_null::TransmutingNull));
 421     store.register_late_pass(|| Box::new(path_buf_push_overwrite::PathBufPushOverwrite));
 422     store.register_late_pass(|| Box::new(integer_division::IntegerDivision));
 423     store.register_late_pass(|| Box::new(inherent_to_string::InherentToString));
 424     let max_trait_bounds = conf.max_trait_bounds;
 425     store.register_late_pass(move || Box::new(trait_bounds::TraitBounds::new(max_trait_bounds)));
 426     store.register_late_pass(|| Box::new(comparison_chain::ComparisonChain));
 427     store.register_late_pass(|| Box::new(mut_key::MutableKeyType));
 428     store.register_late_pass(|| Box::new(modulo_arithmetic::ModuloArithmetic));
 429     store.register_early_pass(|| Box::new(reference::DerefAddrOf));
 430     store.register_early_pass(|| Box::new(reference::RefInDeref));
 431     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
 432     store.register_late_pass(|| Box::new(to_string_in_display::ToStringInDisplay::new()));
 433     store.register_early_pass(|| Box::new(unsafe_removed_from_name::UnsafeNameRemoval));
 434     store.register_early_pass(|| Box::new(if_not_else::IfNotElse));
 435     store.register_early_pass(|| Box::new(else_if_without_else::ElseIfWithoutElse));
 436     store.register_early_pass(|| Box::new(int_plus_one::IntPlusOne));
 437     store.register_early_pass(|| Box::new(formatting::Formatting));
 438     store.register_early_pass(|| Box::new(misc_early::MiscEarlyLints));
 439     store.register_early_pass(|| Box::new(redundant_closure_call::RedundantClosureCall));
 440     store.register_late_pass(|| Box::new(redundant_closure_call::RedundantClosureCall));
 441     store.register_early_pass(|| Box::new(unused_unit::UnusedUnit));
 442     store.register_late_pass(|| Box::new(returns::Return));
 443     store.register_early_pass(|| Box::new(collapsible_if::CollapsibleIf));
 444     store.register_early_pass(|| Box::new(items_after_statements::ItemsAfterStatements));
 445     store.register_early_pass(|| Box::new(precedence::Precedence));
 446     store.register_early_pass(|| Box::new(needless_continue::NeedlessContinue));
 447     store.register_early_pass(|| Box::new(redundant_else::RedundantElse));
 448     store.register_late_pass(|| Box::new(create_dir::CreateDir));
 449     store.register_early_pass(|| Box::new(needless_arbitrary_self_type::NeedlessArbitrarySelfType));
 450     let cargo_ignore_publish = conf.cargo_ignore_publish;
 451     store.register_late_pass(move || Box::new(cargo_common_metadata::CargoCommonMetadata::new(cargo_ignore_publish)));
 452     store.register_late_pass(|| Box::new(multiple_crate_versions::MultipleCrateVersions));
 453     store.register_late_pass(|| Box::new(wildcard_dependencies::WildcardDependencies));
 454     let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
 455     store.register_early_pass(move || Box::new(literal_representation::LiteralDigitGrouping::new(literal_representation_lint_fraction_readability)));
 456     let literal_representation_threshold = conf.literal_representation_threshold;
 457     store.register_early_pass(move || Box::new(literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold)));
 458     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
 459     store.register_late_pass(move || Box::new(enum_variants::EnumVariantNames::new(enum_variant_name_threshold, avoid_breaking_exported_api)));
 460     store.register_early_pass(|| Box::new(tabs_in_doc_comments::TabsInDocComments));
 461     let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
 462     store.register_late_pass(move || Box::new(upper_case_acronyms::UpperCaseAcronyms::new(avoid_breaking_exported_api, upper_case_acronyms_aggressive)));
 463     store.register_late_pass(|| Box::new(default::Default::default()));
 464     store.register_late_pass(|| Box::new(unused_self::UnusedSelf));
 465     store.register_late_pass(|| Box::new(mutable_debug_assertion::DebugAssertWithMutCall));
 466     store.register_late_pass(|| Box::new(exit::Exit));
 467     store.register_late_pass(|| Box::new(to_digit_is_some::ToDigitIsSome));
 468     let array_size_threshold = conf.array_size_threshold;
 469     store.register_late_pass(move || Box::new(large_stack_arrays::LargeStackArrays::new(array_size_threshold)));
 470     store.register_late_pass(move || Box::new(large_const_arrays::LargeConstArrays::new(array_size_threshold)));
 471     store.register_late_pass(|| Box::new(floating_point_arithmetic::FloatingPointArithmetic));
 472     store.register_early_pass(|| Box::new(as_conversions::AsConversions));
 473     store.register_late_pass(|| Box::new(let_underscore::LetUnderscore));
 474     store.register_early_pass(|| Box::new(single_component_path_imports::SingleComponentPathImports));
 475     let max_fn_params_bools = conf.max_fn_params_bools;
 476     let max_struct_bools = conf.max_struct_bools;
 477     store.register_early_pass(move || Box::new(excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools)));
 478     store.register_early_pass(|| Box::new(option_env_unwrap::OptionEnvUnwrap));
 479     let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
 480     store.register_late_pass(move || Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
 481     store.register_late_pass(|| Box::new(verbose_file_reads::VerboseFileReads));
 482     store.register_late_pass(|| Box::new(redundant_pub_crate::RedundantPubCrate::default()));
 483     store.register_late_pass(|| Box::new(unnamed_address::UnnamedAddress));
 484     store.register_late_pass(|| Box::new(dereference::Dereferencing::default()));
 485     store.register_late_pass(|| Box::new(option_if_let_else::OptionIfLetElse));
 486     store.register_late_pass(|| Box::new(future_not_send::FutureNotSend));
 487     store.register_late_pass(|| Box::new(if_let_mutex::IfLetMutex));
 488     store.register_late_pass(|| Box::new(mut_mutex_lock::MutMutexLock));
 489     store.register_late_pass(|| Box::new(match_on_vec_items::MatchOnVecItems));
 490     store.register_late_pass(|| Box::new(manual_async_fn::ManualAsyncFn));
 491     store.register_late_pass(|| Box::new(vec_resize_to_zero::VecResizeToZero));
 492     store.register_late_pass(|| Box::new(panic_in_result_fn::PanicInResultFn));
 493     let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
 494     store.register_early_pass(move || Box::new(non_expressive_names::NonExpressiveNames {
 495         single_char_binding_names_threshold,
 496     }));
 497     let macro_matcher = conf.standard_macro_braces.iter().cloned().collect::<FxHashSet<_>>();
 498     store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(&macro_matcher)));
 499     store.register_late_pass(|| Box::new(macro_use::MacroUseImports::default()));
 500     store.register_late_pass(|| Box::new(pattern_type_mismatch::PatternTypeMismatch));
 501     store.register_late_pass(|| Box::new(stable_sort_primitive::StableSortPrimitive));
 502     store.register_late_pass(|| Box::new(repeat_once::RepeatOnce));
 503     store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
 504     store.register_late_pass(|| Box::new(self_assignment::SelfAssignment));
 505     store.register_late_pass(|| Box::new(manual_unwrap_or::ManualUnwrapOr));
 506     store.register_late_pass(|| Box::new(manual_ok_or::ManualOkOr));
 507     store.register_late_pass(|| Box::new(float_equality_without_abs::FloatEqualityWithoutAbs));
 508     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
 509     store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
 510     let disallowed_methods = conf.disallowed_methods.clone();
 511     store.register_late_pass(move || Box::new(disallowed_method::DisallowedMethod::new(disallowed_methods.clone())));
 512     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86AttSyntax));
 513     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86IntelSyntax));
 514     store.register_late_pass(|| Box::new(undropped_manually_drops::UndroppedManuallyDrops));
 515     store.register_late_pass(|| Box::new(strings::StrToString));
 516     store.register_late_pass(|| Box::new(strings::StringToString));
 517     store.register_late_pass(|| Box::new(zero_sized_map_values::ZeroSizedMapValues));
 518     store.register_late_pass(|| Box::new(vec_init_then_push::VecInitThenPush::default()));
 519     store.register_late_pass(|| Box::new(case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons));
 520     store.register_late_pass(|| Box::new(redundant_slicing::RedundantSlicing));
 521     store.register_late_pass(|| Box::new(from_str_radix_10::FromStrRadix10));
 522     store.register_late_pass(|| Box::new(manual_map::ManualMap));
 523     store.register_late_pass(move || Box::new(if_then_some_else_none::IfThenSomeElseNone::new(msrv)));
 524     store.register_late_pass(|| Box::new(bool_assert_comparison::BoolAssertComparison));
 525     store.register_early_pass(move || Box::new(module_style::ModStyle));
 526     store.register_late_pass(|| Box::new(unused_async::UnusedAsync));
 527     let disallowed_types = conf.disallowed_types.iter().cloned().collect::<FxHashSet<_>>();
 528     store.register_late_pass(move || Box::new(disallowed_type::DisallowedType::new(&disallowed_types)));
 529     let import_renames = conf.enforced_import_renames.clone();
 530     store.register_late_pass(move || Box::new(missing_enforced_import_rename::ImportRename::new(import_renames.clone())));
 531     let scripts = conf.allowed_scripts.clone();
 532     store.register_early_pass(move || Box::new(disallowed_script_idents::DisallowedScriptIdents::new(&scripts)));
 533     store.register_late_pass(|| Box::new(strlen_on_c_strings::StrlenOnCStrings));
 534     store.register_late_pass(move || Box::new(self_named_constructors::SelfNamedConstructors));
 535     store.register_late_pass(move || Box::new(feature_name::FeatureName));
 536     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
 537     store.register_late_pass(move || Box::new(if_then_panic::IfThenPanic));
 538     let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
 539     store.register_late_pass(move || Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
 540 }
 541
 542 #[rustfmt::skip]
 543 fn register_removed_non_tool_lints(store: &mut rustc_lint::LintStore) {
 544     store.register_removed(
 545         "should_assert_eq",
 546         "`assert!()` will be more flexible with RFC 2011",
 547     );
 548     store.register_removed(
 549         "extend_from_slice",
 550         "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice",
 551     );
 552     store.register_removed(
 553         "range_step_by_zero",
 554         "`iterator.step_by(0)` panics nowadays",
 555     );
 556     store.register_removed(
 557         "unstable_as_slice",
 558         "`Vec::as_slice` has been stabilized in 1.7",
 559     );
 560     store.register_removed(
 561         "unstable_as_mut_slice",
 562         "`Vec::as_mut_slice` has been stabilized in 1.7",
 563     );
 564     store.register_removed(
 565         "misaligned_transmute",
 566         "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
 567     );
 568     store.register_removed(
 569         "assign_ops",
 570         "using compound assignment operators (e.g., `+=`) is harmless",
 571     );
 572     store.register_removed(
 573         "if_let_redundant_pattern_matching",
 574         "this lint has been changed to redundant_pattern_matching",
 575     );
 576     store.register_removed(
 577         "unsafe_vector_initialization",
 578         "the replacement suggested by this lint had substantially different behavior",
 579     );
 580     store.register_removed(
 581         "reverse_range_loop",
 582         "this lint is now included in reversed_empty_ranges",
 583     );
 584 }
 585
 586 /// Register renamed lints.
 587 ///
 588 /// Used in `./src/driver.rs`.
 589 pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
 590     ls.register_renamed("clippy::stutter", "clippy::module_name_repetitions");
 591     ls.register_renamed("clippy::new_without_default_derive", "clippy::new_without_default");
 592     ls.register_renamed("clippy::cyclomatic_complexity", "clippy::cognitive_complexity");
 593     ls.register_renamed("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes");
 594     ls.register_renamed("clippy::option_and_then_some", "clippy::bind_instead_of_map");
 595     ls.register_renamed("clippy::box_vec", "clippy::box_collection");
 596     ls.register_renamed("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions");
 597     ls.register_renamed("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions");
 598     ls.register_renamed("clippy::option_map_unwrap_or", "clippy::map_unwrap_or");
 599     ls.register_renamed("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or");
 600     ls.register_renamed("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or");
 601     ls.register_renamed("clippy::option_unwrap_used", "clippy::unwrap_used");
 602     ls.register_renamed("clippy::result_unwrap_used", "clippy::unwrap_used");
 603     ls.register_renamed("clippy::option_expect_used", "clippy::expect_used");
 604     ls.register_renamed("clippy::result_expect_used", "clippy::expect_used");
 605     ls.register_renamed("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles");
 606     ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles");
 607     ls.register_renamed("clippy::identity_conversion", "clippy::useless_conversion");
 608     ls.register_renamed("clippy::zero_width_space", "clippy::invisible_characters");
 609     ls.register_renamed("clippy::single_char_push_str", "clippy::single_char_add_str");
 610     ls.register_renamed("clippy::if_let_some_result", "clippy::match_result_ok");
 611
 612     // uplifted lints
 613     ls.register_renamed("clippy::invalid_ref", "invalid_value");
 614     ls.register_renamed("clippy::into_iter_on_array", "array_into_iter");
 615     ls.register_renamed("clippy::unused_label", "unused_labels");
 616     ls.register_renamed("clippy::drop_bounds", "drop_bounds");
 617     ls.register_renamed("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr");
 618     ls.register_renamed("clippy::panic_params", "non_fmt_panics");
 619     ls.register_renamed("clippy::unknown_clippy_lints", "unknown_lints");
 620     ls.register_renamed("clippy::invalid_atomic_ordering", "invalid_atomic_ordering");
 621 }
 622
 623 // only exists to let the dogfood integration test works.
 624 // Don't run clippy as an executable directly
 625 #[allow(dead_code)]
 626 fn main() {
 627     panic!("Please use the cargo-clippy executable");
 628 }