Auto merge of #13144 - xFrednet:07797-restriction-and-then-what, r=y21

Make restriction lint's use `span_lint_and_then` (i -> p)

This migrates a few restriction lints to use `span_lint_and_then`. This change is motivated by #7797.

I've also cleaned up some lint message. Mostly minor stuff. For example: suggestions with a longer message than `"try"` now use `SuggestionStyle::ShowAlways`

---

cc: #7797

brother PR of: #13136

changelog: none

clippy_lints/src/asm_syntax.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions};
 use rustc_ast::{InlineAsm, Item, ItemKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
@@ -49,14 +49,10 @@ fn check_asm_syntax(
  };
 
  if style == check_for {
- span_lint_and_help(
- cx,
- lint,
- span,
- format!("{style} x86 assembly syntax used"),
- None,
- format!("use {} x86 assembly syntax", !style),
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, lint, span, format!("{style} x86 assembly syntax used"), |diag| {
+ diag.help(format!("use {} x86 assembly syntax", !style));
+ });
  }
  }
 }
@@ -98,13 +94,13 @@ declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
 impl EarlyLintPass for InlineAsmX86IntelSyntax {
  fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
- check_asm_syntax(Self::get_lints()[0], cx, inline_asm, expr.span, AsmStyle::Intel);
+ check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, expr.span, AsmStyle::Intel);
  }
  }
 
  fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
  if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
- check_asm_syntax(Self::get_lints()[0], cx, inline_asm, item.span, AsmStyle::Intel);
+ check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, item.span, AsmStyle::Intel);
  }
  }
 }
@@ -146,13 +142,13 @@ declare_lint_pass!(InlineAsmX86AttSyntax => [INLINE_ASM_X86_ATT_SYNTAX]);
 impl EarlyLintPass for InlineAsmX86AttSyntax {
  fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
- check_asm_syntax(Self::get_lints()[0], cx, inline_asm, expr.span, AsmStyle::Att);
+ check_asm_syntax(INLINE_ASM_X86_ATT_SYNTAX, cx, inline_asm, expr.span, AsmStyle::Att);
  }
  }
 
  fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
  if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
- check_asm_syntax(Self::get_lints()[0], cx, inline_asm, item.span, AsmStyle::Att);
+ check_asm_syntax(INLINE_ASM_X86_ATT_SYNTAX, cx, inline_asm, item.span, AsmStyle::Att);
  }
  }
 }

clippy_lints/src/drop_forget_ref.rs

@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_must_use_func_call;
 use clippy_utils::ty::{is_copy, is_must_use_ty, is_type_lang_item};
 use rustc_hir::{Arm, Expr, ExprKind, LangItem, Node};
@@ -126,14 +126,14 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
  },
  _ => return,
  };
- span_lint_and_note(
- cx,
- lint,
- expr.span,
- msg,
- note_span,
- format!("argument has type `{arg_ty}`"),
- );
+ span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+ let note = format!("argument has type `{arg_ty}`");
+ if let Some(span) = note_span {
+  diag.span_note(span, note);
+ } else {
+  diag.note(note);
+ }
+ });
  }
  }
 }

clippy_lints/src/float_literal.rs

@@ -1,7 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::numeric_literal;
 use rustc_ast::ast::{self, LitFloatType, LitKind};
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, FloatTy};
@@ -105,32 +105,43 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
  if is_whole && !sym_str.contains(['e', 'E']) {
  // Normalize the literal by stripping the fractional portion
  if sym_str.split('.').next().unwrap() != float_str {
- // If the type suffix is missing the suggestion would be
- // incorrectly interpreted as an integer so adding a `.0`
- // suffix to prevent that.
- if type_suffix.is_none() {
- float_str.push_str(".0");
- }
-
- span_lint_and_sugg(
+ span_lint_and_then(
  cx,
  LOSSY_FLOAT_LITERAL,
  expr.span,
  "literal cannot be represented as the underlying type without loss of precision",
- "consider changing the type or replacing it with",
- numeric_literal::format(&float_str, type_suffix, true),
- Applicability::MachineApplicable,
+ |diag| {
+ // If the type suffix is missing the suggestion would be
+ // incorrectly interpreted as an integer so adding a `.0`
+ // suffix to prevent that.
+ if type_suffix.is_none() {
+ float_str.push_str(".0");
+ }
+ diag.span_suggestion_with_style(
+ expr.span,
+ "consider changing the type or replacing it with",
+ numeric_literal::format(&float_str, type_suffix, true),
+ Applicability::MachineApplicable,
+ SuggestionStyle::ShowAlways,
+ );
+ },
  );
  }
  } else if digits > max as usize && float_str.len() < sym_str.len() {
- span_lint_and_sugg(
+ span_lint_and_then(
  cx,
  EXCESSIVE_PRECISION,
  expr.span,
  "float has excessive precision",
- "consider changing the type or truncating it to",
- numeric_literal::format(&float_str, type_suffix, true),
- Applicability::MachineApplicable,
+ |diag| {
+ diag.span_suggestion_with_style(
+ expr.span,
+ "consider changing the type or truncating it to",
+ numeric_literal::format(&float_str, type_suffix, true),
+ Applicability::MachineApplicable,
+ SuggestionStyle::ShowAlways,
+ );
+ },
  );
  }
  }

clippy_lints/src/inherent_impl.rs

@@ -1,6 +1,6 @@
 //! lint on inherent implementations
 
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_lint_allowed;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
@@ -105,13 +105,14 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
  // `TyCtxt::crate_inherent_impls` doesn't have a defined order. Sort the lint output first.
  lint_spans.sort_by_key(|x| x.0.lo());
  for (span, first_span) in lint_spans {
- span_lint_and_note(
+ span_lint_and_then(
  cx,
  MULTIPLE_INHERENT_IMPL,
  span,
  "multiple implementations of this structure",
- Some(first_span),
- "first implementation here",
+ |diag| {
+ diag.span_note(first_span, "first implementation here");
+ },
  );
  }
  }

clippy_lints/src/large_include_file.rs

@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::root_macro_call_first_node;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -66,16 +66,18 @@ impl LateLintPass<'_> for LargeIncludeFile {
  && (cx.tcx.is_diagnostic_item(sym::include_bytes_macro, macro_call.def_id)
  || cx.tcx.is_diagnostic_item(sym::include_str_macro, macro_call.def_id))
  {
- span_lint_and_note(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
  cx,
  LARGE_INCLUDE_FILE,
  expr.span.source_callsite(),
  "attempted to include a large file",
- None,
- format!(
- "the configuration allows a maximum size of {} bytes",
- self.max_file_size
- ),
+ |diag| {
+ diag.note(format!(
+ "the configuration allows a maximum size of {} bytes",
+ self.max_file_size
+ ));
+ },
  );
  }
  }

clippy_lints/src/let_underscore.rs

@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::{implements_trait, is_must_use_ty, match_type};
 use clippy_utils::{is_from_proc_macro, is_must_use_func_call, paths};
 use rustc_hir::{LetStmt, LocalSource, PatKind};
@@ -149,43 +149,53 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
  GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
  });
  if contains_sync_guard {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
  cx,
  LET_UNDERSCORE_LOCK,
  local.span,
  "non-binding `let` on a synchronization lock",
- None,
- "consider using an underscore-prefixed named \
- binding or dropping explicitly with `std::mem::drop`",
+ |diag| {
+ diag.help(
+ "consider using an underscore-prefixed named \
+ binding or dropping explicitly with `std::mem::drop`",
+ );
+ },
  );
  } else if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait()
  && implements_trait(cx, cx.typeck_results().expr_ty(init), future_trait_def_id, &[])
  {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
  cx,
  LET_UNDERSCORE_FUTURE,
  local.span,
  "non-binding `let` on a future",
- None,
- "consider awaiting the future or dropping explicitly with `std::mem::drop`",
+ |diag| {
+ diag.help("consider awaiting the future or dropping explicitly with `std::mem::drop`");
+ },
  );
  } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
  cx,
  LET_UNDERSCORE_MUST_USE,
  local.span,
  "non-binding `let` on an expression with `#[must_use]` type",
- None,
- "consider explicitly using expression value",
+ |diag| {
+ diag.help("consider explicitly using expression value");
+ },
  );
  } else if is_must_use_func_call(cx, init) {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
  cx,
  LET_UNDERSCORE_MUST_USE,
  local.span,
  "non-binding `let` on a result of a `#[must_use]` function",
- None,
- "consider explicitly using function result",
+ |diag| {
+ diag.help("consider explicitly using function result");
+ },
  );
  }
 
@@ -204,18 +214,22 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
  return;
  }
 
- span_lint_and_help(
+ span_lint_and_then(
  cx,
  LET_UNDERSCORE_UNTYPED,
  local.span,
  "non-binding `let` without a type annotation",
- Some(Span::new(
- local.pat.span.hi(),
- local.pat.span.hi() + BytePos(1),
- local.pat.span.ctxt(),
- local.pat.span.parent(),
- )),
- "consider adding a type annotation",
+ |diag| {
+ diag.span_help(
+ Span::new(
+ local.pat.span.hi(),
+ local.pat.span.hi() + BytePos(1),
+ local.pat.span.ctxt(),
+ local.pat.span.parent(),
+ ),
+ "consider adding a type annotation",
+ );
+ },
  );
  }
  }

clippy_lints/src/methods/map_err_ignore.rs

@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::{CaptureBy, Closure, Expr, ExprKind, PatKind};
 use rustc_lint::LateContext;
@@ -22,13 +22,17 @@ pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, arg: &Expr<'_>) {
  {
  // span the area of the closure capture and warn that the
  // original error will be thrown away
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
  cx,
  MAP_ERR_IGNORE,
  fn_decl_span,
  "`map_err(|_|...` wildcard pattern discards the original error",
- None,
- "consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
+ |diag| {
+ diag.help(
+ "consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
+ );
+ },
  );
  }
 }

clippy_lints/src/missing_assert_message.rs

@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_in_test;
 use clippy_utils::macros::{find_assert_args, find_assert_eq_args, root_macro_call_first_node, PanicExpn};
 use rustc_hir::Expr;
@@ -79,13 +79,15 @@ impl<'tcx> LateLintPass<'tcx> for MissingAssertMessage {
  };
 
  if let PanicExpn::Empty = panic_expn {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
  cx,
  MISSING_ASSERT_MESSAGE,
  macro_call.span,
  "assert without any message",
- None,
- "consider describing why the failing assert is problematic",
+ |diag| {
+ diag.help("consider describing why the failing assert is problematic");
+ },
  );
  }
  }

clippy_lints/src/missing_trait_methods.rs

@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_lint_allowed;
 use clippy_utils::macros::span_is_local;
 use rustc_hir::def_id::DefIdMap;
@@ -83,15 +83,15 @@ impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
  cx.tcx.with_stable_hashing_context(|hcx| {
  for assoc in provided.values_sorted(&hcx, true) {
  let source_map = cx.tcx.sess.source_map();
- let definition_span = source_map.guess_head_span(cx.tcx.def_span(assoc.def_id));
-
- span_lint_and_help(
+ span_lint_and_then(
  cx,
  MISSING_TRAIT_METHODS,
  source_map.guess_head_span(item.span),
  format!("missing trait method provided by default: `{}`", assoc.name),
- Some(definition_span),
- "implement the method",
+ |diag| {
+ let definition_span = source_map.guess_head_span(cx.tcx.def_span(assoc.def_id));
+ diag.span_help(definition_span, "implement the method");
+ },
  );
  }
  });