Use expect for lint warnings

clippy_config/src/conf.rs

@@ -248,7 +248,7 @@ macro_rules! define_Conf {
 
         #[derive(Deserialize)]
         #[serde(field_identifier, rename_all = "kebab-case")]
-        #[allow(non_camel_case_types)]
+        #[expect(non_camel_case_types)]
         enum Field { $($name,)* third_party, }
 
         struct ConfVisitor<'a>(&'a SourceFile);
@@ -1213,7 +1213,7 @@ mod tests {
 
         for entry in toml_files {
             let file = fs::read_to_string(entry.path()).unwrap();
-            #[allow(clippy::zero_sized_map_values)]
+            #[expect(clippy::zero_sized_map_values)]
             if let Ok(map) = toml::from_str::<HashMap<String, IgnoredAny>>(&file) {
                 for name in map.keys() {
                     names.remove(name.as_str());

clippy_config/src/types.rs

@@ -131,7 +131,7 @@ impl DisallowedPathEnum {
 }
 
 /// Creates a map of disallowed items to the reason they were disallowed.
-#[allow(clippy::type_complexity)]
+#[expect(clippy::type_complexity)]
 pub fn create_disallowed_map<const REPLACEMENT_ALLOWED: bool>(
     tcx: TyCtxt<'_>,
     disallowed_paths: &'static [DisallowedPath<REPLACEMENT_ALLOWED>],

clippy_dev/src/dogfood.rs

@@ -4,7 +4,7 @@ use itertools::Itertools;
 /// # Panics
 ///
 /// Panics if unable to run the dogfood test
-#[allow(clippy::fn_params_excessive_bools)]
+#[expect(clippy::fn_params_excessive_bools)]
 pub fn dogfood(fix: bool, allow_dirty: bool, allow_staged: bool, allow_no_vcs: bool) {
     run_exit_on_err(
         "cargo test",

clippy_dev/src/main.rs

@@ -192,7 +192,7 @@ enum DevCommand {
         /// Which lint's page to load initially (optional)
         lint: Option<String>,
     },
-    #[allow(clippy::doc_markdown)]
+    #[expect(clippy::doc_markdown)]
     /// Manually run clippy on a file or package
     ///
     /// ## Examples

clippy_dev/src/new_lint.rs

@@ -443,7 +443,6 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
     Ok(())
 }
 
-#[allow(clippy::too_many_lines)]
 fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str> {
     let lint_name_upper = lint.name.to_uppercase();
 

clippy_lints/src/arbitrary_source_item_ordering.rs

@@ -167,7 +167,7 @@ declare_clippy_lint! {
 impl_lint_pass!(ArbitrarySourceItemOrdering => [ARBITRARY_SOURCE_ITEM_ORDERING]);
 
 #[derive(Debug)]
-#[allow(clippy::struct_excessive_bools)] // Bools are cached feature flags.
+#[expect(clippy::struct_excessive_bools, reason = "Bools are cached feature flags")]
 pub struct ArbitrarySourceItemOrdering {
     assoc_types_order: SourceItemOrderingTraitAssocItemKinds,
     enable_ordering_for_enum: bool,

clippy_lints/src/deprecated_lints.rs

@@ -7,7 +7,6 @@ macro_rules! declare_with_version {
         $e:expr,
     )*]) => {
         pub static $name: &[(&str, &str)] = &[$($e),*];
-        #[allow(unused)]
         pub static $name_version: &[&str] = &[$($version),*];
     };
 }

clippy_lints/src/doc/mod.rs

@@ -968,7 +968,7 @@ fn check_for_code_clusters<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a
 /// This walks the "events" (think sections of markdown) produced by `pulldown_cmark`,
 /// so lints here will generally access that information.
 /// Returns documentation headers -- whether a "Safety", "Errors", "Panic" section was found
-#[allow(clippy::too_many_lines)] // Only a big match statement
+#[expect(clippy::too_many_lines, reason = "big match statement")]
 fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize>)>>(
     cx: &LateContext<'_>,
     valid_idents: &FxHashSet<String>,

clippy_lints/src/eta_reduction.rs

@@ -86,7 +86,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
     }
 }
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx>>, expr: &Expr<'tcx>) {
     let body = if let ExprKind::Closure(c) = expr.kind
         && c.fn_decl.inputs.iter().all(|ty| matches!(ty.kind, TyKind::Infer(())))

clippy_lints/src/format.rs

@@ -39,7 +39,6 @@ declare_clippy_lint! {
     "useless use of `format!`"
 }
 
-#[allow(clippy::module_name_repetitions)]
 pub struct UselessFormat {
     format_args: FormatArgsStorage,
 }

clippy_lints/src/format_args.rs

@@ -237,7 +237,7 @@ impl_lint_pass!(FormatArgs<'_> => [
     POINTER_FORMAT,
 ]);
 
-#[allow(clippy::struct_field_names)]
+#[expect(clippy::struct_field_names)]
 pub struct FormatArgs<'tcx> {
     format_args: FormatArgsStorage,
     msrv: Msrv,

clippy_lints/src/functions/must_use.rs

@@ -132,7 +132,7 @@ pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Tr
 }
 
 // FIXME: needs to be an EARLY LINT. all attribute lints should be
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn check_needless_must_use(
     cx: &LateContext<'_>,
     decl: &hir::FnDecl<'_>,

clippy_lints/src/functions/ref_option.rs

@@ -62,7 +62,7 @@ fn check_fn_sig<'a>(cx: &LateContext<'a>, decl: &FnDecl<'a>, span: Span, sig: ty
     }
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 pub(crate) fn check_fn<'a>(
     cx: &LateContext<'a>,
     kind: FnKind<'a>,

clippy_lints/src/implicit_saturating_sub.rs

@@ -112,7 +112,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
     }
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn check_manual_check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &Expr<'tcx>,
@@ -165,7 +165,7 @@ fn check_manual_check<'tcx>(
     }
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn check_gt(
     cx: &LateContext<'_>,
     condition_span: Span,
@@ -196,7 +196,7 @@ fn is_side_effect_free(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     eq_expr_value(cx, expr, expr)
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn check_subtraction(
     cx: &LateContext<'_>,
     condition_span: Span,

clippy_lints/src/lifetimes.rs

@@ -184,7 +184,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
     }
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn check_fn_inner<'tcx>(
     cx: &LateContext<'tcx>,
     sig: &'tcx FnSig<'_>,
@@ -540,7 +540,7 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, generics: &'tcx Generics<'_
     false
 }
 
-#[allow(clippy::struct_excessive_bools)]
+#[expect(clippy::struct_excessive_bools)]
 struct Usage {
     lifetime: Lifetime,
     in_where_predicate: bool,

clippy_lints/src/loops/mod.rs

@@ -881,7 +881,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
 }
 
 impl Loops {
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn check_for_loop<'tcx>(
         &self,
         cx: &LateContext<'tcx>,

clippy_lints/src/loops/never_loop.rs

@@ -240,7 +240,7 @@ fn is_label_for_block(cx: &LateContext<'_>, dest: &Destination) -> bool {
         .is_ok_and(|hir_id| matches!(cx.tcx.hir_node(hir_id), Node::Block(_)))
 }
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 fn never_loop_expr<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &Expr<'tcx>,

clippy_lints/src/matches/collapsible_match.rs

@@ -35,7 +35,7 @@ pub(super) fn check_if_let<'tcx>(
     check_arm(cx, false, pat, let_expr, body, None, else_expr, msrv);
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn check_arm<'tcx>(
     cx: &LateContext<'tcx>,
     outer_is_match: bool,

clippy_lints/src/methods/clone_on_copy.rs

@@ -12,7 +12,6 @@ use rustc_span::symbol::{Symbol, sym};
 use super::CLONE_ON_COPY;
 
 /// Checks for the `CLONE_ON_COPY` lint.
-#[allow(clippy::too_many_lines)]
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &Expr<'_>,

clippy_lints/src/methods/filter_map.rs

@@ -280,7 +280,7 @@ fn is_filter_ok_map_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>, filter_arg: &E
 }
 
 /// lint use of `filter().map()` or `find().map()` for `Iterators`
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &Expr<'_>,

clippy_lints/src/methods/map_all_any_identity.rs

@@ -8,7 +8,7 @@ use rustc_span::{Span, sym};
 
 use super::MAP_ALL_ANY_IDENTITY;
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &Expr<'_>,

clippy_lints/src/methods/mod.rs

@@ -4886,7 +4886,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         }
     }
 
-    #[allow(clippy::too_many_lines)]
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
         if impl_item.span.in_external_macro(cx.sess().source_map()) {
             return;
@@ -4958,7 +4957,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 }
 
 impl Methods {
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Handle method calls whose receiver and arguments may not come from expansion
         if let Some((name, recv, args, span, call_span)) = method_call(expr) {

clippy_lints/src/methods/search_is_some.rs

@@ -14,7 +14,7 @@ use super::SEARCH_IS_SOME;
 
 /// lint searching an Iterator followed by `is_some()`
 /// or calling `find()` on a string followed by `is_some()` or `is_none()`
-#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
+#[expect(clippy::too_many_arguments, clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'_>,
     expr: &'tcx hir::Expr<'_>,

clippy_lints/src/methods/str_splitn.rs

@@ -271,7 +271,6 @@ struct IterUsage {
     span: Span,
 }
 
-#[allow(clippy::too_many_lines)]
 fn parse_iter_usage<'tcx>(
     cx: &LateContext<'tcx>,
     ctxt: SyntaxContext,

clippy_lints/src/methods/unnecessary_to_owned.rs

@@ -66,7 +66,7 @@ pub fn check<'tcx>(
 
 /// Checks whether `expr` is a referent in an `AddrOf` expression and, if so, determines whether its
 /// call of a `to_owned`-like function is unnecessary.
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 fn check_addr_of_expr(
     cx: &LateContext<'_>,
     expr: &Expr<'_>,

clippy_lints/src/methods/wrong_self_convention.rs

@@ -81,7 +81,6 @@ impl fmt::Display for Convention {
     }
 }
 
-#[allow(clippy::too_many_arguments)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     item_name: Symbol,

clippy_lints/src/needless_maybe_sized.rs

@@ -33,7 +33,7 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(NeedlessMaybeSized => [NEEDLESS_MAYBE_SIZED]);
 
-#[allow(clippy::struct_field_names)]
+#[expect(clippy::struct_field_names)]
 struct Bound<'tcx> {
     /// The [`DefId`] of the type parameter the bound refers to
     param: DefId,

clippy_lints/src/needless_pass_by_ref_mut.rs

@@ -364,7 +364,6 @@ impl MutablyUsedVariablesCtxt<'_> {
 }
 
 impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
-    #[allow(clippy::if_same_then_else)]
     fn consume(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, id: HirId) {
         if let euv::Place {
             base:
@@ -398,7 +397,6 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
 
     fn use_cloned(&mut self, _: &euv::PlaceWithHirId<'tcx>, _: HirId) {}
 
-    #[allow(clippy::if_same_then_else)]
     fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, id: HirId, borrow: ty::BorrowKind) {
         self.prev_bind = None;
         if let euv::Place {

clippy_lints/src/only_used_in_recursion.rs

@@ -212,7 +212,7 @@ impl Usage {
 /// The parameters being checked by the lint, indexed by both the parameter's `HirId` and the
 /// `DefId` of the function paired with the parameter's index.
 #[derive(Default)]
-#[allow(clippy::struct_field_names)]
+#[expect(clippy::struct_field_names)]
 struct Params {
     params: Vec<Param>,
     by_id: HirIdMap<usize>,

clippy_lints/src/operators/bit_mask.rs

@@ -47,7 +47,6 @@ fn check_compare<'a>(cx: &LateContext<'a>, bit_op: &Expr<'a>, cmp_op: BinOpKind,
     }
 }
 
-#[allow(clippy::too_many_lines)]
 fn check_bit_mask(
     cx: &LateContext<'_>,
     bit_op: BinOpKind,

clippy_lints/src/swap.rs

@@ -85,7 +85,7 @@ impl<'tcx> LateLintPass<'tcx> for Swap {
     }
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn generate_swap_warning<'tcx>(
     block: &'tcx Block<'tcx>,
     cx: &LateContext<'tcx>,

clippy_lints/src/trait_bounds.rs

@@ -238,7 +238,7 @@ impl TraitBounds {
         }
     }
 
-    #[allow(clippy::mutable_key_type)]
+    #[expect(clippy::mutable_key_type)]
     fn check_type_repetition<'tcx>(&self, cx: &LateContext<'tcx>, generics: &'tcx Generics<'_>) {
         struct SpanlessTy<'cx, 'tcx> {
             ty: &'tcx Ty<'tcx>,

clippy_lints/src/types/mod.rs

@@ -693,7 +693,7 @@ impl Types {
     }
 }
 
-#[allow(clippy::struct_excessive_bools, clippy::struct_field_names)]
+#[expect(clippy::struct_excessive_bools)]
 #[derive(Clone, Copy, Default)]
 struct CheckTyContext {
     is_in_trait_impl: bool,

clippy_lints/src/undocumented_unsafe_blocks.rs

@@ -489,7 +489,6 @@ enum HasSafetyComment {
 }
 
 /// Checks if the lines immediately preceding the item contain a safety comment.
-#[allow(clippy::collapsible_match)]
 fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSafetyComment {
     match span_from_macro_expansion_has_safety_comment(cx, item.span) {
         HasSafetyComment::Maybe => (),
@@ -551,7 +550,6 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSaf
 }
 
 /// Checks if the lines immediately preceding the item contain a safety comment.
-#[allow(clippy::collapsible_match)]
 fn stmt_has_safety_comment(
     cx: &LateContext<'_>,
     span: Span,

clippy_lints/src/utils/author.rs

@@ -205,7 +205,6 @@ struct PrintVisitor<'a, 'tcx> {
     first: Cell<bool>,
 }
 
-#[allow(clippy::unused_self)]
 impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     fn new(cx: &'a LateContext<'tcx>) -> Self {
         Self {
@@ -410,7 +409,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         self.expr(field!(arm.body));
     }
 
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn expr(&self, expr: &Binding<&hir::Expr<'_>>) {
         if let Some(higher::While { condition, body, .. }) = higher::While::hir(expr.value) {
             bind!(self, condition, body);

clippy_utils/src/ast_utils/mod.rs

@@ -143,7 +143,7 @@ pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
     }
 }
 
-#[allow(clippy::too_many_lines)] // Just a big match statement
+#[expect(clippy::too_many_lines, reason = "big match statement")]
 pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
     use ExprKind::*;
     if !over(&l.attrs, &r.attrs, eq_attr) {
@@ -328,7 +328,7 @@ pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> b
     over(&l.attrs, &r.attrs, eq_attr) && eq_vis(&l.vis, &r.vis) && eq_kind(&l.kind, &r.kind)
 }
 
-#[expect(clippy::too_many_lines)] // Just a big match statement
+#[expect(clippy::too_many_lines, reason = "big match statement")]
 pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
     use ItemKind::*;
     match (l, r) {