From 695aa59c6df35343ebbcb153f6249cde0d018139 Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Fri, 18 Oct 2019 21:09:42 +0200 Subject: [PATCH 1/9] Add lint for exit --- clippy_lints/src/exit.rs | 41 +++++++++++++++++++++++++++++++++ clippy_lints/src/lib.rs | 2 ++ clippy_lints/src/utils/paths.rs | 1 + tests/ui/exit.rs | 4 ++++ tests/ui/exit.stderr | 10 ++++++++ 5 files changed, 58 insertions(+) create mode 100644 clippy_lints/src/exit.rs create mode 100644 tests/ui/exit.rs create mode 100644 tests/ui/exit.stderr diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs new file mode 100644 index 000000000000..222f84bd028e --- /dev/null +++ b/clippy_lints/src/exit.rs @@ -0,0 +1,41 @@ +use crate::utils::{match_def_path, paths, qpath_res, span_lint}; +use if_chain::if_chain; +use rustc::hir::{Expr, ExprKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_lint_pass, declare_tool_lint}; + +declare_clippy_lint! { + /// **What it does:** `exit()` terminates the program and doesn't provide a + /// stack trace. + /// + /// **Why is this bad?** Ideally a program is terminated by finishing + /// the main function. + /// + /// **Known problems:** This can be valid code in main() to return + /// errors + /// + /// **Example:** + /// ```ignore + /// std::process::exit(0) + /// ``` + pub EXIT, + restriction, + "`std::process::exit` is called, terminating the program" +} + +declare_lint_pass!(Exit => [EXIT]); + +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Exit { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { + if_chain! { + if let ExprKind::Call(ref path_expr, ref _args) = e.kind; + if let ExprKind::Path(ref path) = path_expr.kind; + if let Some(def_id) = qpath_res(cx, path, path_expr.hir_id).opt_def_id(); + if match_def_path(cx, def_id, &paths::EXIT); + then { + span_lint(cx, EXIT, e.span, "usage of `process::exit`"); + } + + } + } +} diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index 1bd117dae943..99bbaf32c290 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -188,6 +188,7 @@ pub mod escape; pub mod eta_reduction; pub mod eval_order_dependence; pub mod excessive_precision; +pub mod exit; pub mod explicit_write; pub mod fallible_impl_from; pub mod format; @@ -941,6 +942,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold)); store.register_late_pass(|| box unused_self::UnusedSelf); store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall); + reg.register_late_lint_pass(||box exit::Exit); store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![ LintId::of(&arithmetic::FLOAT_ARITHMETIC), diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs index 9787517e5055..042ca4ee7fdc 100644 --- a/clippy_lints/src/utils/paths.rs +++ b/clippy_lints/src/utils/paths.rs @@ -27,6 +27,7 @@ pub const DROP: [&str; 3] = ["core", "mem", "drop"]; pub const DROP_TRAIT: [&str; 4] = ["core", "ops", "drop", "Drop"]; pub const DURATION: [&str; 3] = ["core", "time", "Duration"]; pub const EARLY_CONTEXT: [&str; 4] = ["rustc", "lint", "context", "EarlyContext"]; +pub const EXIT: [&str; 3] = ["std", "process", "exit"]; pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"]; pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"]; pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"]; diff --git a/tests/ui/exit.rs b/tests/ui/exit.rs new file mode 100644 index 000000000000..1850241c4768 --- /dev/null +++ b/tests/ui/exit.rs @@ -0,0 +1,4 @@ +#[warn(clippy::exit)] +fn main() { + std::process::exit(1); +} diff --git a/tests/ui/exit.stderr b/tests/ui/exit.stderr new file mode 100644 index 000000000000..4fd294395501 --- /dev/null +++ b/tests/ui/exit.stderr @@ -0,0 +1,10 @@ +error: usage of `process::exit` + --> $DIR/exit.rs:3:5 + | +LL | std::process::exit(1); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: `-D clippy::exit` implied by `-D warnings` + +error: aborting due to previous error + From 60c2fdd0b96829df97329e29fdb92c958a3c5d4f Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Fri, 18 Oct 2019 21:10:35 +0200 Subject: [PATCH 2/9] Update lints --- CHANGELOG.md | 1 + clippy_lints/src/lib.rs | 1 + src/lintlist/mod.rs | 7 +++++++ 3 files changed, 9 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7b32914854fe..84a3bd491cb8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -996,6 +996,7 @@ Released 2018-09-13 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision +[`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit [`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call [`expl_impl_clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#expl_impl_clone_on_copy [`explicit_counter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index 99bbaf32c290..d267a3d47e39 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -949,6 +949,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf LintId::of(&arithmetic::INTEGER_ARITHMETIC), LintId::of(&dbg_macro::DBG_MACRO), LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE), + LintId::of(&exit::EXIT), LintId::of(&implicit_return::IMPLICIT_RETURN), LintId::of(&indexing_slicing::INDEXING_SLICING), LintId::of(&inherent_impl::MULTIPLE_INHERENT_IMPL), diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs index 35cbeae39889..7ce73b6c090f 100644 --- a/src/lintlist/mod.rs +++ b/src/lintlist/mod.rs @@ -490,6 +490,13 @@ pub const ALL_LINTS: [Lint; 331] = [ deprecation: None, module: "excessive_precision", }, + Lint { + name: "exit", + group: "restriction", + desc: "`std::process::exit` is called, terminating the program", + deprecation: None, + module: "exit", + }, Lint { name: "expect_fun_call", group: "perf", From 9471669e4695921cd8b70c8edaad143d8e84f430 Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Sat, 19 Oct 2019 14:31:02 +0200 Subject: [PATCH 3/9] Exclude main from exit lint --- clippy_lints/src/exit.rs | 29 +++++++++++++++++++++++++---- tests/ui/exit.rs | 8 ++++++++ tests/ui/exit.stderr | 2 +- 3 files changed, 34 insertions(+), 5 deletions(-) diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs index 222f84bd028e..9952ef3ea623 100644 --- a/clippy_lints/src/exit.rs +++ b/clippy_lints/src/exit.rs @@ -1,6 +1,6 @@ use crate::utils::{match_def_path, paths, qpath_res, span_lint}; use if_chain::if_chain; -use rustc::hir::{Expr, ExprKind}; +use rustc::hir::{Expr, ExprKind, Item, ItemKind, Node}; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; use rustc::{declare_lint_pass, declare_tool_lint}; @@ -11,8 +11,7 @@ declare_clippy_lint! { /// **Why is this bad?** Ideally a program is terminated by finishing /// the main function. /// - /// **Known problems:** This can be valid code in main() to return - /// errors + /// **Known problems:** None. /// /// **Example:** /// ```ignore @@ -33,7 +32,29 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Exit { if let Some(def_id) = qpath_res(cx, path, path_expr.hir_id).opt_def_id(); if match_def_path(cx, def_id, &paths::EXIT); then { - span_lint(cx, EXIT, e.span, "usage of `process::exit`"); + let mut parent = cx.tcx.hir().get_parent_item(e.hir_id); + // We have to traverse the parents upwards until we find a function + // otherwise a exit in a let or if in main would still trigger this + loop{ + match cx.tcx.hir().find(parent) { + Some(Node::Item(Item{ident, kind: ItemKind::Fn(..), ..})) => { + // If we found a function we check it's name if it is + // `main` we emit a lint. + if ident.name.as_str() != "main" { + span_lint(cx, EXIT, e.span, "usage of `process::exit`"); + } + // We found any kind of function and can end our loop + break; + } + // If we found anything but a funciton we continue with the + // loop and go one parent up + Some(_) => { + cx.tcx.hir().get_parent_item(parent); + }, + // If we found nothing we break. + None => break, + } + } } } diff --git a/tests/ui/exit.rs b/tests/ui/exit.rs index 1850241c4768..bf8ea9bebf7e 100644 --- a/tests/ui/exit.rs +++ b/tests/ui/exit.rs @@ -1,4 +1,12 @@ #[warn(clippy::exit)] +fn not_main() { + std::process::exit(3); +} + fn main() { + if true { + std::process::exit(2); + }; + not_main(); std::process::exit(1); } diff --git a/tests/ui/exit.stderr b/tests/ui/exit.stderr index 4fd294395501..756cf8837491 100644 --- a/tests/ui/exit.stderr +++ b/tests/ui/exit.stderr @@ -1,7 +1,7 @@ error: usage of `process::exit` --> $DIR/exit.rs:3:5 | -LL | std::process::exit(1); +LL | std::process::exit(3); | ^^^^^^^^^^^^^^^^^^^^^ | = note: `-D clippy::exit` implied by `-D warnings` From ffcf4bec0f9785925b12bce49149997b1ba5c79e Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Mon, 21 Oct 2019 22:55:01 +0200 Subject: [PATCH 4/9] Improve function checking --- clippy_lints/src/exit.rs | 7 ++++--- tests/ui/exit.rs | 8 ++++++++ 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs index 9952ef3ea623..23952efbc8d8 100644 --- a/clippy_lints/src/exit.rs +++ b/clippy_lints/src/exit.rs @@ -1,4 +1,4 @@ -use crate::utils::{match_def_path, paths, qpath_res, span_lint}; +use crate::utils::{is_entrypoint_fn, match_def_path, paths, qpath_res, span_lint}; use if_chain::if_chain; use rustc::hir::{Expr, ExprKind, Item, ItemKind, Node}; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; @@ -40,7 +40,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Exit { Some(Node::Item(Item{ident, kind: ItemKind::Fn(..), ..})) => { // If we found a function we check it's name if it is // `main` we emit a lint. - if ident.name.as_str() != "main" { + let def_id = cx.tcx.hir().local_def_id(parent); + if !is_entrypoint_fn(cx, def_id) { span_lint(cx, EXIT, e.span, "usage of `process::exit`"); } // We found any kind of function and can end our loop @@ -49,7 +50,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Exit { // If we found anything but a funciton we continue with the // loop and go one parent up Some(_) => { - cx.tcx.hir().get_parent_item(parent); + parent = cx.tcx.hir().get_parent_item(parent); }, // If we found nothing we break. None => break, diff --git a/tests/ui/exit.rs b/tests/ui/exit.rs index bf8ea9bebf7e..0ad15faef77b 100644 --- a/tests/ui/exit.rs +++ b/tests/ui/exit.rs @@ -1,5 +1,12 @@ #[warn(clippy::exit)] + fn not_main() { + if true { + std::process::exit(4); + } +} + +fn also_not_main() { std::process::exit(3); } @@ -7,6 +14,7 @@ fn main() { if true { std::process::exit(2); }; + also_not_main(); not_main(); std::process::exit(1); } From eae6a62db7582cc0c243a798268a258436c27407 Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Thu, 24 Oct 2019 21:17:21 +0200 Subject: [PATCH 5/9] Simplify dentry point detection --- README.md | 2 +- clippy_lints/src/exit.rs | 28 ++++++---------------------- clippy_lints/src/lib.rs | 1 + src/lintlist/mod.rs | 2 +- 4 files changed, 9 insertions(+), 24 deletions(-) diff --git a/README.md b/README.md index 41b8b4199ec5..922dbcd11380 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code. -[There are 331 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html) +[There are 333 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html) We have a bunch of lint categories to allow you to choose how much Clippy is supposed to ~~annoy~~ help you: diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs index 23952efbc8d8..7220833b9f23 100644 --- a/clippy_lints/src/exit.rs +++ b/clippy_lints/src/exit.rs @@ -33,31 +33,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Exit { if match_def_path(cx, def_id, &paths::EXIT); then { let mut parent = cx.tcx.hir().get_parent_item(e.hir_id); - // We have to traverse the parents upwards until we find a function - // otherwise a exit in a let or if in main would still trigger this - loop{ - match cx.tcx.hir().find(parent) { - Some(Node::Item(Item{ident, kind: ItemKind::Fn(..), ..})) => { - // If we found a function we check it's name if it is - // `main` we emit a lint. - let def_id = cx.tcx.hir().local_def_id(parent); - if !is_entrypoint_fn(cx, def_id) { - span_lint(cx, EXIT, e.span, "usage of `process::exit`"); - } - // We found any kind of function and can end our loop - break; - } - // If we found anything but a funciton we continue with the - // loop and go one parent up - Some(_) => { - parent = cx.tcx.hir().get_parent_item(parent); - }, - // If we found nothing we break. - None => break, + if let Some(Node::Item(Item{ident, kind: ItemKind::Fn(..), ..})) = cx.tcx.hir().find(parent) { + // If the next item up is a function we check if it is an entry point + // and only then emit a linter warning + let def_id = cx.tcx.hir().local_def_id(parent); + if !is_entrypoint_fn(cx, def_id) { + span_lint(cx, EXIT, e.span, "usage of `process::exit`"); } } } - } } } diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index d267a3d47e39..84e074fc2929 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -502,6 +502,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf &eval_order_dependence::DIVERGING_SUB_EXPRESSION, &eval_order_dependence::EVAL_ORDER_DEPENDENCE, &excessive_precision::EXCESSIVE_PRECISION, + &exit::EXIT, &explicit_write::EXPLICIT_WRITE, &fallible_impl_from::FALLIBLE_IMPL_FROM, &format::USELESS_FORMAT, diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs index 7ce73b6c090f..cda2a4faba15 100644 --- a/src/lintlist/mod.rs +++ b/src/lintlist/mod.rs @@ -6,7 +6,7 @@ pub use lint::Lint; pub use lint::LINT_LEVELS; // begin lint list, do not remove this comment, it’s used in `update_lints` -pub const ALL_LINTS: [Lint; 331] = [ +pub const ALL_LINTS: [Lint; 333] = [ Lint { name: "absurd_extreme_comparisons", group: "correctness", From a984702b509ce18d1dc22b1abf627b7c03fd59f6 Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Fri, 25 Oct 2019 10:16:25 +0200 Subject: [PATCH 6/9] Update clippy_lints/src/lib.rs Co-Authored-By: Philipp Krones --- clippy_lints/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index 84e074fc2929..e0a34102ceb6 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -943,7 +943,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold)); store.register_late_pass(|| box unused_self::UnusedSelf); store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall); - reg.register_late_lint_pass(||box exit::Exit); + store.register_late_lint_pass(|| box exit::Exit); store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![ LintId::of(&arithmetic::FLOAT_ARITHMETIC), From abdf027df30b93a0cbd3c00690761ace7ee43430 Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Fri, 25 Oct 2019 10:59:33 +0200 Subject: [PATCH 7/9] Update clippy_lints/src/lib.rs Co-Authored-By: Philipp Krones --- clippy_lints/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index e0a34102ceb6..dae1c429b7d5 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -943,7 +943,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold)); store.register_late_pass(|| box unused_self::UnusedSelf); store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall); - store.register_late_lint_pass(|| box exit::Exit); + store.register_late_pass(|| box exit::Exit); store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![ LintId::of(&arithmetic::FLOAT_ARITHMETIC), From 5e6017d193bfc3891e99018997854bec5c97a919 Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Tue, 29 Oct 2019 21:34:00 +0100 Subject: [PATCH 8/9] Update tests for exit --- tests/ui/{exit.rs => exit1.rs} | 5 ----- tests/ui/exit1.stderr | 10 ++++++++++ tests/ui/exit2.rs | 13 +++++++++++++ tests/ui/{exit.stderr => exit2.stderr} | 2 +- tests/ui/exit3.rs | 8 ++++++++ 5 files changed, 32 insertions(+), 6 deletions(-) rename tests/ui/{exit.rs => exit1.rs} (73%) create mode 100644 tests/ui/exit1.stderr create mode 100644 tests/ui/exit2.rs rename tests/ui/{exit.stderr => exit2.stderr} (89%) create mode 100644 tests/ui/exit3.rs diff --git a/tests/ui/exit.rs b/tests/ui/exit1.rs similarity index 73% rename from tests/ui/exit.rs rename to tests/ui/exit1.rs index 0ad15faef77b..4eac6eb74672 100644 --- a/tests/ui/exit.rs +++ b/tests/ui/exit1.rs @@ -6,15 +6,10 @@ fn not_main() { } } -fn also_not_main() { - std::process::exit(3); -} - fn main() { if true { std::process::exit(2); }; - also_not_main(); not_main(); std::process::exit(1); } diff --git a/tests/ui/exit1.stderr b/tests/ui/exit1.stderr new file mode 100644 index 000000000000..a8d3956aa27a --- /dev/null +++ b/tests/ui/exit1.stderr @@ -0,0 +1,10 @@ +error: usage of `process::exit` + --> $DIR/exit1.rs:5:9 + | +LL | std::process::exit(4); + | ^^^^^^^^^^^^^^^^^^^^^ + | + = note: `-D clippy::exit` implied by `-D warnings` + +error: aborting due to previous error + diff --git a/tests/ui/exit2.rs b/tests/ui/exit2.rs new file mode 100644 index 000000000000..4b693ed7083f --- /dev/null +++ b/tests/ui/exit2.rs @@ -0,0 +1,13 @@ +#[warn(clippy::exit)] + +fn also_not_main() { + std::process::exit(3); +} + +fn main() { + if true { + std::process::exit(2); + }; + also_not_main(); + std::process::exit(1); +} diff --git a/tests/ui/exit.stderr b/tests/ui/exit2.stderr similarity index 89% rename from tests/ui/exit.stderr rename to tests/ui/exit2.stderr index 756cf8837491..7263e156a9d2 100644 --- a/tests/ui/exit.stderr +++ b/tests/ui/exit2.stderr @@ -1,5 +1,5 @@ error: usage of `process::exit` - --> $DIR/exit.rs:3:5 + --> $DIR/exit2.rs:4:5 | LL | std::process::exit(3); | ^^^^^^^^^^^^^^^^^^^^^ diff --git a/tests/ui/exit3.rs b/tests/ui/exit3.rs new file mode 100644 index 000000000000..9dc0e1015a4f --- /dev/null +++ b/tests/ui/exit3.rs @@ -0,0 +1,8 @@ +#[warn(clippy::exit)] + +fn main() { + if true { + std::process::exit(2); + }; + std::process::exit(1); +} From 2f1370d64cb62c521ec04999f30ed856b644dccc Mon Sep 17 00:00:00 2001 From: "Heinz N. Gies" Date: Thu, 7 Nov 2019 17:13:26 +0100 Subject: [PATCH 9/9] Update lints --- README.md | 2 +- src/lintlist/mod.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 922dbcd11380..87ef441eadd5 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code. -[There are 333 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html) +[There are 332 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html) We have a bunch of lint categories to allow you to choose how much Clippy is supposed to ~~annoy~~ help you: diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs index cda2a4faba15..5c92d69a4993 100644 --- a/src/lintlist/mod.rs +++ b/src/lintlist/mod.rs @@ -6,7 +6,7 @@ pub use lint::Lint; pub use lint::LINT_LEVELS; // begin lint list, do not remove this comment, it’s used in `update_lints` -pub const ALL_LINTS: [Lint; 333] = [ +pub const ALL_LINTS: [Lint; 332] = [ Lint { name: "absurd_extreme_comparisons", group: "correctness",