diff --git a/Cargo.lock b/Cargo.lock
index fb762cd2fe629..4bd99b7fbe7ac 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -564,7 +564,7 @@ dependencies = [
"termize",
"tokio",
"toml 0.7.8",
- "ui_test 0.24.0",
+ "ui_test 0.25.0",
"walkdir",
]
@@ -572,6 +572,7 @@ dependencies = [
name = "clippy_config"
version = "0.1.82"
dependencies = [
+ "itertools",
"rustc-semver",
"serde",
"toml 0.7.8",
@@ -4936,9 +4937,9 @@ dependencies = [
[[package]]
name = "spanned"
-version = "0.2.1"
+version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed14ba8b4b82241bd5daba2c49185d4a0581a0058355fe96537338f002b8605d"
+checksum = "86af297923fbcfd107c20a189a6e9c872160df71a7190ae4a7a6c5dce4b2feb6"
dependencies = [
"bstr",
"color-eyre",
@@ -5562,9 +5563,9 @@ dependencies = [
[[package]]
name = "ui_test"
-version = "0.24.0"
+version = "0.25.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc1c6c78d55482388711c8d417b8e547263046a607512278fed274c54633bbe4"
+checksum = "f7e4f339f62edc873975c47115f9e71c5454ddaa37c1142b42fc0b2672c8dacb"
dependencies = [
"annotate-snippets 0.11.4",
"anyhow",
diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
index b83d9e63d3e49..b8813ea4125fe 100644
--- a/compiler/rustc_errors/src/emitter.rs
+++ b/compiler/rustc_errors/src/emitter.rs
@@ -43,19 +43,14 @@ const DEFAULT_COLUMN_WIDTH: usize = 140;
/// Describes the way the content of the `rendered` field of the json output is generated
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum HumanReadableErrorType {
- Default(ColorConfig),
- AnnotateSnippet(ColorConfig),
- Short(ColorConfig),
+ Default,
+ AnnotateSnippet,
+ Short,
}
impl HumanReadableErrorType {
- /// Returns a (`short`, `color`) tuple
- pub fn unzip(self) -> (bool, ColorConfig) {
- match self {
- HumanReadableErrorType::Default(cc) => (false, cc),
- HumanReadableErrorType::Short(cc) => (true, cc),
- HumanReadableErrorType::AnnotateSnippet(cc) => (false, cc),
- }
+ pub fn short(&self) -> bool {
+ *self == HumanReadableErrorType::Short
}
}
diff --git a/compiler/rustc_errors/src/json.rs b/compiler/rustc_errors/src/json.rs
index 42a28bc789013..32e59f9ab036a 100644
--- a/compiler/rustc_errors/src/json.rs
+++ b/compiler/rustc_errors/src/json.rs
@@ -55,6 +55,7 @@ pub struct JsonEmitter {
ignored_directories_in_source_blocks: Vec<String>,
#[setters(skip)]
json_rendered: HumanReadableErrorType,
+ color_config: ColorConfig,
diagnostic_width: Option<usize>,
macro_backtrace: bool,
track_diagnostics: bool,
@@ -68,6 +69,7 @@ impl JsonEmitter {
fallback_bundle: LazyFallbackBundle,
pretty: bool,
json_rendered: HumanReadableErrorType,
+ color_config: ColorConfig,
) -> JsonEmitter {
JsonEmitter {
dst: IntoDynSyncSend(dst),
@@ -79,6 +81,7 @@ impl JsonEmitter {
ui_testing: false,
ignored_directories_in_source_blocks: Vec::new(),
json_rendered,
+ color_config,
diagnostic_width: None,
macro_backtrace: false,
track_diagnostics: false,
@@ -173,7 +176,7 @@ impl Emitter for JsonEmitter {
}
fn should_show_explain(&self) -> bool {
- !matches!(self.json_rendered, HumanReadableErrorType::Short(_))
+ !self.json_rendered.short()
}
}
@@ -353,8 +356,8 @@ impl Diagnostic {
let buf = BufWriter::default();
let mut dst: Destination = Box::new(buf.clone());
- let (short, color_config) = je.json_rendered.unzip();
- match color_config {
+ let short = je.json_rendered.short();
+ match je.color_config {
ColorConfig::Always | ColorConfig::Auto => dst = Box::new(termcolor::Ansi::new(dst)),
ColorConfig::Never => {}
}
diff --git a/compiler/rustc_errors/src/json/tests.rs b/compiler/rustc_errors/src/json/tests.rs
index e3549fc3aa537..6af376d7afdb2 100644
--- a/compiler/rustc_errors/src/json/tests.rs
+++ b/compiler/rustc_errors/src/json/tests.rs
@@ -50,7 +50,8 @@ fn test_positions(code: &str, span: (u32, u32), expected_output: SpanTestData) {
sm,
fallback_bundle,
true, // pretty
- HumanReadableErrorType::Short(ColorConfig::Never),
+ HumanReadableErrorType::Short,
+ ColorConfig::Never,
);
let span = Span::with_root_ctxt(BytePos(span.0), BytePos(span.1));
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 023352156eb45..96a6f52d60b6c 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -818,8 +818,14 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
});
sess.time("layout_testing", || layout_test::test_layout(tcx));
sess.time("abi_testing", || abi_test::test_abi(tcx));
+
+ // If `-Zvalidate-mir` is set, we also want to compute the final MIR for each item
+ // (either its `mir_for_ctfe` or `optimized_mir`) since that helps uncover any bugs
+ // in MIR optimizations that may only be reachable through codegen, or other codepaths
+ // that requires the optimized/ctfe MIR, such as polymorphization, coroutine bodies,
+ // or evaluating consts.
if tcx.sess.opts.unstable_opts.validate_mir {
- sess.time("ensuring_optimized_MIR_is_computable", || {
+ sess.time("ensuring_final_MIR_is_computable", || {
tcx.hir().par_body_owners(|def_id| {
tcx.instance_mir(ty::InstanceKind::Item(def_id.into()));
});
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index ce3b2f77f210a..34f2dca7c42ff 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -315,7 +315,8 @@ fn test_search_paths_tracking_hash_different_order() {
let early_dcx = EarlyDiagCtxt::new(JSON);
const JSON: ErrorOutputType = ErrorOutputType::Json {
pretty: false,
- json_rendered: HumanReadableErrorType::Default(ColorConfig::Never),
+ json_rendered: HumanReadableErrorType::Default,
+ color_config: ColorConfig::Never,
};
let push = |opts: &mut Options, search_path| {
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index e69d8d84d7d89..00837f7cdd87d 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -458,28 +458,23 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I:
))
}
- ty::FnDef(..) | ty::FnPtr(..) => {
- let bound_sig = self_ty.fn_sig(cx);
- let sig = bound_sig.skip_binder();
- let future_trait_def_id = cx.require_lang_item(TraitSolverLangItem::Future);
- // `FnDef` and `FnPtr` only implement `AsyncFn*` when their
- // return type implements `Future`.
- let nested = vec![
- bound_sig
- .rebind(ty::TraitRef::new(cx, future_trait_def_id, [sig.output()]))
- .upcast(cx),
- ];
- let future_output_def_id = cx.require_lang_item(TraitSolverLangItem::FutureOutput);
- let future_output_ty = Ty::new_projection(cx, future_output_def_id, [sig.output()]);
- Ok((
- bound_sig.rebind(AsyncCallableRelevantTypes {
- tupled_inputs_ty: Ty::new_tup(cx, sig.inputs().as_slice()),
- output_coroutine_ty: sig.output(),
- coroutine_return_ty: future_output_ty,
- }),
- nested,
- ))
+ ty::FnDef(def_id, _) => {
+ let sig = self_ty.fn_sig(cx);
+ if sig.skip_binder().is_fn_trait_compatible() && !cx.has_target_features(def_id) {
+ fn_item_to_async_callable(cx, sig)
+ } else {
+ Err(NoSolution)
+ }
+ }
+ ty::FnPtr(..) => {
+ let sig = self_ty.fn_sig(cx);
+ if sig.skip_binder().is_fn_trait_compatible() {
+ fn_item_to_async_callable(cx, sig)
+ } else {
+ Err(NoSolution)
+ }
}
+
ty::Closure(_, args) => {
let args = args.as_closure();
let bound_sig = args.sig();
@@ -563,6 +558,29 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I:
}
}
+fn fn_item_to_async_callable<I: Interner>(
+ cx: I,
+ bound_sig: ty::Binder<I, ty::FnSig<I>>,
+) -> Result<(ty::Binder<I, AsyncCallableRelevantTypes<I>>, Vec<I::Predicate>), NoSolution> {
+ let sig = bound_sig.skip_binder();
+ let future_trait_def_id = cx.require_lang_item(TraitSolverLangItem::Future);
+ // `FnDef` and `FnPtr` only implement `AsyncFn*` when their
+ // return type implements `Future`.
+ let nested = vec![
+ bound_sig.rebind(ty::TraitRef::new(cx, future_trait_def_id, [sig.output()])).upcast(cx),
+ ];
+ let future_output_def_id = cx.require_lang_item(TraitSolverLangItem::FutureOutput);
+ let future_output_ty = Ty::new_projection(cx, future_output_def_id, [sig.output()]);
+ Ok((
+ bound_sig.rebind(AsyncCallableRelevantTypes {
+ tupled_inputs_ty: Ty::new_tup(cx, sig.inputs().as_slice()),
+ output_coroutine_ty: sig.output(),
+ coroutine_return_ty: future_output_ty,
+ }),
+ nested,
+ ))
+}
+
/// Given a coroutine-closure, project to its returned coroutine when we are *certain*
/// that the closure's kind is compatible with the goal.
fn coroutine_closure_to_certain_coroutine<I: Interner>(
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 20c14a985024c..95d171409d86d 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -602,7 +602,7 @@ impl OutputType {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ErrorOutputType {
/// Output meant for the consumption of humans.
- HumanReadable(HumanReadableErrorType),
+ HumanReadable(HumanReadableErrorType, ColorConfig),
/// Output that's consumed by other tools such as `rustfix` or the `RLS`.
Json {
/// Render the JSON in a human readable way (with indents and newlines).
@@ -610,12 +610,13 @@ pub enum ErrorOutputType {
/// The JSON output includes a `rendered` field that includes the rendered
/// human output.
json_rendered: HumanReadableErrorType,
+ color_config: ColorConfig,
},
}
impl Default for ErrorOutputType {
fn default() -> Self {
- Self::HumanReadable(HumanReadableErrorType::Default(ColorConfig::Auto))
+ Self::HumanReadable(HumanReadableErrorType::Default, ColorConfig::Auto)
}
}
@@ -1631,6 +1632,7 @@ pub fn parse_color(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches) -> Col
/// Possible json config files
pub struct JsonConfig {
pub json_rendered: HumanReadableErrorType,
+ pub json_color: ColorConfig,
json_artifact_notifications: bool,
pub json_unused_externs: JsonUnusedExterns,
json_future_incompat: bool,
@@ -1668,8 +1670,7 @@ impl JsonUnusedExterns {
/// The first value returned is how to render JSON diagnostics, and the second
/// is whether or not artifact notifications are enabled.
pub fn parse_json(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches) -> JsonConfig {
- let mut json_rendered: fn(ColorConfig) -> HumanReadableErrorType =
- HumanReadableErrorType::Default;
+ let mut json_rendered = HumanReadableErrorType::Default;
let mut json_color = ColorConfig::Never;
let mut json_artifact_notifications = false;
let mut json_unused_externs = JsonUnusedExterns::No;
@@ -1696,7 +1697,8 @@ pub fn parse_json(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches) -> Json
}
JsonConfig {
- json_rendered: json_rendered(json_color),
+ json_rendered,
+ json_color,
json_artifact_notifications,
json_unused_externs,
json_future_incompat,
@@ -1708,6 +1710,7 @@ pub fn parse_error_format(
early_dcx: &mut EarlyDiagCtxt,
matches: &getopts::Matches,
color: ColorConfig,
+ json_color: ColorConfig,
json_rendered: HumanReadableErrorType,
) -> ErrorOutputType {
// We need the `opts_present` check because the driver will send us Matches
@@ -1717,18 +1720,22 @@ pub fn parse_error_format(
let error_format = if matches.opts_present(&["error-format".to_owned()]) {
match matches.opt_str("error-format").as_deref() {
None | Some("human") => {
- ErrorOutputType::HumanReadable(HumanReadableErrorType::Default(color))
+ ErrorOutputType::HumanReadable(HumanReadableErrorType::Default, color)
}
Some("human-annotate-rs") => {
- ErrorOutputType::HumanReadable(HumanReadableErrorType::AnnotateSnippet(color))
+ ErrorOutputType::HumanReadable(HumanReadableErrorType::AnnotateSnippet, color)
}
- Some("json") => ErrorOutputType::Json { pretty: false, json_rendered },
- Some("pretty-json") => ErrorOutputType::Json { pretty: true, json_rendered },
- Some("short") => ErrorOutputType::HumanReadable(HumanReadableErrorType::Short(color)),
-
+ Some("json") => {
+ ErrorOutputType::Json { pretty: false, json_rendered, color_config: json_color }
+ }
+ Some("pretty-json") => {
+ ErrorOutputType::Json { pretty: true, json_rendered, color_config: json_color }
+ }
+ Some("short") => ErrorOutputType::HumanReadable(HumanReadableErrorType::Short, color),
Some(arg) => {
early_dcx.abort_if_error_and_set_error_format(ErrorOutputType::HumanReadable(
- HumanReadableErrorType::Default(color),
+ HumanReadableErrorType::Default,
+ color,
));
early_dcx.early_fatal(format!(
"argument for `--error-format` must be `human`, `json` or \
@@ -1737,7 +1744,7 @@ pub fn parse_error_format(
}
}
} else {
- ErrorOutputType::HumanReadable(HumanReadableErrorType::Default(color))
+ ErrorOutputType::HumanReadable(HumanReadableErrorType::Default, color)
};
match error_format {
@@ -1791,7 +1798,7 @@ fn check_error_format_stability(
if let ErrorOutputType::Json { pretty: true, .. } = error_format {
early_dcx.early_fatal("`--error-format=pretty-json` is unstable");
}
- if let ErrorOutputType::HumanReadable(HumanReadableErrorType::AnnotateSnippet(_)) =
+ if let ErrorOutputType::HumanReadable(HumanReadableErrorType::AnnotateSnippet, _) =
error_format
{
early_dcx.early_fatal("`--error-format=human-annotate-rs` is unstable");
@@ -2392,12 +2399,13 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
let JsonConfig {
json_rendered,
+ json_color,
json_artifact_notifications,
json_unused_externs,
json_future_incompat,
} = parse_json(early_dcx, matches);
- let error_format = parse_error_format(early_dcx, matches, color, json_rendered);
+ let error_format = parse_error_format(early_dcx, matches, color, json_color, json_rendered);
early_dcx.abort_if_error_and_set_error_format(error_format);
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index be67baf57f6dc..672dddf871e02 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -950,10 +950,10 @@ fn default_emitter(
t => t,
};
match sopts.error_format {
- config::ErrorOutputType::HumanReadable(kind) => {
- let (short, color_config) = kind.unzip();
+ config::ErrorOutputType::HumanReadable(kind, color_config) => {
+ let short = kind.short();
- if let HumanReadableErrorType::AnnotateSnippet(_) = kind {
+ if let HumanReadableErrorType::AnnotateSnippet = kind {
let emitter = AnnotateSnippetEmitter::new(
Some(source_map),
bundle,
@@ -978,13 +978,14 @@ fn default_emitter(
Box::new(emitter.ui_testing(sopts.unstable_opts.ui_testing))
}
}
- config::ErrorOutputType::Json { pretty, json_rendered } => Box::new(
+ config::ErrorOutputType::Json { pretty, json_rendered, color_config } => Box::new(
JsonEmitter::new(
Box::new(io::BufWriter::new(io::stderr())),
source_map,
fallback_bundle,
pretty,
json_rendered,
+ color_config,
)
.registry(Some(registry))
.fluent_bundle(bundle)
@@ -1425,20 +1426,23 @@ fn mk_emitter(output: ErrorOutputType) -> Box<DynEmitter> {
let fallback_bundle =
fallback_fluent_bundle(vec![rustc_errors::DEFAULT_LOCALE_RESOURCE], false);
let emitter: Box<DynEmitter> = match output {
- config::ErrorOutputType::HumanReadable(kind) => {
- let (short, color_config) = kind.unzip();
+ config::ErrorOutputType::HumanReadable(kind, color_config) => {
+ let short = kind.short();
Box::new(
HumanEmitter::new(stderr_destination(color_config), fallback_bundle)
.short_message(short),
)
}
- config::ErrorOutputType::Json { pretty, json_rendered } => Box::new(JsonEmitter::new(
- Box::new(io::BufWriter::new(io::stderr())),
- Lrc::new(SourceMap::new(FilePathMapping::empty())),
- fallback_bundle,
- pretty,
- json_rendered,
- )),
+ config::ErrorOutputType::Json { pretty, json_rendered, color_config } => {
+ Box::new(JsonEmitter::new(
+ Box::new(io::BufWriter::new(io::stderr())),
+ Lrc::new(SourceMap::new(FilePathMapping::empty())),
+ fallback_bundle,
+ pretty,
+ json_rendered,
+ color_config,
+ ))
+ }
};
emitter
}
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index 2085d3da44341..9de62031311b7 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -467,8 +467,20 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
}
candidates.vec.push(AsyncClosureCandidate);
}
- ty::FnDef(..) | ty::FnPtr(..) => {
- candidates.vec.push(AsyncClosureCandidate);
+ // Provide an impl, but only for suitable `fn` pointers.
+ ty::FnPtr(sig) => {
+ if sig.is_fn_trait_compatible() {
+ candidates.vec.push(AsyncClosureCandidate);
+ }
+ }
+ // Provide an impl for suitable functions, rejecting `#[target_feature]` functions (RFC 2396).
+ ty::FnDef(def_id, _) => {
+ let tcx = self.tcx();
+ if tcx.fn_sig(def_id).skip_binder().is_fn_trait_compatible()
+ && tcx.codegen_fn_attrs(def_id).target_features.is_empty()
+ {
+ candidates.vec.push(AsyncClosureCandidate);
+ }
}
_ => {}
}
diff --git a/library/std/build.rs b/library/std/build.rs
index 18ca7b512a9b6..35a5977b6ebaf 100644
--- a/library/std/build.rs
+++ b/library/std/build.rs
@@ -11,6 +11,7 @@ fn main() {
.expect("CARGO_CFG_TARGET_POINTER_WIDTH was not set")
.parse()
.unwrap();
+ let is_miri = env::var_os("CARGO_CFG_MIRI").is_some();
println!("cargo:rustc-check-cfg=cfg(netbsd10)");
if target_os == "netbsd" && env::var("RUSTC_STD_NETBSD10").is_ok() {
@@ -91,6 +92,8 @@ fn main() {
println!("cargo:rustc-check-cfg=cfg(reliable_f128_math)");
let has_reliable_f16 = match (target_arch.as_str(), target_os.as_str()) {
+ // We can always enable these in Miri as that is not affected by codegen bugs.
+ _ if is_miri => true,
// Selection failure until recent LLVM <https://github.com/llvm/llvm-project/issues/93894>
// FIXME(llvm19): can probably be removed at the version bump
("loongarch64", _) => false,
@@ -118,6 +121,8 @@ fn main() {
};
let has_reliable_f128 = match (target_arch.as_str(), target_os.as_str()) {
+ // We can always enable these in Miri as that is not affected by codegen bugs.
+ _ if is_miri => true,
// Unsupported <https://github.com/llvm/llvm-project/issues/94434>
("arm64ec", _) => false,
// ABI and precision bugs <https://github.com/rust-lang/rust/issues/125109>
@@ -141,6 +146,8 @@ fn main() {
// LLVM is currenlty adding missing routines, <https://github.com/llvm/llvm-project/issues/93566>
let has_reliable_f16_math = has_reliable_f16
&& match (target_arch.as_str(), target_os.as_str()) {
+ // FIXME: Disabled on Miri as the intrinsics are not implemented yet.
+ _ if is_miri => false,
// Currently nothing special. Hooray!
// This will change as platforms gain better better support for standard ops but math
// lags behind.
@@ -149,6 +156,8 @@ fn main() {
let has_reliable_f128_math = has_reliable_f128
&& match (target_arch.as_str(), target_os.as_str()) {
+ // FIXME: Disabled on Miri as the intrinsics are not implemented yet.
+ _ if is_miri => false,
// LLVM lowers `fp128` math to `long double` symbols even on platforms where
// `long double` is not IEEE binary128. See
// <https://github.com/llvm/llvm-project/issues/44744>.
diff --git a/library/std/src/f16/tests.rs b/library/std/src/f16/tests.rs
index 50504e7ffd94f..684ee3f3855b8 100644
--- a/library/std/src/f16/tests.rs
+++ b/library/std/src/f16/tests.rs
@@ -4,20 +4,20 @@
use crate::f16::consts;
use crate::num::{FpCategory as Fp, *};
-/// Tolerance for results on the order of 10.0e-2;
-#[cfg(reliable_f16_math)]
+/// Tolerance for results on the order of 10.0e-2
+#[allow(unused)]
const TOL_N2: f16 = 0.0001;
/// Tolerance for results on the order of 10.0e+0
-#[cfg(reliable_f16_math)]
+#[allow(unused)]
const TOL_0: f16 = 0.01;
/// Tolerance for results on the order of 10.0e+2
-#[cfg(reliable_f16_math)]
+#[allow(unused)]
const TOL_P2: f16 = 0.5;
/// Tolerance for results on the order of 10.0e+4
-#[cfg(reliable_f16_math)]
+#[allow(unused)]
const TOL_P4: f16 = 10.0;
/// Smallest number
diff --git a/library/std/src/sync/rwlock/tests.rs b/library/std/src/sync/rwlock/tests.rs
index 12bb0fbf0503b..37a2e41641ac1 100644
--- a/library/std/src/sync/rwlock/tests.rs
+++ b/library/std/src/sync/rwlock/tests.rs
@@ -21,6 +21,10 @@ fn smoke() {
}
#[test]
+// FIXME: On macOS we use a provenance-incorrect implementation and Miri
+// catches that issue with a chance of around 1/1000.
+// See <https://github.com/rust-lang/rust/issues/121950> for details.
+#[cfg_attr(all(miri, target_os = "macos"), ignore)]
fn frob() {
const N: u32 = 10;
const M: usize = if cfg!(miri) { 100 } else { 1000 };
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index e4549796b3e83..9c7a9f8467f5a 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -362,9 +362,10 @@ impl Options {
}
let color = config::parse_color(early_dcx, matches);
- let config::JsonConfig { json_rendered, json_unused_externs, .. } =
+ let config::JsonConfig { json_rendered, json_unused_externs, json_color, .. } =
config::parse_json(early_dcx, matches);
- let error_format = config::parse_error_format(early_dcx, matches, color, json_rendered);
+ let error_format =
+ config::parse_error_format(early_dcx, matches, color, json_color, json_rendered);
let diagnostic_width = matches.opt_get("diagnostic-width").unwrap_or_default();
let codegen_options = CodegenOptions::build(early_dcx, matches);
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index fea31e7ecbc9a..08a4a3f3fb264 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -138,8 +138,8 @@ pub(crate) fn new_dcx(
false,
);
let emitter: Box<DynEmitter> = match error_format {
- ErrorOutputType::HumanReadable(kind) => {
- let (short, color_config) = kind.unzip();
+ ErrorOutputType::HumanReadable(kind, color_config) => {
+ let short = kind.short();
Box::new(
HumanEmitter::new(stderr_destination(color_config), fallback_bundle)
.sm(source_map.map(|sm| sm as _))
@@ -150,7 +150,7 @@ pub(crate) fn new_dcx(
.ui_testing(unstable_opts.ui_testing),
)
}
- ErrorOutputType::Json { pretty, json_rendered } => {
+ ErrorOutputType::Json { pretty, json_rendered, color_config } => {
let source_map = source_map.unwrap_or_else(|| {
Lrc::new(source_map::SourceMap::new(source_map::FilePathMapping::empty()))
});
@@ -161,6 +161,7 @@ pub(crate) fn new_dcx(
fallback_bundle,
pretty,
json_rendered,
+ color_config,
)
.ui_testing(unstable_opts.ui_testing)
.diagnostic_width(diagnostic_width)
diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 41eb142dd1e29..08d6a5a52b21a 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -422,8 +422,8 @@ fn run_test(
path_for_rustdoc.to_str().expect("target path must be valid unicode")
}
});
- if let ErrorOutputType::HumanReadable(kind) = rustdoc_options.error_format {
- let (short, color_config) = kind.unzip();
+ if let ErrorOutputType::HumanReadable(kind, color_config) = rustdoc_options.error_format {
+ let short = kind.short();
if short {
compiler.arg("--error-format").arg("short");
diff --git a/src/librustdoc/passes/stripper.rs b/src/librustdoc/passes/stripper.rs
index d1e2b9978f7de..f807c3362c4cb 100644
--- a/src/librustdoc/passes/stripper.rs
+++ b/src/librustdoc/passes/stripper.rs
@@ -95,7 +95,14 @@ impl<'a, 'tcx> DocFolder for Stripper<'a, 'tcx> {
}
clean::ModuleItem(..) => {
- if i.item_id.is_local() && i.visibility(self.tcx) != Some(Visibility::Public) {
+ if i.item_id.is_local()
+ && !is_item_reachable(
+ self.tcx,
+ self.is_json_output,
+ self.effective_visibilities,
+ i.item_id,
+ )
+ {
debug!("Stripper: stripping module {:?}", i.name);
let old = mem::replace(&mut self.update_retained, false);
let ret = strip_item(self.fold_item_recur(i));
diff --git a/src/tools/clippy/.cargo/config.toml b/src/tools/clippy/.cargo/config.toml
index 7afdd068a9905..ce07290d1e1e5 100644
--- a/src/tools/clippy/.cargo/config.toml
+++ b/src/tools/clippy/.cargo/config.toml
@@ -13,6 +13,13 @@ target-dir = "target"
[unstable]
binary-dep-depinfo = true
+profile-rustflags = true
[profile.dev]
split-debuginfo = "unpacked"
+
+# Add back the containing directory of the packages we have to refer to using --manifest-path
+[profile.dev.package.clippy_dev]
+rustflags = ["--remap-path-prefix", "=clippy_dev"]
+[profile.dev.package.lintcheck]
+rustflags = ["--remap-path-prefix", "=lintcheck"]
diff --git a/src/tools/clippy/.github/workflows/clippy.yml b/src/tools/clippy/.github/workflows/clippy.yml
index 06bf3b6fdbfab..0a0538490cce9 100644
--- a/src/tools/clippy/.github/workflows/clippy.yml
+++ b/src/tools/clippy/.github/workflows/clippy.yml
@@ -25,6 +25,7 @@ env:
CARGO_TARGET_DIR: '${{ github.workspace }}/target'
NO_FMT_TEST: 1
CARGO_INCREMENTAL: 0
+ RUSTFLAGS: -D warnings
concurrency:
# For a given workflow, if we push to the same PR, cancel all previous builds on that PR.
@@ -47,25 +48,25 @@ jobs:
# Run
- name: Build
- run: cargo build --tests --features deny-warnings,internal
+ run: cargo build --tests --features internal
- name: Test
- run: cargo test --features deny-warnings,internal
+ run: cargo test --features internal
- name: Test clippy_lints
- run: cargo test --features deny-warnings,internal
+ run: cargo test --features internal
working-directory: clippy_lints
- name: Test clippy_utils
- run: cargo test --features deny-warnings
+ run: cargo test
working-directory: clippy_utils
- name: Test rustc_tools_util
- run: cargo test --features deny-warnings
+ run: cargo test
working-directory: rustc_tools_util
- name: Test clippy_dev
- run: cargo test --features deny-warnings
+ run: cargo test
working-directory: clippy_dev
- name: Test clippy-driver
diff --git a/src/tools/clippy/.github/workflows/clippy_bors.yml b/src/tools/clippy/.github/workflows/clippy_bors.yml
index 1f4bec9291823..10e18e84c89fd 100644
--- a/src/tools/clippy/.github/workflows/clippy_bors.yml
+++ b/src/tools/clippy/.github/workflows/clippy_bors.yml
@@ -11,6 +11,7 @@ env:
CARGO_TARGET_DIR: '${{ github.workspace }}/target'
NO_FMT_TEST: 1
CARGO_INCREMENTAL: 0
+ RUSTFLAGS: -D warnings
concurrency:
# For a given workflow, if we push to the same branch, cancel all previous builds on that branch.
@@ -85,34 +86,34 @@ jobs:
# Run
- name: Build
- run: cargo build --tests --features deny-warnings,internal
+ run: cargo build --tests --features internal
- name: Test
if: matrix.host == 'x86_64-unknown-linux-gnu'
- run: cargo test --features deny-warnings,internal
+ run: cargo test --features internal
- name: Test
if: matrix.host != 'x86_64-unknown-linux-gnu'
- run: cargo test --features deny-warnings,internal -- --skip dogfood
+ run: cargo test --features internal -- --skip dogfood
- name: Test clippy_lints
- run: cargo test --features deny-warnings,internal
+ run: cargo test --features internal
working-directory: clippy_lints
- name: Test clippy_utils
- run: cargo test --features deny-warnings
+ run: cargo test
working-directory: clippy_utils
- name: Test clippy_config
- run: cargo test --features deny-warnings
+ run: cargo test
working-directory: clippy_config
- name: Test rustc_tools_util
- run: cargo test --features deny-warnings
+ run: cargo test
working-directory: rustc_tools_util
- name: Test clippy_dev
- run: cargo test --features deny-warnings
+ run: cargo test
working-directory: clippy_dev
- name: Test clippy-driver
diff --git a/src/tools/clippy/.github/workflows/clippy_dev.yml b/src/tools/clippy/.github/workflows/clippy_dev.yml
index 37f18a4c08740..cf0a8bde202ad 100644
--- a/src/tools/clippy/.github/workflows/clippy_dev.yml
+++ b/src/tools/clippy/.github/workflows/clippy_dev.yml
@@ -16,6 +16,7 @@ on:
env:
RUST_BACKTRACE: 1
CARGO_INCREMENTAL: 0
+ RUSTFLAGS: -D warnings
jobs:
clippy_dev:
@@ -28,7 +29,7 @@ jobs:
# Run
- name: Build
- run: cargo build --features deny-warnings
+ run: cargo build
working-directory: clippy_dev
- name: Test update_lints
@@ -38,6 +39,8 @@ jobs:
run: cargo dev fmt --check
- name: Test cargo dev new lint
+ env:
+ RUSTFLAGS: -A unused-imports
run: |
cargo dev new_lint --name new_early_pass --pass early
cargo dev new_lint --name new_late_pass --pass late
diff --git a/src/tools/clippy/.github/workflows/lintcheck.yml b/src/tools/clippy/.github/workflows/lintcheck.yml
index 6a5139b6dc0bb..3cbda0b382436 100644
--- a/src/tools/clippy/.github/workflows/lintcheck.yml
+++ b/src/tools/clippy/.github/workflows/lintcheck.yml
@@ -58,7 +58,7 @@ jobs:
- name: Run lintcheck
if: steps.cache-json.outputs.cache-hit != 'true'
- run: ./target/debug/lintcheck --format json --warn-all --crates-toml ./lintcheck/ci_crates.toml
+ run: ./target/debug/lintcheck --format json --all-lints --crates-toml ./lintcheck/ci_crates.toml
- name: Upload base JSON
uses: actions/upload-artifact@v4
@@ -86,7 +86,7 @@ jobs:
run: cargo build --manifest-path=lintcheck/Cargo.toml
- name: Run lintcheck
- run: ./target/debug/lintcheck --format json --warn-all --crates-toml ./lintcheck/ci_crates.toml
+ run: ./target/debug/lintcheck --format json --all-lints --crates-toml ./lintcheck/ci_crates.toml
- name: Upload head JSON
uses: actions/upload-artifact@v4
diff --git a/src/tools/clippy/CHANGELOG.md b/src/tools/clippy/CHANGELOG.md
index 60c03b03d9be3..fddc2fd994e87 100644
--- a/src/tools/clippy/CHANGELOG.md
+++ b/src/tools/clippy/CHANGELOG.md
@@ -5830,6 +5830,7 @@ Released 2018-09-13
[`result_unit_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unit_err
[`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
[`return_self_not_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#return_self_not_must_use
+[`reverse_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#reverse_range_loop
[`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
[`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
[`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
@@ -5998,6 +5999,7 @@ Released 2018-09-13
[`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
[`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
[`unused_peekable`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_peekable
+[`unused_result_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_result_ok
[`unused_rounding`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_rounding
[`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
[`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
diff --git a/src/tools/clippy/Cargo.toml b/src/tools/clippy/Cargo.toml
index bb4dc97e748e3..78409c7a09e29 100644
--- a/src/tools/clippy/Cargo.toml
+++ b/src/tools/clippy/Cargo.toml
@@ -30,7 +30,7 @@ color-print = "0.3.4"
anstream = "0.6.0"
[dev-dependencies]
-ui_test = "0.24"
+ui_test = "0.25"
regex = "1.5.5"
toml = "0.7.3"
walkdir = "2.3"
@@ -51,7 +51,6 @@ tokio = { version = "1", features = ["io-util"] }
rustc_tools_util = "0.3.0"
[features]
-deny-warnings = ["clippy_lints/deny-warnings"]
integration = ["tempfile"]
internal = ["clippy_lints/internal", "tempfile"]
diff --git a/src/tools/clippy/book/src/lint_configuration.md b/src/tools/clippy/book/src/lint_configuration.md
index fb717a2c166d4..e3d550b146629 100644
--- a/src/tools/clippy/book/src/lint_configuration.md
+++ b/src/tools/clippy/book/src/lint_configuration.md
@@ -364,7 +364,7 @@ Suppress lints whenever the suggested change would cause breakage for other crat
## `await-holding-invalid-types`
-
+The list of types which may not be held across an await point.
**Default Value:** `[]`
@@ -668,6 +668,8 @@ crate. For example, `pub(crate)` items.
## `msrv`
The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
+**Default Value:** `current version`
+
---
**Affected lints:**
* [`allow_attributes`](https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes)
@@ -862,6 +864,8 @@ The maximum number of lines a function or method can have
The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by
reference. By default there is no limit
+**Default Value:** `target_pointer_width * 2`
+
---
**Affected lints:**
* [`trivially_copy_pass_by_ref`](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref)
diff --git a/src/tools/clippy/clippy_config/Cargo.toml b/src/tools/clippy/clippy_config/Cargo.toml
index e1b2edc8a6ff9..d5b28e2532371 100644
--- a/src/tools/clippy/clippy_config/Cargo.toml
+++ b/src/tools/clippy/clippy_config/Cargo.toml
@@ -6,6 +6,7 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
+itertools = "0.12"
rustc-semver = "1.1"
serde = { version = "1.0", features = ["derive"] }
toml = "0.7.3"
@@ -13,9 +14,6 @@ toml = "0.7.3"
[dev-dependencies]
walkdir = "2.3"
-[features]
-deny-warnings = []
-
[package.metadata.rust-analyzer]
# This crate uses #[feature(rustc_private)]
rustc_private = true
diff --git a/src/tools/clippy/clippy_config/src/conf.rs b/src/tools/clippy/clippy_config/src/conf.rs
index 63140a36875da..4c2a8255d6b65 100644
--- a/src/tools/clippy/clippy_config/src/conf.rs
+++ b/src/tools/clippy/clippy_config/src/conf.rs
@@ -123,7 +123,8 @@ macro_rules! define_Conf {
$(#[doc = $doc:literal])+
$(#[conf_deprecated($dep:literal, $new_conf:ident)])?
$(#[default_text = $default_text:expr])?
- ($name:ident: $ty:ty = $default:expr),
+ $(#[lints($($for_lints:ident),* $(,)?)])?
+ $name:ident: $ty:ty = $default:expr,
)*) => {
/// Clippy lint configuration
pub struct Conf {
@@ -201,29 +202,128 @@ macro_rules! define_Conf {
}
pub fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
- let mut sorted = vec![
- $(
- {
- let deprecation_reason = wrap_option!($($dep)?);
-
- ClippyConfiguration::new(
- stringify!($name),
- default_text!(defaults::$name() $(, $default_text)?),
- concat!($($doc, '\n',)*),
- deprecation_reason,
- )
- },
- )+
- ];
- sorted.sort_by(|a, b| a.name.cmp(&b.name));
- sorted
+ vec![$(
+ ClippyConfiguration {
+ name: stringify!($name).replace('_', "-"),
+ default: default_text!(defaults::$name() $(, $default_text)?),
+ lints: &[$($(stringify!($for_lints)),*)?],
+ doc: concat!($($doc, '\n',)*),
+ deprecation_reason: wrap_option!($($dep)?)
+ },
+ )*]
}
};
}
define_Conf! {
- /// Lint: ARITHMETIC_SIDE_EFFECTS.
+ /// Which crates to allow absolute paths from
+ #[lints(absolute_paths)]
+ absolute_paths_allowed_crates: FxHashSet<String> = FxHashSet::default(),
+ /// The maximum number of segments a path can have before being linted, anything above this will
+ /// be linted.
+ #[lints(absolute_paths)]
+ absolute_paths_max_segments: u64 = 2,
+ /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
+ #[lints(undocumented_unsafe_blocks)]
+ accept_comment_above_attributes: bool = true,
+ /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
+ #[lints(undocumented_unsafe_blocks)]
+ accept_comment_above_statement: bool = true,
+ /// Don't lint when comparing the result of a modulo operation to zero.
+ #[lints(modulo_arithmetic)]
+ allow_comparison_to_zero: bool = true,
+ /// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
+ #[lints(dbg_macro)]
+ allow_dbg_in_tests: bool = false,
+ /// Whether `expect` should be allowed in test functions or `#[cfg(test)]`
+ #[lints(expect_used)]
+ allow_expect_in_tests: bool = false,
+ /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
+ #[lints(uninlined_format_args)]
+ allow_mixed_uninlined_format_args: bool = true,
+ /// Whether to allow `r#""#` when `r""` can be used
+ #[lints(unnecessary_raw_string_hashes)]
+ allow_one_hash_in_raw_strings: bool = false,
+ /// Whether `panic` should be allowed in test functions or `#[cfg(test)]`
+ #[lints(panic)]
+ allow_panic_in_tests: bool = false,
+ /// Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
+ #[lints(print_stderr, print_stdout)]
+ allow_print_in_tests: bool = false,
+ /// Whether to allow module inception if it's not public.
+ #[lints(module_inception)]
+ allow_private_module_inception: bool = false,
+ /// List of trait paths to ignore when checking renamed function parameters.
+ ///
+ /// #### Example
+ ///
+ /// ```toml
+ /// allow-renamed-params-for = [ "std::convert::From" ]
+ /// ```
+ ///
+ /// #### Noteworthy
+ ///
+ /// - By default, the following traits are ignored: `From`, `TryFrom`, `FromStr`
+ /// - `".."` can be used as part of the list to indicate that the configured values should be appended to the
+ /// default configuration of Clippy. By default, any configuration will replace the default value.
+ #[lints(renamed_function_params)]
+ allow_renamed_params_for: Vec<String> =
+ DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS.iter().map(ToString::to_string).collect(),
+ /// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
+ #[lints(unwrap_used)]
+ allow_unwrap_in_tests: bool = false,
+ /// Whether `useless_vec` should ignore test functions or `#[cfg(test)]`
+ #[lints(useless_vec)]
+ allow_useless_vec_in_tests: bool = false,
+ /// Additional dotfiles (files or directories starting with a dot) to allow
+ #[lints(path_ends_with_ext)]
+ allowed_dotfiles: Vec<String> = Vec::default(),
+ /// A list of crate names to allow duplicates of
+ #[lints(multiple_crate_versions)]
+ allowed_duplicate_crates: FxHashSet<String> = FxHashSet::default(),
+ /// Allowed names below the minimum allowed characters. The value `".."` can be used as part of
+ /// the list to indicate, that the configured values should be appended to the default
+ /// configuration of Clippy. By default, any configuration will replace the default value.
+ #[lints(min_ident_chars)]
+ allowed_idents_below_min_chars: FxHashSet<String> =
+ DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect(),
+ /// List of prefixes to allow when determining whether an item's name ends with the module's name.
+ /// If the rest of an item's name is an allowed prefix (e.g. item `ToFoo` or `to_foo` in module `foo`),
+ /// then don't emit a warning.
+ ///
+ /// #### Example
+ ///
+ /// ```toml
+ /// allowed-prefixes = [ "to", "from" ]
+ /// ```
+ ///
+ /// #### Noteworthy
+ ///
+ /// - By default, the following prefixes are allowed: `to`, `as`, `into`, `from`, `try_into` and `try_from`
+ /// - PascalCase variant is included automatically for each snake_case variant (e.g. if `try_into` is included,
+ /// `TryInto` will also be included)
+ /// - Use `".."` as part of the list to indicate that the configured values should be appended to the
+ /// default configuration of Clippy. By default, any configuration will replace the default value
+ #[lints(module_name_repetitions)]
+ allowed_prefixes: Vec<String> = DEFAULT_ALLOWED_PREFIXES.iter().map(ToString::to_string).collect(),
+ /// The list of unicode scripts allowed to be used in the scope.
+ #[lints(disallowed_script_idents)]
+ allowed_scripts: Vec<String> = vec!["Latin".to_string()],
+ /// List of path segments allowed to have wildcard imports.
///
+ /// #### Example
+ ///
+ /// ```toml
+ /// allowed-wildcard-imports = [ "utils", "common" ]
+ /// ```
+ ///
+ /// #### Noteworthy
+ ///
+ /// 1. This configuration has no effects if used with `warn_on_all_wildcard_imports = true`.
+ /// 2. Paths with any segment that containing the word 'prelude'
+ /// are already allowed by default.
+ #[lints(wildcard_imports)]
+ allowed_wildcard_imports: FxHashSet<String> = FxHashSet::default(),
/// Suppress checking of the passed type names in all types of operations.
///
/// If a specific operation is desired, consider using `arithmetic_side_effects_allowed_binary` or `arithmetic_side_effects_allowed_unary` instead.
@@ -238,9 +338,8 @@ define_Conf! {
///
/// A type, say `SomeType`, listed in this configuration has the same behavior of
/// `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
- (arithmetic_side_effects_allowed: Vec<String> = <_>::default()),
- /// Lint: ARITHMETIC_SIDE_EFFECTS.
- ///
+ #[lints(arithmetic_side_effects)]
+ arithmetic_side_effects_allowed: Vec<String> = <_>::default(),
/// Suppress checking of the passed type pair names in binary operations like addition or
/// multiplication.
///
@@ -255,9 +354,8 @@ define_Conf! {
/// ```toml
/// arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]]
/// ```
- (arithmetic_side_effects_allowed_binary: Vec<[String; 2]> = <_>::default()),
- /// Lint: ARITHMETIC_SIDE_EFFECTS.
- ///
+ #[lints(arithmetic_side_effects)]
+ arithmetic_side_effects_allowed_binary: Vec<[String; 2]> = <_>::default(),
/// Suppress checking of the passed type names in unary operations like "negation" (`-`).
///
/// #### Example
@@ -265,298 +363,78 @@ define_Conf! {
/// ```toml
/// arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
/// ```
- (arithmetic_side_effects_allowed_unary: Vec<String> = <_>::default()),
- /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX, UNNECESSARY_BOX_RETURNS, SINGLE_CALL_FN, NEEDLESS_PASS_BY_REF_MUT.
- ///
+ #[lints(arithmetic_side_effects)]
+ arithmetic_side_effects_allowed_unary: Vec<String> = <_>::default(),
+ /// The maximum allowed size for arrays on the stack
+ #[lints(large_const_arrays, large_stack_arrays)]
+ array_size_threshold: u64 = 512_000,
/// Suppress lints whenever the suggested change would cause breakage for other crates.
- (avoid_breaking_exported_api: bool = true),
- /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE, ITER_KV_MAP, MANUAL_C_STR_LITERALS, ASSIGNING_CLONES, LEGACY_NUMERIC_CONSTANTS, MANUAL_PATTERN_CHAR_COMPARISON, ALLOW_ATTRIBUTES, ALLOW_ATTRIBUTES_WITHOUT_REASON, COLLAPSIBLE_MATCH.
- ///
- /// The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
- #[default_text = ""]
- (msrv: Msrv = Msrv::empty()),
+ #[lints(
+ box_collection,
+ enum_variant_names,
+ large_types_passed_by_value,
+ linkedlist,
+ needless_pass_by_ref_mut,
+ option_option,
+ rc_buffer,
+ rc_mutex,
+ redundant_allocation,
+ single_call_fn,
+ trivially_copy_pass_by_ref,
+ unnecessary_box_returns,
+ unnecessary_wraps,
+ unused_self,
+ upper_case_acronyms,
+ vec_box,
+ wrong_self_convention,
+ )]
+ avoid_breaking_exported_api: bool = true,
+ /// The list of types which may not be held across an await point.
+ #[lints(await_holding_invalid_type)]
+ await_holding_invalid_types: Vec<DisallowedPath> = Vec::new(),
/// DEPRECATED LINT: BLACKLISTED_NAME.
///
/// Use the Disallowed Names lint instead
#[conf_deprecated("Please use `disallowed-names` instead", disallowed_names)]
- (blacklisted_names: Vec<String> = Vec::new()),
- /// Lint: COGNITIVE_COMPLEXITY.
- ///
+ blacklisted_names: Vec<String> = Vec::new(),
+ /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+ #[lints(cargo_common_metadata)]
+ cargo_ignore_publish: bool = false,
+ /// Whether to also run the listed lints on private items.
+ #[lints(missing_errors_doc, missing_panics_doc, missing_safety_doc, unnecessary_safety_doc)]
+ check_private_items: bool = false,
/// The maximum cognitive complexity a function can have
- (cognitive_complexity_threshold: u64 = 25),
- /// Lint: EXCESSIVE_NESTING.
- ///
- /// The maximum amount of nesting a block can reside in
- (excessive_nesting_threshold: u64 = 0),
+ #[lints(cognitive_complexity)]
+ cognitive_complexity_threshold: u64 = 25,
/// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
///
/// Use the Cognitive Complexity lint instead.
#[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
- (cyclomatic_complexity_threshold: u64 = 25),
- /// Lint: DISALLOWED_NAMES.
- ///
+ cyclomatic_complexity_threshold: u64 = 25,
+ /// The list of disallowed macros, written as fully qualified paths.
+ #[lints(disallowed_macros)]
+ disallowed_macros: Vec<DisallowedPath> = Vec::new(),
+ /// The list of disallowed methods, written as fully qualified paths.
+ #[lints(disallowed_methods)]
+ disallowed_methods: Vec<DisallowedPath> = Vec::new(),
/// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
/// `".."` can be used as part of the list to indicate that the configured values should be appended to the
/// default configuration of Clippy. By default, any configuration will replace the default value.
- (disallowed_names: Vec<String> = DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
- /// Lint: SEMICOLON_INSIDE_BLOCK.
- ///
- /// Whether to lint only if it's multiline.
- (semicolon_inside_block_ignore_singleline: bool = false),
- /// Lint: SEMICOLON_OUTSIDE_BLOCK.
- ///
- /// Whether to lint only if it's singleline.
- (semicolon_outside_block_ignore_multiline: bool = false),
- /// Lint: DOC_MARKDOWN.
- ///
+ #[lints(disallowed_names)]
+ disallowed_names: Vec<String> = DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect(),
+ /// The list of disallowed types, written as fully qualified paths.
+ #[lints(disallowed_types)]
+ disallowed_types: Vec<DisallowedPath> = Vec::new(),
/// The list of words this lint should not consider as identifiers needing ticks. The value
/// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
/// default configuration of Clippy. By default, any configuration will replace the default value. For example:
/// * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
/// * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
- (doc_valid_idents: FxHashSet<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect()),
- /// Lint: TOO_MANY_ARGUMENTS.
- ///
- /// The maximum number of argument a function or method can have
- (too_many_arguments_threshold: u64 = 7),
- /// Lint: TYPE_COMPLEXITY.
- ///
- /// The maximum complexity a type can have
- (type_complexity_threshold: u64 = 250),
- /// Lint: MANY_SINGLE_CHAR_NAMES.
- ///
- /// The maximum number of single char bindings a scope may have
- (single_char_binding_names_threshold: u64 = 4),
- /// Lint: BOXED_LOCAL, USELESS_VEC.
- ///
- /// The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
- (too_large_for_stack: u64 = 200),
- /// Lint: ENUM_VARIANT_NAMES.
- ///
- /// The minimum number of enum variants for the lints about variant names to trigger
- (enum_variant_name_threshold: u64 = 3),
- /// Lint: STRUCT_FIELD_NAMES.
- ///
- /// The minimum number of struct fields for the lints about field names to trigger
- (struct_field_name_threshold: u64 = 3),
- /// Lint: LARGE_ENUM_VARIANT.
- ///
- /// The maximum size of an enum's variant to avoid box suggestion
- (enum_variant_size_threshold: u64 = 200),
- /// Lint: VERBOSE_BIT_MASK.
- ///
- /// The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
- (verbose_bit_mask_threshold: u64 = 1),
- /// Lint: DECIMAL_LITERAL_REPRESENTATION.
- ///
- /// The lower bound for linting decimal literals
- (literal_representation_threshold: u64 = 16384),
- /// Lint: TRIVIALLY_COPY_PASS_BY_REF.
- ///
- /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by
- /// reference. By default there is no limit
- #[default_text = ""]
- (trivial_copy_size_limit: Option<u64> = None),
- /// Lint: LARGE_TYPES_PASSED_BY_VALUE.
- ///
- /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
- (pass_by_value_size_limit: u64 = 256),
- /// Lint: TOO_MANY_LINES.
- ///
- /// The maximum number of lines a function or method can have
- (too_many_lines_threshold: u64 = 100),
- /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS.
- ///
- /// The maximum allowed size for arrays on the stack
- (array_size_threshold: u64 = 512_000),
- /// Lint: LARGE_STACK_FRAMES.
- ///
- /// The maximum allowed stack size for functions in bytes
- (stack_size_threshold: u64 = 512_000),
- /// Lint: VEC_BOX.
- ///
- /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
- (vec_box_size_threshold: u64 = 4096),
- /// Lint: TYPE_REPETITION_IN_BOUNDS.
- ///
- /// The maximum number of bounds a trait can have to be linted
- (max_trait_bounds: u64 = 3),
- /// Lint: STRUCT_EXCESSIVE_BOOLS.
- ///
- /// The maximum number of bool fields a struct can have
- (max_struct_bools: u64 = 3),
- /// Lint: FN_PARAMS_EXCESSIVE_BOOLS.
- ///
- /// The maximum number of bool parameters a function can have
- (max_fn_params_bools: u64 = 3),
- /// Lint: WILDCARD_IMPORTS.
- ///
- /// Whether to allow certain wildcard imports (prelude, super in tests).
- (warn_on_all_wildcard_imports: bool = false),
- /// Lint: DISALLOWED_MACROS.
- ///
- /// The list of disallowed macros, written as fully qualified paths.
- (disallowed_macros: Vec<DisallowedPath> = Vec::new()),
- /// Lint: DISALLOWED_METHODS.
- ///
- /// The list of disallowed methods, written as fully qualified paths.
- (disallowed_methods: Vec<DisallowedPath> = Vec::new()),
- /// Lint: DISALLOWED_TYPES.
- ///
- /// The list of disallowed types, written as fully qualified paths.
- (disallowed_types: Vec<DisallowedPath> = Vec::new()),
- /// Lint: UNREADABLE_LITERAL.
- ///
- /// Should the fraction of a decimal be linted to include separators.
- (unreadable_literal_lint_fractions: bool = true),
- /// Lint: UPPER_CASE_ACRONYMS.
- ///
- /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
- (upper_case_acronyms_aggressive: bool = false),
- /// Lint: MANUAL_LET_ELSE.
- ///
- /// Whether the matches should be considered by the lint, and whether there should
- /// be filtering for common types.
- (matches_for_let_else: MatchLintBehaviour = MatchLintBehaviour::WellKnownTypes),
- /// Lint: CARGO_COMMON_METADATA.
- ///
- /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
- (cargo_ignore_publish: bool = false),
- /// Lint: NONSTANDARD_MACRO_BRACES.
- ///
- /// Enforce the named macros always use the braces specified.
- ///
- /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
- /// could be used with a full path two `MacroMatcher`s have to be added one with the full path
- /// `crate_name::macro_name` and one with just the macro name.
- (standard_macro_braces: Vec<MacroMatcher> = Vec::new()),
- /// Lint: MISSING_ENFORCED_IMPORT_RENAMES.
- ///
- /// The list of imports to always rename, a fully qualified path followed by the rename.
- (enforced_import_renames: Vec<Rename> = Vec::new()),
- /// Lint: DISALLOWED_SCRIPT_IDENTS.
- ///
- /// The list of unicode scripts allowed to be used in the scope.
- (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
- /// Lint: NON_SEND_FIELDS_IN_SEND_TY.
- ///
+ #[lints(doc_markdown)]
+ doc_valid_idents: FxHashSet<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect(),
/// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
- (enable_raw_pointer_heuristic_for_send: bool = true),
- /// Lint: INDEX_REFUTABLE_SLICE.
- ///
- /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
- /// the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
- /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
- (max_suggested_slice_pattern_length: u64 = 3),
- /// Lint: AWAIT_HOLDING_INVALID_TYPE.
- (await_holding_invalid_types: Vec<DisallowedPath> = Vec::new()),
- /// Lint: LARGE_INCLUDE_FILE.
- ///
- /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
- (max_include_file_size: u64 = 1_000_000),
- /// Lint: EXPECT_USED.
- ///
- /// Whether `expect` should be allowed in test functions or `#[cfg(test)]`
- (allow_expect_in_tests: bool = false),
- /// Lint: UNWRAP_USED.
- ///
- /// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
- (allow_unwrap_in_tests: bool = false),
- /// Lint: PANIC.
- ///
- /// Whether `panic` should be allowed in test functions or `#[cfg(test)]`
- (allow_panic_in_tests: bool = false),
- /// Lint: DBG_MACRO.
- ///
- /// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
- (allow_dbg_in_tests: bool = false),
- /// Lint: PRINT_STDOUT, PRINT_STDERR.
- ///
- /// Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
- (allow_print_in_tests: bool = false),
- /// Lint: USELESS_VEC.
- ///
- /// Whether `useless_vec` should ignore test functions or `#[cfg(test)]`
- (allow_useless_vec_in_tests: bool = false),
- /// Lint: RESULT_LARGE_ERR.
- ///
- /// The maximum size of the `Err`-variant in a `Result` returned from a function
- (large_error_threshold: u64 = 128),
- /// Lint: MUTABLE_KEY_TYPE, IFS_SAME_COND, BORROW_INTERIOR_MUTABLE_CONST, DECLARE_INTERIOR_MUTABLE_CONST.
- ///
- /// A list of paths to types that should be treated as if they do not contain interior mutability
- (ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()])),
- /// Lint: UNINLINED_FORMAT_ARGS.
- ///
- /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
- (allow_mixed_uninlined_format_args: bool = true),
- /// Lint: INDEXING_SLICING.
- ///
- /// Whether to suppress a restriction lint in constant code. In same
- /// cases the restructured operation might not be unavoidable, as the
- /// suggested counterparts are unavailable in constant code. This
- /// configuration will cause restriction lints to trigger even
- /// if no suggestion can be made.
- (suppress_restriction_lint_in_const: bool = false),
- /// Lint: MISSING_DOCS_IN_PRIVATE_ITEMS.
- ///
- /// Whether to **only** check for missing documentation in items visible within the current
- /// crate. For example, `pub(crate)` items.
- (missing_docs_in_crate_items: bool = false),
- /// Lint: LARGE_FUTURES.
- ///
- /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
- (future_size_threshold: u64 = 16 * 1024),
- /// Lint: UNNECESSARY_BOX_RETURNS.
- ///
- /// The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
- (unnecessary_box_size: u64 = 128),
- /// Lint: MODULE_INCEPTION.
- ///
- /// Whether to allow module inception if it's not public.
- (allow_private_module_inception: bool = false),
- /// Lint: MIN_IDENT_CHARS.
- ///
- /// Allowed names below the minimum allowed characters. The value `".."` can be used as part of
- /// the list to indicate, that the configured values should be appended to the default
- /// configuration of Clippy. By default, any configuration will replace the default value.
- (allowed_idents_below_min_chars: FxHashSet<String> =
- DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect()),
- /// Lint: MIN_IDENT_CHARS.
- ///
- /// Minimum chars an ident can have, anything below or equal to this will be linted.
- (min_ident_chars_threshold: u64 = 1),
- /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
- ///
- /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
- (accept_comment_above_statement: bool = true),
- /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
- ///
- /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
- (accept_comment_above_attributes: bool = true),
- /// Lint: UNNECESSARY_RAW_STRING_HASHES.
- ///
- /// Whether to allow `r#""#` when `r""` can be used
- (allow_one_hash_in_raw_strings: bool = false),
- /// Lint: ABSOLUTE_PATHS.
- ///
- /// The maximum number of segments a path can have before being linted, anything above this will
- /// be linted.
- (absolute_paths_max_segments: u64 = 2),
- /// Lint: ABSOLUTE_PATHS.
- ///
- /// Which crates to allow absolute paths from
- (absolute_paths_allowed_crates: FxHashSet<String> = FxHashSet::default()),
- /// Lint: PATH_ENDS_WITH_EXT.
- ///
- /// Additional dotfiles (files or directories starting with a dot) to allow
- (allowed_dotfiles: Vec<String> = Vec::default()),
- /// Lint: MULTIPLE_CRATE_VERSIONS.
- ///
- /// A list of crate names to allow duplicates of
- (allowed_duplicate_crates: FxHashSet<String> = FxHashSet::default()),
- /// Lint: EXPLICIT_ITER_LOOP.
- ///
+ #[lints(non_send_fields_in_send_ty)]
+ enable_raw_pointer_heuristic_for_send: bool = true,
/// Whether to recommend using implicit into iter for reborrowed values.
///
/// #### Example
@@ -574,77 +452,195 @@ define_Conf! {
/// for _ in &*rmvec {}
/// for _ in &mut *rmvec {}
/// ```
- (enforce_iter_loop_reborrow: bool = false),
- /// Lint: MISSING_SAFETY_DOC, UNNECESSARY_SAFETY_DOC, MISSING_PANICS_DOC, MISSING_ERRORS_DOC.
- ///
- /// Whether to also run the listed lints on private items.
- (check_private_items: bool = false),
- /// Lint: PUB_UNDERSCORE_FIELDS.
- ///
+ #[lints(explicit_iter_loop)]
+ enforce_iter_loop_reborrow: bool = false,
+ /// The list of imports to always rename, a fully qualified path followed by the rename.
+ #[lints(missing_enforced_import_renames)]
+ enforced_import_renames: Vec<Rename> = Vec::new(),
+ /// The minimum number of enum variants for the lints about variant names to trigger
+ #[lints(enum_variant_names)]
+ enum_variant_name_threshold: u64 = 3,
+ /// The maximum size of an enum's variant to avoid box suggestion
+ #[lints(large_enum_variant)]
+ enum_variant_size_threshold: u64 = 200,
+ /// The maximum amount of nesting a block can reside in
+ #[lints(excessive_nesting)]
+ excessive_nesting_threshold: u64 = 0,
+ /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
+ #[lints(large_futures)]
+ future_size_threshold: u64 = 16 * 1024,
+ /// A list of paths to types that should be treated as if they do not contain interior mutability
+ #[lints(borrow_interior_mutable_const, declare_interior_mutable_const, ifs_same_cond, mutable_key_type)]
+ ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()]),
+ /// The maximum size of the `Err`-variant in a `Result` returned from a function
+ #[lints(result_large_err)]
+ large_error_threshold: u64 = 128,
+ /// The lower bound for linting decimal literals
+ #[lints(decimal_literal_representation)]
+ literal_representation_threshold: u64 = 16384,
+ /// Whether the matches should be considered by the lint, and whether there should
+ /// be filtering for common types.
+ #[lints(manual_let_else)]
+ matches_for_let_else: MatchLintBehaviour = MatchLintBehaviour::WellKnownTypes,
+ /// The maximum number of bool parameters a function can have
+ #[lints(fn_params_excessive_bools)]
+ max_fn_params_bools: u64 = 3,
+ /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
+ #[lints(large_include_file)]
+ max_include_file_size: u64 = 1_000_000,
+ /// The maximum number of bool fields a struct can have
+ #[lints(struct_excessive_bools)]
+ max_struct_bools: u64 = 3,
+ /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
+ /// the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
+ /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
+ #[lints(index_refutable_slice)]
+ max_suggested_slice_pattern_length: u64 = 3,
+ /// The maximum number of bounds a trait can have to be linted
+ #[lints(type_repetition_in_bounds)]
+ max_trait_bounds: u64 = 3,
+ /// Minimum chars an ident can have, anything below or equal to this will be linted.
+ #[lints(min_ident_chars)]
+ min_ident_chars_threshold: u64 = 1,
+ /// Whether to **only** check for missing documentation in items visible within the current
+ /// crate. For example, `pub(crate)` items.
+ #[lints(missing_docs_in_private_items)]
+ missing_docs_in_crate_items: bool = false,
+ /// The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
+ #[default_text = "current version"]
+ #[lints(
+ allow_attributes,
+ allow_attributes_without_reason,
+ almost_complete_range,
+ approx_constant,
+ assigning_clones,
+ borrow_as_ptr,
+ cast_abs_to_unsigned,
+ checked_conversions,
+ cloned_instead_of_copied,
+ collapsible_match,
+ collapsible_str_replace,
+ deprecated_cfg_attr,
+ derivable_impls,
+ err_expect,
+ filter_map_next,
+ from_over_into,
+ if_then_some_else_none,
+ index_refutable_slice,
+ iter_kv_map,
+ legacy_numeric_constants,
+ manual_bits,
+ manual_c_str_literals,
+ manual_clamp,
+ manual_hash_one,
+ manual_is_ascii_check,
+ manual_let_else,
+ manual_non_exhaustive,
+ manual_pattern_char_comparison,
+ manual_range_contains,
+ manual_rem_euclid,
+ manual_retain,
+ manual_split_once,
+ manual_str_repeat,
+ manual_strip,
+ manual_try_fold,
+ map_clone,
+ map_unwrap_or,
+ match_like_matches_macro,
+ mem_replace_with_default,
+ missing_const_for_fn,
+ needless_borrow,
+ option_as_ref_deref,
+ option_map_unwrap_or,
+ ptr_as_ptr,
+ redundant_field_names,
+ redundant_static_lifetimes,
+ seek_from_current,
+ seek_rewind,
+ transmute_ptr_to_ref,
+ tuple_array_conversions,
+ type_repetition_in_bounds,
+ unchecked_duration_subtraction,
+ uninlined_format_args,
+ unnecessary_lazy_evaluations,
+ unnested_or_patterns,
+ use_self,
+ )]
+ msrv: Msrv = Msrv::empty(),
+ /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+ #[lints(large_types_passed_by_value)]
+ pass_by_value_size_limit: u64 = 256,
/// Lint "public" fields in a struct that are prefixed with an underscore based on their
/// exported visibility, or whether they are marked as "pub".
- (pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PubliclyExported),
- /// Lint: MODULO_ARITHMETIC.
- ///
- /// Don't lint when comparing the result of a modulo operation to zero.
- (allow_comparison_to_zero: bool = true),
- /// Lint: WILDCARD_IMPORTS.
- ///
- /// List of path segments allowed to have wildcard imports.
- ///
- /// #### Example
- ///
- /// ```toml
- /// allowed-wildcard-imports = [ "utils", "common" ]
- /// ```
- ///
- /// #### Noteworthy
- ///
- /// 1. This configuration has no effects if used with `warn_on_all_wildcard_imports = true`.
- /// 2. Paths with any segment that containing the word 'prelude'
- /// are already allowed by default.
- (allowed_wildcard_imports: FxHashSet<String> = FxHashSet::default()),
- /// Lint: MODULE_NAME_REPETITIONS.
- ///
- /// List of prefixes to allow when determining whether an item's name ends with the module's name.
- /// If the rest of an item's name is an allowed prefix (e.g. item `ToFoo` or `to_foo` in module `foo`),
- /// then don't emit a warning.
- ///
- /// #### Example
- ///
- /// ```toml
- /// allowed-prefixes = [ "to", "from" ]
- /// ```
- ///
- /// #### Noteworthy
- ///
- /// - By default, the following prefixes are allowed: `to`, `as`, `into`, `from`, `try_into` and `try_from`
- /// - PascalCase variant is included automatically for each snake_case variant (e.g. if `try_into` is included,
- /// `TryInto` will also be included)
- /// - Use `".."` as part of the list to indicate that the configured values should be appended to the
- /// default configuration of Clippy. By default, any configuration will replace the default value
- (allowed_prefixes: Vec<String> = DEFAULT_ALLOWED_PREFIXES.iter().map(ToString::to_string).collect()),
- /// Lint: RENAMED_FUNCTION_PARAMS.
- ///
- /// List of trait paths to ignore when checking renamed function parameters.
- ///
- /// #### Example
- ///
- /// ```toml
- /// allow-renamed-params-for = [ "std::convert::From" ]
- /// ```
- ///
- /// #### Noteworthy
- ///
- /// - By default, the following traits are ignored: `From`, `TryFrom`, `FromStr`
- /// - `".."` can be used as part of the list to indicate that the configured values should be appended to the
- /// default configuration of Clippy. By default, any configuration will replace the default value.
- (allow_renamed_params_for: Vec<String> =
- DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS.iter().map(ToString::to_string).collect()),
- /// Lint: MACRO_METAVARS_IN_UNSAFE.
+ #[lints(pub_underscore_fields)]
+ pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PubliclyExported,
+ /// Whether to lint only if it's multiline.
+ #[lints(semicolon_inside_block)]
+ semicolon_inside_block_ignore_singleline: bool = false,
+ /// Whether to lint only if it's singleline.
+ #[lints(semicolon_outside_block)]
+ semicolon_outside_block_ignore_multiline: bool = false,
+ /// The maximum number of single char bindings a scope may have
+ #[lints(many_single_char_names)]
+ single_char_binding_names_threshold: u64 = 4,
+ /// The maximum allowed stack size for functions in bytes
+ #[lints(large_stack_frames)]
+ stack_size_threshold: u64 = 512_000,
+ /// Enforce the named macros always use the braces specified.
///
+ /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
+ /// could be used with a full path two `MacroMatcher`s have to be added one with the full path
+ /// `crate_name::macro_name` and one with just the macro name.
+ #[lints(nonstandard_macro_braces)]
+ standard_macro_braces: Vec<MacroMatcher> = Vec::new(),
+ /// The minimum number of struct fields for the lints about field names to trigger
+ #[lints(struct_field_names)]
+ struct_field_name_threshold: u64 = 3,
+ /// Whether to suppress a restriction lint in constant code. In same
+ /// cases the restructured operation might not be unavoidable, as the
+ /// suggested counterparts are unavailable in constant code. This
+ /// configuration will cause restriction lints to trigger even
+ /// if no suggestion can be made.
+ #[lints(indexing_slicing)]
+ suppress_restriction_lint_in_const: bool = false,
+ /// The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+ #[lints(boxed_local, useless_vec)]
+ too_large_for_stack: u64 = 200,
+ /// The maximum number of argument a function or method can have
+ #[lints(too_many_arguments)]
+ too_many_arguments_threshold: u64 = 7,
+ /// The maximum number of lines a function or method can have
+ #[lints(too_many_lines)]
+ too_many_lines_threshold: u64 = 100,
+ /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by
+ /// reference. By default there is no limit
+ #[default_text = "target_pointer_width * 2"]
+ #[lints(trivially_copy_pass_by_ref)]
+ trivial_copy_size_limit: Option<u64> = None,
+ /// The maximum complexity a type can have
+ #[lints(type_complexity)]
+ type_complexity_threshold: u64 = 250,
+ /// The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
+ #[lints(unnecessary_box_returns)]
+ unnecessary_box_size: u64 = 128,
+ /// Should the fraction of a decimal be linted to include separators.
+ #[lints(unreadable_literal)]
+ unreadable_literal_lint_fractions: bool = true,
+ /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
+ #[lints(upper_case_acronyms)]
+ upper_case_acronyms_aggressive: bool = false,
+ /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
+ #[lints(vec_box)]
+ vec_box_size_threshold: u64 = 4096,
+ /// The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
+ #[lints(verbose_bit_mask)]
+ verbose_bit_mask_threshold: u64 = 1,
+ /// Whether to allow certain wildcard imports (prelude, super in tests).
+ #[lints(wildcard_imports)]
+ warn_on_all_wildcard_imports: bool = false,
/// Whether to also emit warnings for unsafe blocks with metavariable expansions in **private** macros.
- (warn_unsafe_macro_metavars_in_private_macros: bool = false),
+ #[lints(macro_metavars_in_unsafe)]
+ warn_unsafe_macro_metavars_in_private_macros: bool = false,
}
/// Search for the configuration file.
diff --git a/src/tools/clippy/clippy_config/src/lib.rs b/src/tools/clippy/clippy_config/src/lib.rs
index ff7fa7241cb96..d2246f12029b3 100644
--- a/src/tools/clippy/clippy_config/src/lib.rs
+++ b/src/tools/clippy/clippy_config/src/lib.rs
@@ -1,5 +1,4 @@
-#![feature(rustc_private, let_chains)]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+#![feature(rustc_private, array_windows, let_chains)]
#![warn(
trivial_casts,
trivial_numeric_casts,
diff --git a/src/tools/clippy/clippy_config/src/metadata.rs b/src/tools/clippy/clippy_config/src/metadata.rs
index 400887185e8cf..7cbd92a9b7100 100644
--- a/src/tools/clippy/clippy_config/src/metadata.rs
+++ b/src/tools/clippy/clippy_config/src/metadata.rs
@@ -1,11 +1,12 @@
-use std::fmt::{self, Write};
+use itertools::Itertools;
+use std::fmt;
#[derive(Debug, Clone, Default)]
pub struct ClippyConfiguration {
pub name: String,
pub default: String,
- pub lints: Vec<String>,
- pub doc: String,
+ pub lints: &'static [&'static str],
+ pub doc: &'static str,
pub deprecation_reason: Option<&'static str>,
}
@@ -13,61 +14,23 @@ impl fmt::Display for ClippyConfiguration {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "- `{}`: {}", self.name, self.doc)?;
if !self.default.is_empty() {
- write!(f, " (default: `{}`)", self.default)?;
+ write!(f, "\n\n (default: `{}`)", self.default)?;
}
Ok(())
}
}
impl ClippyConfiguration {
- pub fn new(
- name: &'static str,
- default: String,
- doc_comment: &'static str,
- deprecation_reason: Option<&'static str>,
- ) -> Self {
- let (mut lints, doc) = parse_config_field_doc(doc_comment)
- .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
-
- lints.sort();
-
- Self {
- name: to_kebab(name),
- lints,
- doc,
- default,
- deprecation_reason,
- }
- }
-
pub fn to_markdown_paragraph(&self) -> String {
- let mut out = format!(
- "## `{}`\n{}\n\n",
+ format!(
+ "## `{}`\n{}\n\n**Default Value:** `{}`\n\n---\n**Affected lints:**\n{}\n\n",
self.name,
- self.doc
- .lines()
- .map(|line| line.strip_prefix(" ").unwrap_or(line))
- .collect::<Vec<_>>()
- .join("\n"),
- );
-
- if !self.default.is_empty() {
- write!(out, "**Default Value:** `{}`\n\n", self.default).unwrap();
- }
-
- write!(
- out,
- "---\n**Affected lints:**\n{}\n\n",
- self.lints
- .iter()
- .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
- .map(|name| format!("* [`{name}`](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
- .collect::<Vec<_>>()
- .join("\n"),
+ self.doc.lines().map(|x| x.strip_prefix(' ').unwrap_or(x)).join("\n"),
+ self.default,
+ self.lints.iter().format_with("\n", |name, f| f(&format_args!(
+ "* [`{name}`](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"
+ ))),
)
- .unwrap();
-
- out
}
pub fn to_markdown_link(&self) -> String {
@@ -75,47 +38,3 @@ impl ClippyConfiguration {
format!("[`{}`]: {BOOK_CONFIGS_PATH}#{}", self.name, self.name)
}
}
-
-/// This parses the field documentation of the config struct.
-///
-/// ```rust, ignore
-/// parse_config_field_doc(cx, "Lint: LINT_NAME_1, LINT_NAME_2. Papa penguin, papa penguin")
-/// ```
-///
-/// Would yield:
-/// ```rust, ignore
-/// Some(["lint_name_1", "lint_name_2"], "Papa penguin, papa penguin")
-/// ```
-fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
- const DOC_START: &str = " Lint: ";
- if doc_comment.starts_with(DOC_START)
- && let Some(split_pos) = doc_comment.find('.')
- {
- let mut doc_comment = doc_comment.to_string();
- let mut documentation = doc_comment.split_off(split_pos);
-
- // Extract lints
- doc_comment.make_ascii_lowercase();
- let lints: Vec<String> = doc_comment
- .split_off(DOC_START.len())
- .lines()
- .next()
- .unwrap()
- .split(", ")
- .map(str::to_string)
- .collect();
-
- // Format documentation correctly
- // split off leading `.` from lint name list and indent for correct formatting
- documentation = documentation.trim_start_matches('.').trim().replace("\n ", "\n ");
-
- Some((lints, documentation))
- } else {
- None
- }
-}
-
-/// Transforms a given `snake_case_string` to a tasty `kebab-case-string`
-fn to_kebab(config_name: &str) -> String {
- config_name.replace('_', "-")
-}
diff --git a/src/tools/clippy/clippy_dev/Cargo.toml b/src/tools/clippy/clippy_dev/Cargo.toml
index 4104e7d94f146..a5d72c3a559df 100644
--- a/src/tools/clippy/clippy_dev/Cargo.toml
+++ b/src/tools/clippy/clippy_dev/Cargo.toml
@@ -13,9 +13,6 @@ opener = "0.6"
shell-escape = "0.1"
walkdir = "2.3"
-[features]
-deny-warnings = []
-
[package.metadata.rust-analyzer]
# This package uses #[feature(rustc_private)]
rustc_private = true
diff --git a/src/tools/clippy/clippy_dev/src/fmt.rs b/src/tools/clippy/clippy_dev/src/fmt.rs
index 2562314418172..5fc4365c6e785 100644
--- a/src/tools/clippy/clippy_dev/src/fmt.rs
+++ b/src/tools/clippy/clippy_dev/src/fmt.rs
@@ -1,30 +1,65 @@
use crate::clippy_project_root;
use itertools::Itertools;
+use rustc_lexer::{tokenize, TokenKind};
use shell_escape::escape;
use std::ffi::{OsStr, OsString};
-use std::path::Path;
+use std::ops::ControlFlow;
+use std::path::{Path, PathBuf};
use std::process::{self, Command, Stdio};
use std::{fs, io};
use walkdir::WalkDir;
-#[derive(Debug)]
-pub enum CliError {
+pub enum Error {
CommandFailed(String, String),
- IoError(io::Error),
+ Io(io::Error),
RustfmtNotInstalled,
- WalkDirError(walkdir::Error),
+ WalkDir(walkdir::Error),
IntellijSetupActive,
+ Parse(PathBuf, usize, String),
+ CheckFailed,
}
-impl From<io::Error> for CliError {
+impl From<io::Error> for Error {
fn from(error: io::Error) -> Self {
- Self::IoError(error)
+ Self::Io(error)
}
}
-impl From<walkdir::Error> for CliError {
+impl From<walkdir::Error> for Error {
fn from(error: walkdir::Error) -> Self {
- Self::WalkDirError(error)
+ Self::WalkDir(error)
+ }
+}
+
+impl Error {
+ fn display(&self) {
+ match self {
+ Self::CheckFailed => {
+ eprintln!("Formatting check failed!\nRun `cargo dev fmt` to update.");
+ },
+ Self::CommandFailed(command, stderr) => {
+ eprintln!("error: command `{command}` failed!\nstderr: {stderr}");
+ },
+ Self::Io(err) => {
+ eprintln!("error: {err}");
+ },
+ Self::RustfmtNotInstalled => {
+ eprintln!("error: rustfmt nightly is not installed.");
+ },
+ Self::WalkDir(err) => {
+ eprintln!("error: {err}");
+ },
+ Self::IntellijSetupActive => {
+ eprintln!(
+ "error: a local rustc repo is enabled as path dependency via `cargo dev setup intellij`.\n\
+ Not formatting because that would format the local repo as well!\n\
+ Please revert the changes to `Cargo.toml`s with `cargo dev remove intellij`."
+ );
+ },
+ Self::Parse(path, line, msg) => {
+ eprintln!("error parsing `{}:{line}`: {msg}", path.display());
+ },
+ }
}
}
@@ -34,75 +69,244 @@ struct FmtContext {
rustfmt_path: String,
}
-// the "main" function of cargo dev fmt
-pub fn run(check: bool, verbose: bool) {
- fn try_run(context: &FmtContext) -> Result<bool, CliError> {
- let mut success = true;
-
- let project_root = clippy_project_root();
-
- // if we added a local rustc repo as path dependency to clippy for rust analyzer, we do NOT want to
- // format because rustfmt would also format the entire rustc repo as it is a local
- // dependency
- if fs::read_to_string(project_root.join("Cargo.toml"))
- .expect("Failed to read clippy Cargo.toml")
- .contains("[target.'cfg(NOT_A_PLATFORM)'.dependencies]")
- {
- return Err(CliError::IntellijSetupActive);
- }
-
- rustfmt_test(context)?;
+struct ClippyConf<'a> {
+ name: &'a str,
+ attrs: &'a str,
+ lints: Vec<&'a str>,
+ field: &'a str,
+}
- success &= cargo_fmt(context, project_root.as_path())?;
- success &= cargo_fmt(context, &project_root.join("clippy_dev"))?;
- success &= cargo_fmt(context, &project_root.join("rustc_tools_util"))?;
- success &= cargo_fmt(context, &project_root.join("lintcheck"))?;
+fn offset_to_line(text: &str, offset: usize) -> usize {
+ match text.split('\n').try_fold((1usize, 0usize), |(line, pos), s| {
+ let pos = pos + s.len() + 1;
+ if pos > offset {
+ ControlFlow::Break(line)
+ } else {
+ ControlFlow::Continue((line + 1, pos))
+ }
+ }) {
+ ControlFlow::Break(x) | ControlFlow::Continue((x, _)) => x,
+ }
+}
- let chunks = WalkDir::new(project_root.join("tests"))
- .into_iter()
- .filter_map(|entry| {
- let entry = entry.expect("failed to find tests");
- let path = entry.path();
+/// Formats the configuration list in `clippy_config/src/conf.rs`
+#[expect(clippy::too_many_lines)]
+fn fmt_conf(check: bool) -> Result<(), Error> {
+ #[derive(Clone, Copy)]
+ enum State {
+ Start,
+ Docs,
+ Pound,
+ OpenBracket,
+ Attr(u32),
+ Lints,
+ EndLints,
+ Field,
+ }
- if path.extension() != Some("rs".as_ref()) || entry.file_name() == "ice-3891.rs" {
- None
- } else {
- Some(entry.into_path().into_os_string())
- }
- })
- .chunks(250);
+ let path: PathBuf = [
+ clippy_project_root().as_path(),
+ "clippy_config".as_ref(),
+ "src".as_ref(),
+ "conf.rs".as_ref(),
+ ]
+ .into_iter()
+ .collect();
+ let text = fs::read_to_string(&path)?;
- for chunk in &chunks {
- success &= rustfmt(context, chunk)?;
- }
+ let (pre, conf) = text
+ .split_once("define_Conf! {\n")
+ .expect("can't find config definition");
+ let (conf, post) = conf.split_once("\n}\n").expect("can't find config definition");
+ let conf_offset = pre.len() + 15;
- Ok(success)
- }
+ let mut pos = 0u32;
+ let mut attrs_start = 0;
+ let mut attrs_end = 0;
+ let mut field_start = 0;
+ let mut lints = Vec::new();
+ let mut name = "";
+ let mut fields = Vec::new();
+ let mut state = State::Start;
- fn output_err(err: CliError) {
- match err {
- CliError::CommandFailed(command, stderr) => {
- eprintln!("error: A command failed! `{command}`\nstderr: {stderr}");
+ for (i, t) in tokenize(conf)
+ .map(|x| {
+ let start = pos;
+ pos += x.len;
+ (start as usize, x)
+ })
+ .filter(|(_, t)| !matches!(t.kind, TokenKind::Whitespace))
+ {
+ match (state, t.kind) {
+ (State::Start, TokenKind::LineComment { doc_style: Some(_) }) => {
+ attrs_start = i;
+ attrs_end = i + t.len as usize;
+ state = State::Docs;
},
- CliError::IoError(err) => {
- eprintln!("error: {err}");
+ (State::Start, TokenKind::Pound) => {
+ attrs_start = i;
+ attrs_end = i;
+ state = State::Pound;
},
- CliError::RustfmtNotInstalled => {
- eprintln!("error: rustfmt nightly is not installed.");
+ (State::Docs, TokenKind::LineComment { doc_style: Some(_) }) => attrs_end = i + t.len as usize,
+ (State::Docs, TokenKind::Pound) => state = State::Pound,
+ (State::Pound, TokenKind::OpenBracket) => state = State::OpenBracket,
+ (State::OpenBracket, TokenKind::Ident) => {
+ state = if conf[i..i + t.len as usize] == *"lints" {
+ State::Lints
+ } else {
+ State::Attr(0)
+ };
},
- CliError::WalkDirError(err) => {
- eprintln!("error: {err}");
+ (State::Attr(0), TokenKind::CloseBracket) => {
+ attrs_end = i + 1;
+ state = State::Docs;
},
- CliError::IntellijSetupActive => {
- eprintln!(
- "error: a local rustc repo is enabled as path dependency via `cargo dev setup intellij`.
-Not formatting because that would format the local repo as well!
-Please revert the changes to Cargo.tomls with `cargo dev remove intellij`."
- );
+ (State::Attr(x), TokenKind::OpenParen | TokenKind::OpenBracket | TokenKind::OpenBrace) => {
+ state = State::Attr(x + 1);
+ },
+ (State::Attr(x), TokenKind::CloseParen | TokenKind::CloseBracket | TokenKind::CloseBrace) => {
+ state = State::Attr(x - 1);
+ },
+ (State::Lints, TokenKind::Ident) => lints.push(&conf[i..i + t.len as usize]),
+ (State::Lints, TokenKind::CloseBracket) => state = State::EndLints,
+ (State::EndLints | State::Docs, TokenKind::Ident) => {
+ field_start = i;
+ name = &conf[i..i + t.len as usize];
+ state = State::Field;
+ },
+ (State::Field, TokenKind::LineComment { doc_style: Some(_) }) => {
+ #[expect(clippy::drain_collect)]
+ fields.push(ClippyConf {
+ name,
+ lints: lints.drain(..).collect(),
+ attrs: &conf[attrs_start..attrs_end],
+ field: conf[field_start..i].trim_end(),
+ });
+ attrs_start = i;
+ attrs_end = i + t.len as usize;
+ state = State::Docs;
+ },
+ (State::Field, TokenKind::Pound) => {
+ #[expect(clippy::drain_collect)]
+ fields.push(ClippyConf {
+ name,
+ lints: lints.drain(..).collect(),
+ attrs: &conf[attrs_start..attrs_end],
+ field: conf[field_start..i].trim_end(),
+ });
+ attrs_start = i;
+ attrs_end = i;
+ state = State::Pound;
+ },
+ (State::Field | State::Attr(_), _)
+ | (State::Lints, TokenKind::Comma | TokenKind::OpenParen | TokenKind::CloseParen) => {},
+ _ => {
+ return Err(Error::Parse(
+ path,
+ offset_to_line(&text, conf_offset + i),
+ format!("unexpected token `{}`", &conf[i..i + t.len as usize]),
+ ));
},
}
}
+ if !matches!(state, State::Field) {
+ return Err(Error::Parse(
+ path,
+ offset_to_line(&text, conf_offset + conf.len()),
+ "incomplete field".into(),
+ ));
+ }
+ fields.push(ClippyConf {
+ name,
+ lints,
+ attrs: &conf[attrs_start..attrs_end],
+ field: conf[field_start..].trim_end(),
+ });
+
+ for field in &mut fields {
+ field.lints.sort_unstable();
+ }
+ fields.sort_by_key(|x| x.name);
+
+ let new_text = format!(
+ "{pre}define_Conf! {{\n{}}}\n{post}",
+ fields.iter().format_with("", |field, f| {
+ if field.lints.is_empty() {
+ f(&format_args!(" {}\n {}\n", field.attrs, field.field))
+ } else if field.lints.iter().map(|x| x.len() + 2).sum::<usize>() < 120 - 14 {
+ f(&format_args!(
+ " {}\n #[lints({})]\n {}\n",
+ field.attrs,
+ field.lints.iter().join(", "),
+ field.field,
+ ))
+ } else {
+ f(&format_args!(
+ " {}\n #[lints({}\n )]\n {}\n",
+ field.attrs,
+ field
+ .lints
+ .iter()
+ .format_with("", |x, f| f(&format_args!("\n {x},"))),
+ field.field,
+ ))
+ }
+ })
+ );
+
+ if text != new_text {
+ if check {
+ return Err(Error::CheckFailed);
+ }
+ fs::write(&path, new_text.as_bytes())?;
+ }
+ Ok(())
+}
+
+fn run_rustfmt(context: &FmtContext) -> Result<(), Error> {
+ let project_root = clippy_project_root();
+
+ // if we added a local rustc repo as path dependency to clippy for rust analyzer, we do NOT want to
+ // format because rustfmt would also format the entire rustc repo as it is a local
+ // dependency
+ if fs::read_to_string(project_root.join("Cargo.toml"))
+ .expect("Failed to read clippy Cargo.toml")
+ .contains("[target.'cfg(NOT_A_PLATFORM)'.dependencies]")
+ {
+ return Err(Error::IntellijSetupActive);
+ }
+
+ check_for_rustfmt(context)?;
+
+ cargo_fmt(context, project_root.as_path())?;
+ cargo_fmt(context, &project_root.join("clippy_dev"))?;
+ cargo_fmt(context, &project_root.join("rustc_tools_util"))?;
+ cargo_fmt(context, &project_root.join("lintcheck"))?;
+
+ let chunks = WalkDir::new(project_root.join("tests"))
+ .into_iter()
+ .filter_map(|entry| {
+ let entry = entry.expect("failed to find tests");
+ let path = entry.path();
+
+ if path.extension() != Some("rs".as_ref()) || entry.file_name() == "ice-3891.rs" {
+ None
+ } else {
+ Some(entry.into_path().into_os_string())
+ }
+ })
+ .chunks(250);
+
+ for chunk in &chunks {
+ rustfmt(context, chunk)?;
+ }
+ Ok(())
+}
+
+// the "main" function of cargo dev fmt
+pub fn run(check: bool, verbose: bool) {
let output = Command::new("rustup")
.args(["which", "rustfmt"])
.stderr(Stdio::inherit())
@@ -120,21 +324,10 @@ Please revert the changes to Cargo.tomls with `cargo dev remove intellij`."
verbose,
rustfmt_path,
};
- let result = try_run(&context);
- let code = match result {
- Ok(true) => 0,
- Ok(false) => {
- eprintln!();
- eprintln!("Formatting check failed.");
- eprintln!("Run `cargo dev fmt` to update formatting.");
- 1
- },
- Err(err) => {
- output_err(err);
- 1
- },
- };
- process::exit(code);
+ if let Err(e) = run_rustfmt(&context).and_then(|()| fmt_conf(check)) {
+ e.display();
+ process::exit(1);
+ }
}
fn format_command(program: impl AsRef<OsStr>, dir: impl AsRef<Path>, args: &[impl AsRef<OsStr>]) -> String {
@@ -148,12 +341,12 @@ fn format_command(program: impl AsRef<OsStr>, dir: impl AsRef<Path>, args: &[imp
)
}
-fn exec(
+fn exec_fmt_command(
context: &FmtContext,
program: impl AsRef<OsStr>,
dir: impl AsRef<Path>,
args: &[impl AsRef<OsStr>],
-) -> Result<bool, CliError> {
+) -> Result<(), Error> {
if context.verbose {
println!("{}", format_command(&program, &dir, args));
}
@@ -166,28 +359,28 @@ fn exec(
.unwrap();
let success = output.status.success();
- if !context.check && !success {
- let stderr = std::str::from_utf8(&output.stderr).unwrap_or("");
- return Err(CliError::CommandFailed(
- format_command(&program, &dir, args),
- String::from(stderr),
- ));
+ match (context.check, success) {
+ (_, true) => Ok(()),
+ (true, false) => Err(Error::CheckFailed),
+ (false, false) => {
+ let stderr = std::str::from_utf8(&output.stderr).unwrap_or("");
+ Err(Error::CommandFailed(
+ format_command(&program, &dir, args),
+ String::from(stderr),
+ ))
+ },
}
-
- Ok(success)
}
-fn cargo_fmt(context: &FmtContext, path: &Path) -> Result<bool, CliError> {
+fn cargo_fmt(context: &FmtContext, path: &Path) -> Result<(), Error> {
let mut args = vec!["fmt", "--all"];
if context.check {
args.push("--check");
}
- let success = exec(context, "cargo", path, &args)?;
-
- Ok(success)
+ exec_fmt_command(context, "cargo", path, &args)
}
-fn rustfmt_test(context: &FmtContext) -> Result<(), CliError> {
+fn check_for_rustfmt(context: &FmtContext) -> Result<(), Error> {
let program = "rustfmt";
let dir = std::env::current_dir()?;
let args = &["--version"];
@@ -204,23 +397,20 @@ fn rustfmt_test(context: &FmtContext) -> Result<(), CliError> {
.unwrap_or("")
.starts_with("error: 'rustfmt' is not installed")
{
- Err(CliError::RustfmtNotInstalled)
+ Err(Error::RustfmtNotInstalled)
} else {
- Err(CliError::CommandFailed(
+ Err(Error::CommandFailed(
format_command(program, &dir, args),
std::str::from_utf8(&output.stderr).unwrap_or("").to_string(),
))
}
}
-fn rustfmt(context: &FmtContext, paths: impl Iterator<Item = OsString>) -> Result<bool, CliError> {
+fn rustfmt(context: &FmtContext, paths: impl Iterator<Item = OsString>) -> Result<(), Error> {
let mut args = Vec::new();
if context.check {
args.push(OsString::from("--check"));
}
args.extend(paths);
-
- let success = exec(context, &context.rustfmt_path, std::env::current_dir()?, &args)?;
-
- Ok(success)
+ exec_fmt_command(context, &context.rustfmt_path, std::env::current_dir()?, &args)
}
diff --git a/src/tools/clippy/clippy_dev/src/lib.rs b/src/tools/clippy/clippy_dev/src/lib.rs
index 3aa43dbe23ed6..ad385d5fbd29f 100644
--- a/src/tools/clippy/clippy_dev/src/lib.rs
+++ b/src/tools/clippy/clippy_dev/src/lib.rs
@@ -1,6 +1,5 @@
#![feature(let_chains)]
#![feature(rustc_private)]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(
trivial_casts,
trivial_numeric_casts,
diff --git a/src/tools/clippy/clippy_dev/src/main.rs b/src/tools/clippy/clippy_dev/src/main.rs
index 366b52b25dfcf..755b04b0b232f 100644
--- a/src/tools/clippy/clippy_dev/src/main.rs
+++ b/src/tools/clippy/clippy_dev/src/main.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
// warn on lints, that are included in `rust-lang/rust`s bootstrap
#![warn(rust_2018_idioms, unused_lifetimes)]
@@ -74,7 +73,7 @@ fn main() {
new_name,
uplift,
} => update_lints::rename(&old_name, new_name.as_ref().unwrap_or(&old_name), uplift),
- DevCommand::Deprecate { name, reason } => update_lints::deprecate(&name, reason.as_deref()),
+ DevCommand::Deprecate { name, reason } => update_lints::deprecate(&name, &reason),
}
}
@@ -223,7 +222,7 @@ enum DevCommand {
name: String,
#[arg(long, short)]
/// The reason for deprecation
- reason: Option<String>,
+ reason: String,
},
}
diff --git a/src/tools/clippy/clippy_dev/src/serve.rs b/src/tools/clippy/clippy_dev/src/serve.rs
index 4a4261d1a1e63..19560b31fd3e2 100644
--- a/src/tools/clippy/clippy_dev/src/serve.rs
+++ b/src/tools/clippy/clippy_dev/src/serve.rs
@@ -1,10 +1,14 @@
-use std::ffi::OsStr;
-use std::num::ParseIntError;
use std::path::Path;
use std::process::Command;
use std::time::{Duration, SystemTime};
use std::{env, thread};
+#[cfg(windows)]
+const PYTHON: &str = "python";
+
+#[cfg(not(windows))]
+const PYTHON: &str = "python3";
+
/// # Panics
///
/// Panics if the python commands could not be spawned
@@ -25,7 +29,7 @@ pub fn run(port: u16, lint: Option<String>) -> ! {
}
if let Some(url) = url.take() {
thread::spawn(move || {
- Command::new("python3")
+ Command::new(PYTHON)
.arg("-m")
.arg("http.server")
.arg(port.to_string())
@@ -58,8 +62,3 @@ fn mtime(path: impl AsRef<Path>) -> SystemTime {
.unwrap_or(SystemTime::UNIX_EPOCH)
}
}
-
-#[allow(clippy::missing_errors_doc)]
-pub fn validate_port(arg: &OsStr) -> Result<(), ParseIntError> {
- arg.to_string_lossy().parse::<u16>().map(|_| ())
-}
diff --git a/src/tools/clippy/clippy_dev/src/update_lints.rs b/src/tools/clippy/clippy_dev/src/update_lints.rs
index 45353901c98fd..15578d69c3a9d 100644
--- a/src/tools/clippy/clippy_dev/src/update_lints.rs
+++ b/src/tools/clippy/clippy_dev/src/update_lints.rs
@@ -1,13 +1,12 @@
use crate::clippy_project_root;
use aho_corasick::AhoCorasickBuilder;
-use indoc::writedoc;
use itertools::Itertools;
use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
use std::collections::{HashMap, HashSet};
use std::ffi::OsStr;
use std::fmt::{self, Write};
use std::fs::{self, OpenOptions};
-use std::io::{self, Read, Seek, SeekFrom, Write as _};
+use std::io::{self, Read, Seek, Write as _};
use std::ops::Range;
use std::path::{Path, PathBuf};
use walkdir::{DirEntry, WalkDir};
@@ -77,12 +76,8 @@ fn generate_lint_files(
for lint in usable_lints
.iter()
.map(|l| &*l.name)
- .chain(deprecated_lints.iter().map(|l| &*l.name))
- .chain(
- renamed_lints
- .iter()
- .map(|l| l.old_name.strip_prefix("clippy::").unwrap_or(&l.old_name)),
- )
+ .chain(deprecated_lints.iter().filter_map(|l| l.name.strip_prefix("clippy::")))
+ .chain(renamed_lints.iter().filter_map(|l| l.old_name.strip_prefix("clippy::")))
.sorted()
{
writeln!(res, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
@@ -108,11 +103,6 @@ fn generate_lint_files(
update_mode,
&gen_declared_lints(internal_lints.iter(), usable_lints.iter()),
);
- process_file(
- "clippy_lints/src/lib.deprecated.rs",
- update_mode,
- &gen_deprecated(deprecated_lints),
- );
let content = gen_deprecated_lints_test(deprecated_lints);
process_file("tests/ui/deprecated.rs", update_mode, &content);
@@ -205,7 +195,7 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
let ext = f.path().extension();
(ext == Some(OsStr::new("rs")) || ext == Some(OsStr::new("fixed")))
&& name != Some(OsStr::new("rename.rs"))
- && name != Some(OsStr::new("renamed_lints.rs"))
+ && name != Some(OsStr::new("deprecated_lints.rs"))
})
{
rewrite_file(file.path(), |s| {
@@ -213,6 +203,19 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
});
}
+ let version = crate::new_lint::get_stabilization_version();
+ rewrite_file(Path::new("clippy_lints/src/deprecated_lints.rs"), |s| {
+ insert_at_marker(
+ s,
+ "// end renamed lints. used by `cargo dev rename_lint`",
+ &format!(
+ "#[clippy::version = \"{version}\"]\n \
+ (\"{}\", \"{}\"),\n ",
+ lint.old_name, lint.new_name,
+ ),
+ )
+ });
+
renamed_lints.push(lint);
renamed_lints.sort_by(|lhs, rhs| {
lhs.new_name
@@ -222,11 +225,6 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
.then_with(|| lhs.old_name.cmp(&rhs.old_name))
});
- write_file(
- Path::new("clippy_lints/src/renamed_lints.rs"),
- &gen_renamed_lints_list(&renamed_lints),
- );
-
if uplift {
write_file(Path::new("tests/ui/rename.rs"), &gen_renamed_lints_test(&renamed_lints));
println!(
@@ -293,7 +291,8 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
// Don't change `clippy_utils/src/renamed_lints.rs` here as it would try to edit the lint being
// renamed.
- for (_, file) in clippy_lints_src_files().filter(|(rel_path, _)| rel_path != OsStr::new("renamed_lints.rs")) {
+ for (_, file) in clippy_lints_src_files().filter(|(rel_path, _)| rel_path != OsStr::new("deprecated_lints.rs"))
+ {
rewrite_file(file.path(), |s| replace_ident_like(s, replacements));
}
@@ -304,7 +303,6 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
println!("note: `cargo uitest` still needs to be run to update the test results");
}
-const DEFAULT_DEPRECATION_REASON: &str = "default deprecation note";
/// Runs the `deprecate` command
///
/// This does the following:
@@ -314,33 +312,16 @@ const DEFAULT_DEPRECATION_REASON: &str = "default deprecation note";
/// # Panics
///
/// If a file path could not read from or written to
-pub fn deprecate(name: &str, reason: Option<&str>) {
- fn finish(
- (lints, mut deprecated_lints, renamed_lints): (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>),
- name: &str,
- reason: &str,
- ) {
- deprecated_lints.push(DeprecatedLint {
- name: name.to_string(),
- reason: reason.to_string(),
- declaration_range: Range::default(),
- });
-
- generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
- println!("info: `{name}` has successfully been deprecated");
-
- if reason == DEFAULT_DEPRECATION_REASON {
- println!("note: the deprecation reason must be updated in `clippy_lints/src/deprecated_lints.rs`");
- }
- println!("note: you must run `cargo uitest` to update the test results");
- }
-
- let reason = reason.unwrap_or(DEFAULT_DEPRECATION_REASON);
- let name_lower = name.to_lowercase();
- let name_upper = name.to_uppercase();
+pub fn deprecate(name: &str, reason: &str) {
+ let prefixed_name = if name.starts_with("clippy::") {
+ name.to_owned()
+ } else {
+ format!("clippy::{name}")
+ };
+ let stripped_name = &prefixed_name[8..];
- let (mut lints, deprecated_lints, renamed_lints) = gather_all();
- let Some(lint) = lints.iter().find(|l| l.name == name_lower) else {
+ let (mut lints, mut deprecated_lints, renamed_lints) = gather_all();
+ let Some(lint) = lints.iter().find(|l| l.name == stripped_name) else {
eprintln!("error: failed to find lint `{name}`");
return;
};
@@ -357,13 +338,27 @@ pub fn deprecate(name: &str, reason: Option<&str>) {
let deprecated_lints_path = &*clippy_project_root().join("clippy_lints/src/deprecated_lints.rs");
- if remove_lint_declaration(&name_lower, &mod_path, &mut lints).unwrap_or(false) {
- declare_deprecated(&name_upper, deprecated_lints_path, reason).unwrap();
- finish((lints, deprecated_lints, renamed_lints), name, reason);
- return;
- }
+ if remove_lint_declaration(stripped_name, &mod_path, &mut lints).unwrap_or(false) {
+ let version = crate::new_lint::get_stabilization_version();
+ rewrite_file(deprecated_lints_path, |s| {
+ insert_at_marker(
+ s,
+ "// end deprecated lints. used by `cargo dev deprecate_lint`",
+ &format!("#[clippy::version = \"{version}\"]\n (\"{prefixed_name}\", \"{reason}\"),\n ",),
+ )
+ });
+
+ deprecated_lints.push(DeprecatedLint {
+ name: prefixed_name,
+ reason: reason.into(),
+ });
- eprintln!("error: lint not found");
+ generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
+ println!("info: `{name}` has successfully been deprecated");
+ println!("note: you must run `cargo uitest` to update the test results");
+ } else {
+ eprintln!("error: lint not found");
+ }
}
fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io::Result<bool> {
@@ -377,14 +372,14 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
// Some lints have their own directories, delete them
if path.is_dir() {
- fs::remove_dir_all(path).ok();
+ let _ = fs::remove_dir_all(path);
return;
}
// Remove all related test files
- fs::remove_file(path.with_extension("rs")).ok();
- fs::remove_file(path.with_extension("stderr")).ok();
- fs::remove_file(path.with_extension("fixed")).ok();
+ let _ = fs::remove_file(path.with_extension("rs"));
+ let _ = fs::remove_file(path.with_extension("stderr"));
+ let _ = fs::remove_file(path.with_extension("fixed"));
}
fn remove_impl_lint_pass(lint_name_upper: &str, content: &mut String) {
@@ -427,7 +422,7 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
lint_mod_path.set_file_name(name);
lint_mod_path.set_extension("rs");
- fs::remove_file(lint_mod_path).ok();
+ let _ = fs::remove_file(lint_mod_path);
}
let mut content =
@@ -465,37 +460,6 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
Ok(false)
}
-fn declare_deprecated(name: &str, path: &Path, reason: &str) -> io::Result<()> {
- let mut file = OpenOptions::new().write(true).open(path)?;
-
- file.seek(SeekFrom::End(0))?;
-
- let version = crate::new_lint::get_stabilization_version();
- let deprecation_reason = if reason == DEFAULT_DEPRECATION_REASON {
- "TODO"
- } else {
- reason
- };
-
- writedoc!(
- file,
- "
-
- declare_deprecated_lint! {{
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// {deprecation_reason}
- #[clippy::version = \"{version}\"]
- pub {name},
- \"{reason}\"
- }}
-
- "
- )
-}
-
/// Replace substrings if they aren't bordered by identifier characters. Returns `None` if there
/// were no replacements.
fn replace_ident_like(contents: &str, replacements: &[(&str, &str)]) -> Option<String> {
@@ -604,14 +568,12 @@ impl Lint {
struct DeprecatedLint {
name: String,
reason: String,
- declaration_range: Range<usize>,
}
impl DeprecatedLint {
- fn new(name: &str, reason: &str, declaration_range: Range<usize>) -> Self {
+ fn new(name: &str, reason: &str) -> Self {
Self {
- name: name.to_lowercase(),
+ name: remove_line_splices(name),
reason: remove_line_splices(reason),
- declaration_range,
}
}
}
@@ -629,28 +591,6 @@ impl RenamedLint {
}
}
-/// Generates the `register_removed` code
-#[must_use]
-fn gen_deprecated(lints: &[DeprecatedLint]) -> String {
- let mut output = GENERATED_FILE_COMMENT.to_string();
- output.push_str("{\n");
- for lint in lints {
- let _: fmt::Result = write!(
- output,
- concat!(
- " store.register_removed(\n",
- " \"clippy::{}\",\n",
- " \"{}\",\n",
- " );\n"
- ),
- lint.name, lint.reason,
- );
- }
- output.push_str("}\n");
-
- output
-}
-
/// Generates the code for registering lints
#[must_use]
fn gen_declared_lints<'a>(
@@ -680,7 +620,7 @@ fn gen_declared_lints<'a>(
fn gen_deprecated_lints_test(lints: &[DeprecatedLint]) -> String {
let mut res: String = GENERATED_FILE_COMMENT.into();
for lint in lints {
- writeln!(res, "#![warn(clippy::{})]", lint.name).unwrap();
+ writeln!(res, "#![warn({})] //~ ERROR: lint `{}`", lint.name, lint.name).unwrap();
}
res.push_str("\nfn main() {}\n");
res
@@ -699,27 +639,13 @@ fn gen_renamed_lints_test(lints: &[RenamedLint]) -> String {
seen_lints.clear();
for lint in lints {
if seen_lints.insert(&lint.old_name) {
- writeln!(res, "#![warn({})]", lint.old_name).unwrap();
+ writeln!(res, "#![warn({})] //~ ERROR: lint `{}`", lint.old_name, lint.old_name).unwrap();
}
}
res.push_str("\nfn main() {}\n");
res
}
-fn gen_renamed_lints_list(lints: &[RenamedLint]) -> String {
- const HEADER: &str = "\
- // This file is managed by `cargo dev rename_lint`. Prefer using that when possible.\n\n\
- #[rustfmt::skip]\n\
- pub static RENAMED_LINTS: &[(&str, &str)] = &[\n";
-
- let mut res = String::from(HEADER);
- for lint in lints {
- writeln!(res, " (\"{}\", \"{}\"),", lint.old_name, lint.new_name).unwrap();
- }
- res.push_str("];\n");
- res
-}
-
/// Gathers all lints defined in `clippy_lints/src`
fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>) {
let mut lints = Vec::with_capacity(1000);
@@ -744,10 +670,10 @@ fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>) {
module.strip_suffix(".rs").unwrap_or(&module)
};
- match module {
- "deprecated_lints" => parse_deprecated_contents(&contents, &mut deprecated_lints),
- "renamed_lints" => parse_renamed_contents(&contents, &mut renamed_lints),
- _ => parse_contents(&contents, module, &mut lints),
+ if module == "deprecated_lints" {
+ parse_deprecated_contents(&contents, &mut deprecated_lints, &mut renamed_lints);
+ } else {
+ parse_contents(&contents, module, &mut lints);
}
}
(lints, deprecated_lints, renamed_lints)
@@ -848,54 +774,37 @@ fn parse_contents(contents: &str, module: &str, lints: &mut Vec<Lint>) {
}
/// Parse a source file looking for `declare_deprecated_lint` macro invocations.
-fn parse_deprecated_contents(contents: &str, lints: &mut Vec<DeprecatedLint>) {
- let mut offset = 0usize;
- let mut iter = tokenize(contents).map(|t| {
- let range = offset..offset + t.len as usize;
- offset = range.end;
-
- LintDeclSearchResult {
- token_kind: t.kind,
- content: &contents[range.clone()],
- range,
- }
- });
+fn parse_deprecated_contents(contents: &str, deprecated: &mut Vec<DeprecatedLint>, renamed: &mut Vec<RenamedLint>) {
+ let Some((_, contents)) = contents.split_once("\ndeclare_with_version! { DEPRECATED") else {
+ return;
+ };
+ let Some((deprecated_src, renamed_src)) = contents.split_once("\ndeclare_with_version! { RENAMED") else {
+ return;
+ };
- while let Some(LintDeclSearchResult { range, .. }) = iter.find(
- |LintDeclSearchResult {
- token_kind, content, ..
- }| token_kind == &TokenKind::Ident && *content == "declare_deprecated_lint",
- ) {
- let start = range.start;
+ for line in deprecated_src.lines() {
+ let mut offset = 0usize;
+ let mut iter = tokenize(line).map(|t| {
+ let range = offset..offset + t.len as usize;
+ offset = range.end;
- let mut iter = iter.by_ref().filter(|LintDeclSearchResult { ref token_kind, .. }| {
- !matches!(token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. })
+ LintDeclSearchResult {
+ token_kind: t.kind,
+ content: &line[range.clone()],
+ range,
+ }
});
+
let (name, reason) = match_tokens!(
iter,
- // !{
- Bang OpenBrace
- // #[clippy::version = "version"]
- Pound OpenBracket Ident Colon Colon Ident Eq Literal{..} CloseBracket
- // pub LINT_NAME,
- Ident Ident(name) Comma
- // "description"
- Literal{kind: LiteralKind::Str{..},..}(reason)
+ // ("old_name",
+ Whitespace OpenParen Literal{kind: LiteralKind::Str{..},..}(name) Comma
+ // "new_name"),
+ Whitespace Literal{kind: LiteralKind::Str{..},..}(reason) CloseParen Comma
);
-
- if let Some(LintDeclSearchResult {
- token_kind: TokenKind::CloseBrace,
- range,
- ..
- }) = iter.next()
- {
- lints.push(DeprecatedLint::new(name, reason, start..range.end));
- }
+ deprecated.push(DeprecatedLint::new(name, reason));
}
-}
-
-fn parse_renamed_contents(contents: &str, lints: &mut Vec<RenamedLint>) {
- for line in contents.lines() {
+ for line in renamed_src.lines() {
let mut offset = 0usize;
let mut iter = tokenize(line).map(|t| {
let range = offset..offset + t.len as usize;
@@ -915,7 +824,7 @@ fn parse_renamed_contents(contents: &str, lints: &mut Vec<RenamedLint>) {
// "new_name"),
Whitespace Literal{kind: LiteralKind::Str{..},..}(new_name) CloseParen Comma
);
- lints.push(RenamedLint::new(old_name, new_name));
+ renamed.push(RenamedLint::new(old_name, new_name));
}
}
@@ -1015,6 +924,12 @@ fn panic_file(error: io::Error, name: &Path, action: &str) -> ! {
panic!("failed to {action} file `{}`: {error}", name.display())
}
+fn insert_at_marker(text: &str, marker: &str, new_text: &str) -> Option<String> {
+ let i = text.find(marker)?;
+ let (pre, post) = text.split_at(i);
+ Some([pre, new_text, post].into_iter().collect())
+}
+
fn rewrite_file(path: &Path, f: impl FnOnce(&str) -> Option<String>) {
let mut file = OpenOptions::new()
.write(true)
@@ -1084,31 +999,6 @@ mod tests {
assert_eq!(expected, result);
}
- #[test]
- fn test_parse_deprecated_contents() {
- static DEPRECATED_CONTENTS: &str = r#"
- /// some doc comment
- declare_deprecated_lint! {
- #[clippy::version = "I'm a version"]
- pub SHOULD_ASSERT_EQ,
- "`assert!()` will be more flexible with RFC 2011"
- }
- "#;
-
- let mut result = Vec::new();
- parse_deprecated_contents(DEPRECATED_CONTENTS, &mut result);
- for r in &mut result {
- r.declaration_range = Range::default();
- }
-
- let expected = vec![DeprecatedLint::new(
- "should_assert_eq",
- "\"`assert!()` will be more flexible with RFC 2011\"",
- Range::default(),
- )];
- assert_eq!(expected, result);
- }
-
#[test]
fn test_usable_lints() {
let lints = vec![
@@ -1177,34 +1067,4 @@ mod tests {
);
assert_eq!(expected, Lint::by_lint_group(lints.into_iter()));
}
-
- #[test]
- fn test_gen_deprecated() {
- let lints = vec![
- DeprecatedLint::new(
- "should_assert_eq",
- "\"has been superseded by should_assert_eq2\"",
- Range::default(),
- ),
- DeprecatedLint::new("another_deprecated", "\"will be removed\"", Range::default()),
- ];
-
- let expected = GENERATED_FILE_COMMENT.to_string()
- + &[
- "{",
- " store.register_removed(",
- " \"clippy::should_assert_eq\",",
- " \"has been superseded by should_assert_eq2\",",
- " );",
- " store.register_removed(",
- " \"clippy::another_deprecated\",",
- " \"will be removed\",",
- " );",
- "}",
- ]
- .join("\n")
- + "\n";
-
- assert_eq!(expected, gen_deprecated(&lints));
- }
}
diff --git a/src/tools/clippy/clippy_lints/Cargo.toml b/src/tools/clippy/clippy_lints/Cargo.toml
index eb04c006f89fd..99ed93468a01a 100644
--- a/src/tools/clippy/clippy_lints/Cargo.toml
+++ b/src/tools/clippy/clippy_lints/Cargo.toml
@@ -32,7 +32,6 @@ url = "2.2"
walkdir = "2.3"
[features]
-deny-warnings = ["clippy_config/deny-warnings", "clippy_utils/deny-warnings"]
# build clippy with internal lints enabled, off by default
internal = ["serde_json", "tempfile", "regex"]
diff --git a/src/tools/clippy/clippy_lints/src/approx_const.rs b/src/tools/clippy/clippy_lints/src/approx_const.rs
index e6d52bcef717c..3b4cc1134802d 100644
--- a/src/tools/clippy/clippy_lints/src/approx_const.rs
+++ b/src/tools/clippy/clippy_lints/src/approx_const.rs
@@ -97,7 +97,7 @@ impl ApproxConstant {
cx,
APPROX_CONSTANT,
e.span,
- format!("approximate value of `{module}::consts::{}` found", &name),
+ format!("approximate value of `{module}::consts::{name}` found"),
None,
"consider using the constant directly",
);
diff --git a/src/tools/clippy/clippy_lints/src/as_conversions.rs b/src/tools/clippy/clippy_lints/src/as_conversions.rs
index cfa25005a05ed..fefd8195f8e7e 100644
--- a/src/tools/clippy/clippy_lints/src/as_conversions.rs
+++ b/src/tools/clippy/clippy_lints/src/as_conversions.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_from_proc_macro;
use rustc_hir::{Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -52,13 +52,15 @@ impl<'tcx> LateLintPass<'tcx> for AsConversions {
&& !in_external_macro(cx.sess(), expr.span)
&& !is_from_proc_macro(cx, expr)
{
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
AS_CONVERSIONS,
expr.span,
"using a potentially dangerous silent `as` conversion",
- None,
- "consider using a safe wrapper for this conversion",
+ |diag| {
+ diag.help("consider using a safe wrapper for this conversion");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/asm_syntax.rs b/src/tools/clippy/clippy_lints/src/asm_syntax.rs
index 0db1456d40bfc..69a8eb7d94e74 100644
--- a/src/tools/clippy/clippy_lints/src/asm_syntax.rs
+++ b/src/tools/clippy/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);
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/assertions_on_constants.rs b/src/tools/clippy/clippy_lints/src/assertions_on_constants.rs
index ed4cdce8cb886..7eaac80f969f7 100644
--- a/src/tools/clippy/clippy_lints/src/assertions_on_constants.rs
+++ b/src/tools/clippy/clippy_lints/src/assertions_on_constants.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_help;
use clippy_utils::is_inside_always_const_context;
use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
@@ -43,7 +43,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
let Some((condition, panic_expn)) = find_assert_args(cx, e, macro_call.expn) else {
return;
};
- let Some(Constant::Bool(val)) = constant(cx, cx.typeck_results(), condition) else {
+ let Some(Constant::Bool(val)) = ConstEvalCtxt::new(cx).eval(condition) else {
return;
};
diff --git a/src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs b/src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs
index 7217686dcca5b..f1cb4a05af86c 100644
--- a/src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs
+++ b/src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
use clippy_utils::source::snippet_with_context;
use clippy_utils::ty::{has_debug_impl, is_copy, is_type_diagnostic_item};
@@ -68,39 +68,28 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
return;
}
}
- let semicolon = if is_expr_final_block_expr(cx.tcx, e) { ";" } else { "" };
- let mut app = Applicability::MachineApplicable;
- match method_segment.ident.as_str() {
+ let (message, replacement) = match method_segment.ident.as_str() {
"is_ok" if type_suitable_to_unwrap(cx, args.type_at(1)) => {
- span_lint_and_sugg(
- cx,
- ASSERTIONS_ON_RESULT_STATES,
- macro_call.span,
- "called `assert!` with `Result::is_ok`",
- "replace with",
- format!(
- "{}.unwrap(){semicolon}",
- snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
- ),
- app,
- );
+ ("called `assert!` with `Result::is_ok`", "unwrap")
},
"is_err" if type_suitable_to_unwrap(cx, args.type_at(0)) => {
- span_lint_and_sugg(
- cx,
- ASSERTIONS_ON_RESULT_STATES,
- macro_call.span,
- "called `assert!` with `Result::is_err`",
- "replace with",
- format!(
- "{}.unwrap_err(){semicolon}",
- snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
- ),
- app,
- );
+ ("called `assert!` with `Result::is_err`", "unwrap_err")
},
- _ => (),
+ _ => return,
};
+ span_lint_and_then(cx, ASSERTIONS_ON_RESULT_STATES, macro_call.span, message, |diag| {
+ let semicolon = if is_expr_final_block_expr(cx.tcx, e) { ";" } else { "" };
+ let mut app = Applicability::MachineApplicable;
+ diag.span_suggestion(
+ macro_call.span,
+ "replace with",
+ format!(
+ "{}.{replacement}(){semicolon}",
+ snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
+ ),
+ app,
+ );
+ });
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/assigning_clones.rs b/src/tools/clippy/clippy_lints/src/assigning_clones.rs
index 03f777600f084..6e336efbb90a2 100644
--- a/src/tools/clippy/clippy_lints/src/assigning_clones.rs
+++ b/src/tools/clippy/clippy_lints/src/assigning_clones.rs
@@ -227,9 +227,22 @@ fn build_sugg<'tcx>(
match call_kind {
CallKind::Method => {
let receiver_sugg = if let ExprKind::Unary(hir::UnOp::Deref, ref_expr) = lhs.kind {
- // `*lhs = self_expr.clone();` -> `lhs.clone_from(self_expr)`
- Sugg::hir_with_applicability(cx, ref_expr, "_", app)
+ // If `ref_expr` is a reference, we can remove the dereference operator (`*`) to make
+ // the generated code a bit simpler. In other cases, we don't do this special case, to avoid
+ // having to deal with Deref (https://github.com/rust-lang/rust-clippy/issues/12437).
+
+ let ty = cx.typeck_results().expr_ty(ref_expr);
+ if ty.is_ref() {
+ // Apply special case, remove `*`
+ // `*lhs = self_expr.clone();` -> `lhs.clone_from(self_expr)`
+ Sugg::hir_with_applicability(cx, ref_expr, "_", app)
+ } else {
+ // Keep the original lhs
+ // `*lhs = self_expr.clone();` -> `(*lhs).clone_from(self_expr)`
+ Sugg::hir_with_applicability(cx, lhs, "_", app)
+ }
} else {
+ // Keep the original lhs
// `lhs = self_expr.clone();` -> `lhs.clone_from(self_expr)`
Sugg::hir_with_applicability(cx, lhs, "_", app)
}
@@ -249,8 +262,16 @@ fn build_sugg<'tcx>(
},
CallKind::Ufcs => {
let self_sugg = if let ExprKind::Unary(hir::UnOp::Deref, ref_expr) = lhs.kind {
- // `*lhs = Clone::clone(self_expr);` -> `Clone::clone_from(lhs, self_expr)`
- Sugg::hir_with_applicability(cx, ref_expr, "_", app)
+ // See special case of removing `*` in method handling above
+ let ty = cx.typeck_results().expr_ty(ref_expr);
+ if ty.is_ref() {
+ // `*lhs = Clone::clone(self_expr);` -> `Clone::clone_from(lhs, self_expr)`
+ Sugg::hir_with_applicability(cx, ref_expr, "_", app)
+ } else {
+ // `*lhs = Clone::clone(self_expr);` -> `Clone::clone_from(&mut *lhs, self_expr)`
+ // mut_addr_deref is used to avoid unnecessary parentheses around `*lhs`
+ Sugg::hir_with_applicability(cx, ref_expr, "_", app).mut_addr_deref()
+ }
} else {
// `lhs = Clone::clone(self_expr);` -> `Clone::clone_from(&mut lhs, self_expr)`
Sugg::hir_with_applicability(cx, lhs, "_", app).mut_addr()
diff --git a/src/tools/clippy/clippy_lints/src/attrs/allow_attributes.rs b/src/tools/clippy/clippy_lints/src/attrs/allow_attributes.rs
index df9994086cd48..a5a7b9f74a693 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/allow_attributes.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/allow_attributes.rs
@@ -1,5 +1,5 @@
use super::ALLOW_ATTRIBUTES;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::is_from_proc_macro;
use rustc_ast::{AttrStyle, Attribute};
use rustc_errors::Applicability;
@@ -13,14 +13,14 @@ pub fn check<'cx>(cx: &LateContext<'cx>, attr: &'cx Attribute) {
&& let Some(ident) = attr.ident()
&& !is_from_proc_macro(cx, attr)
{
- span_lint_and_sugg(
- cx,
- ALLOW_ATTRIBUTES,
- ident.span,
- "#[allow] attribute found",
- "replace it with",
- "expect".into(),
- Applicability::MachineApplicable,
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, ALLOW_ATTRIBUTES, ident.span, "#[allow] attribute found", |diag| {
+ diag.span_suggestion(
+ ident.span,
+ "replace it with",
+ "expect",
+ Applicability::MachineApplicable,
+ );
+ });
}
}
diff --git a/src/tools/clippy/clippy_lints/src/attrs/allow_attributes_without_reason.rs b/src/tools/clippy/clippy_lints/src/attrs/allow_attributes_without_reason.rs
index 4b42616a636bc..4ab97118df1d4 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/allow_attributes_without_reason.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/allow_attributes_without_reason.rs
@@ -1,5 +1,5 @@
use super::{Attribute, ALLOW_ATTRIBUTES_WITHOUT_REASON};
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::is_from_proc_macro;
use rustc_ast::{MetaItemKind, NestedMetaItem};
use rustc_lint::{LateContext, LintContext};
@@ -21,12 +21,14 @@ pub(super) fn check<'cx>(cx: &LateContext<'cx>, name: Symbol, items: &[NestedMet
return;
}
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
ALLOW_ATTRIBUTES_WITHOUT_REASON,
attr.span,
format!("`{}` attribute without specifying a reason", name.as_str()),
- None,
- "try adding a reason at the end with `, reason = \"..\"`",
+ |diag| {
+ diag.help("try adding a reason at the end with `, reason = \"..\"`");
+ },
);
}
diff --git a/src/tools/clippy/clippy_lints/src/bool_to_int_with_if.rs b/src/tools/clippy/clippy_lints/src/bool_to_int_with_if.rs
index 561ca9bd9866d..612712d16843c 100644
--- a/src/tools/clippy/clippy_lints/src/bool_to_int_with_if.rs
+++ b/src/tools/clippy/clippy_lints/src/bool_to_int_with_if.rs
@@ -1,6 +1,6 @@
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::sugg::Sugg;
-use clippy_utils::{in_constant, is_else_clause};
+use clippy_utils::{is_else_clause, is_in_const_context};
use rustc_ast::LitKind;
use rustc_errors::Applicability;
use rustc_hir::{Expr, ExprKind};
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
&& let Some(else_lit) = as_int_bool_lit(else_)
&& then_lit != else_lit
&& !expr.span.from_expansion()
- && !in_constant(cx, expr.hir_id)
+ && !is_in_const_context(cx)
{
let ty = cx.typeck_results().expr_ty(then);
let mut applicability = Applicability::MachineApplicable;
diff --git a/src/tools/clippy/clippy_lints/src/booleans.rs b/src/tools/clippy/clippy_lints/src/booleans.rs
index a1c6c0b608f72..a2f48c18170a6 100644
--- a/src/tools/clippy/clippy_lints/src/booleans.rs
+++ b/src/tools/clippy/clippy_lints/src/booleans.rs
@@ -477,14 +477,12 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
cx: self.cx,
};
if let Ok(expr) = h2q.run(e) {
- if h2q.terminals.len() > 8 {
- // QMC has exponentially slow behavior as the number of terminals increases
- // 8 is reasonable, it takes approximately 0.2 seconds.
- // See #825
+ let stats = terminal_stats(&expr);
+ if stats.ops > 7 {
+ // QMC has exponentially slow behavior as the number of ops increases.
+ // See #825, #13206
return;
}
-
- let stats = terminal_stats(&expr);
let mut simplified = expr.simplify();
for simple in Bool::Not(Box::new(expr)).simplify() {
match simple {
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_lossless.rs b/src/tools/clippy/clippy_lints/src/casts/cast_lossless.rs
index ff460a3fd8e39..bd3acc06f4b2b 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_lossless.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_lossless.rs
@@ -1,6 +1,6 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::in_constant;
+use clippy_utils::is_in_const_context;
use clippy_utils::source::snippet_opt;
use clippy_utils::sugg::Sugg;
use clippy_utils::ty::is_isize_or_usize;
@@ -21,7 +21,7 @@ pub(super) fn check(
cast_to_hir: &rustc_hir::Ty<'_>,
msrv: &Msrv,
) {
- if !should_lint(cx, expr, cast_from, cast_to, msrv) {
+ if !should_lint(cx, cast_from, cast_to, msrv) {
return;
}
@@ -70,9 +70,9 @@ pub(super) fn check(
);
}
-fn should_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: &Msrv) -> bool {
+fn should_lint(cx: &LateContext<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: &Msrv) -> bool {
// Do not suggest using From in consts/statics until it is valid to do so (see #2267).
- if in_constant(cx, expr.hir_id) {
+ if is_in_const_context(cx) {
return false;
}
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_nan_to_int.rs b/src/tools/clippy/clippy_lints/src/casts/cast_nan_to_int.rs
index 5bc8692c289f7..464eabe5d9ab7 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_nan_to_int.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_nan_to_int.rs
@@ -1,6 +1,6 @@
use super::CAST_NAN_TO_INT;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_note;
use rustc_hir::Expr;
use rustc_lint::LateContext;
@@ -20,7 +20,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
}
fn is_known_nan(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
- match constant(cx, cx.typeck_results(), e) {
+ match ConstEvalCtxt::new(cx).eval(e) {
// FIXME(f16_f128): add these types when nan checks are available on all platforms
Some(Constant::F64(n)) => n.is_nan(),
Some(Constant::F32(n)) => n.is_nan(),
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_possible_truncation.rs b/src/tools/clippy/clippy_lints/src/casts/cast_possible_truncation.rs
index 7c5acd1a678d7..102fe25fc67b0 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
use clippy_utils::expr_or_init;
use clippy_utils::source::snippet;
@@ -15,7 +15,7 @@ use rustc_target::abi::IntegerType;
use super::{utils, CAST_ENUM_TRUNCATION, CAST_POSSIBLE_TRUNCATION};
fn constant_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
- if let Some(Constant::Int(c)) = constant(cx, cx.typeck_results(), expr) {
+ if let Some(Constant::Int(c)) = ConstEvalCtxt::new(cx).eval(expr) {
Some(c)
} else {
None
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs b/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
index 8bbd41b0db1ee..9daf237344a4b 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
@@ -1,7 +1,7 @@
use std::convert::Infallible;
use std::ops::ControlFlow;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint;
use clippy_utils::visitors::{for_each_expr_without_closures, Descend};
use clippy_utils::{method_chain_args, sext};
@@ -88,7 +88,7 @@ fn get_const_signed_int_eval<'cx>(
) -> Option<i128> {
let ty = ty.into().unwrap_or_else(|| cx.typeck_results().expr_ty(expr));
- if let Constant::Int(n) = constant(cx, cx.typeck_results(), expr)?
+ if let Constant::Int(n) = ConstEvalCtxt::new(cx).eval(expr)?
&& let ty::Int(ity) = *ty.kind()
{
return Some(sext(cx.tcx, n, ity));
@@ -103,7 +103,7 @@ fn get_const_unsigned_int_eval<'cx>(
) -> Option<u128> {
let ty = ty.into().unwrap_or_else(|| cx.typeck_results().expr_ty(expr));
- if let Constant::Int(n) = constant(cx, cx.typeck_results(), expr)?
+ if let Constant::Int(n) = ConstEvalCtxt::new(cx).eval(expr)?
&& let ty::Uint(_ity) = *ty.kind()
{
return Some(n);
diff --git a/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_any.rs b/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
index 826589bf303b5..75de53f73ee7a 100644
--- a/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
@@ -1,6 +1,6 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet_with_applicability;
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, SuggestionStyle};
use rustc_hir::Expr;
use rustc_lint::LateContext;
use rustc_middle::ty::{self, Ty};
@@ -14,21 +14,24 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
_ => { /* continue to checks */ },
}
- match cast_from.kind() {
- ty::FnDef(..) | ty::FnPtr(_) => {
- let mut applicability = Applicability::MaybeIncorrect;
- let from_snippet = snippet_with_applicability(cx, cast_expr.span, "..", &mut applicability);
+ if let ty::FnDef(..) | ty::FnPtr(_) = cast_from.kind() {
+ let mut applicability = Applicability::MaybeIncorrect;
+ let from_snippet = snippet_with_applicability(cx, cast_expr.span, "..", &mut applicability);
- span_lint_and_sugg(
- cx,
- FN_TO_NUMERIC_CAST_ANY,
- expr.span,
- format!("casting function pointer `{from_snippet}` to `{cast_to}`"),
- "did you mean to invoke the function?",
- format!("{from_snippet}() as {cast_to}"),
- applicability,
- );
- },
- _ => {},
+ span_lint_and_then(
+ cx,
+ FN_TO_NUMERIC_CAST_ANY,
+ expr.span,
+ format!("casting function pointer `{from_snippet}` to `{cast_to}`"),
+ |diag| {
+ diag.span_suggestion_with_style(
+ expr.span,
+ "did you mean to invoke the function?",
+ format!("{from_snippet}() as {cast_to}"),
+ applicability,
+ SuggestionStyle::ShowAlways,
+ );
+ },
+ );
}
}
diff --git a/src/tools/clippy/clippy_lints/src/casts/zero_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/zero_ptr.rs
index 5071af5ecb986..3c1c7d2dc3a54 100644
--- a/src/tools/clippy/clippy_lints/src/casts/zero_ptr.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/zero_ptr.rs
@@ -1,6 +1,6 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_opt;
-use clippy_utils::{in_constant, is_integer_literal, std_or_core};
+use clippy_utils::{is_in_const_context, is_integer_literal, std_or_core};
use rustc_errors::Applicability;
use rustc_hir::{Expr, Mutability, Ty, TyKind};
use rustc_lint::LateContext;
@@ -10,7 +10,7 @@ use super::ZERO_PTR;
pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to: &Ty<'_>) {
if let TyKind::Ptr(ref mut_ty) = to.kind
&& is_integer_literal(from, 0)
- && !in_constant(cx, from.hir_id)
+ && !is_in_const_context(cx)
&& let Some(std_or_core) = std_or_core(cx)
{
let (msg, sugg_fn) = match mut_ty.mutbl {
diff --git a/src/tools/clippy/clippy_lints/src/checked_conversions.rs b/src/tools/clippy/clippy_lints/src/checked_conversions.rs
index 0b1ab5411bf18..1711565fca891 100644
--- a/src/tools/clippy/clippy_lints/src/checked_conversions.rs
+++ b/src/tools/clippy/clippy_lints/src/checked_conversions.rs
@@ -4,7 +4,7 @@ use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{in_constant, is_integer_literal, SpanlessEq};
+use clippy_utils::{is_in_const_context, is_integer_literal, SpanlessEq};
use rustc_errors::Applicability;
use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, TyKind};
use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -67,7 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
_ => return,
}
&& !in_external_macro(cx.sess(), item.span)
- && !in_constant(cx, item.hir_id)
+ && !is_in_const_context(cx)
&& self.msrv.meets(msrvs::TRY_FROM)
&& let Some(cv) = match op2 {
// todo: check for case signed -> larger unsigned == only x >= 0
diff --git a/src/tools/clippy/clippy_lints/src/comparison_chain.rs b/src/tools/clippy/clippy_lints/src/comparison_chain.rs
index 2c23c0b4f154c..5d78744e9b5e2 100644
--- a/src/tools/clippy/clippy_lints/src/comparison_chain.rs
+++ b/src/tools/clippy/clippy_lints/src/comparison_chain.rs
@@ -1,6 +1,6 @@
use clippy_utils::diagnostics::span_lint_and_help;
use clippy_utils::ty::implements_trait;
-use clippy_utils::{if_sequence, in_constant, is_else_clause, SpanlessEq};
+use clippy_utils::{if_sequence, is_else_clause, is_in_const_context, SpanlessEq};
use rustc_hir::{BinOpKind, Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_session::declare_lint_pass;
@@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
return;
}
- if in_constant(cx, expr.hir_id) {
+ if is_in_const_context(cx) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/create_dir.rs b/src/tools/clippy/clippy_lints/src/create_dir.rs
index 27c00948a8f2b..b49a977dbeaf1 100644
--- a/src/tools/clippy/clippy_lints/src/create_dir.rs
+++ b/src/tools/clippy/clippy_lints/src/create_dir.rs
@@ -1,6 +1,6 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use rustc_errors::Applicability;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::{Applicability, SuggestionStyle};
use rustc_hir::{Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_session::declare_lint_pass;
@@ -39,14 +39,24 @@ impl LateLintPass<'_> for CreateDir {
&& let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
&& cx.tcx.is_diagnostic_item(sym::fs_create_dir, def_id)
{
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
CREATE_DIR,
expr.span,
"calling `std::fs::create_dir` where there may be a better way",
- "consider calling `std::fs::create_dir_all` instead",
- format!("create_dir_all({})", snippet(cx, arg.span, "..")),
- Applicability::MaybeIncorrect,
+ |diag| {
+ let mut app = Applicability::MaybeIncorrect;
+ diag.span_suggestion_with_style(
+ expr.span,
+ "consider calling `std::fs::create_dir_all` instead",
+ format!(
+ "create_dir_all({})",
+ snippet_with_applicability(cx, arg.span, "..", &mut app)
+ ),
+ app,
+ SuggestionStyle::ShowAlways,
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/dbg_macro.rs b/src/tools/clippy/clippy_lints/src/dbg_macro.rs
index 788c6f3ada297..93c8fff05e9ed 100644
--- a/src/tools/clippy/clippy_lints/src/dbg_macro.rs
+++ b/src/tools/clippy/clippy_lints/src/dbg_macro.rs
@@ -1,5 +1,5 @@
use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::is_in_test;
use clippy_utils::macros::{macro_backtrace, MacroCall};
use clippy_utils::source::snippet_with_applicability;
@@ -65,61 +65,67 @@ impl LateLintPass<'_> for DbgMacro {
// allows `dbg!` in test code if allow-dbg-in-test is set to true in clippy.toml
!(self.allow_dbg_in_tests && is_in_test(cx.tcx, expr.hir_id))
{
- let mut applicability = Applicability::MachineApplicable;
-
- let (sugg_span, suggestion) = match expr.peel_drop_temps().kind {
- // dbg!()
- ExprKind::Block(..) => {
- // If the `dbg!` macro is a "free" statement and not contained within other expressions,
- // remove the whole statement.
- if let Node::Stmt(_) = cx.tcx.parent_hir_node(expr.hir_id)
- && let Some(semi_span) = cx.sess().source_map().mac_call_stmt_semi_span(macro_call.span)
- {
- (macro_call.span.to(semi_span), String::new())
- } else {
- (macro_call.span, String::from("()"))
- }
- },
- // dbg!(1)
- ExprKind::Match(val, ..) => (
- macro_call.span,
- snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability).to_string(),
- ),
- // dbg!(2, 3)
- ExprKind::Tup(
- [
- Expr {
- kind: ExprKind::Match(first, ..),
- ..
- },
- ..,
- Expr {
- kind: ExprKind::Match(last, ..),
- ..
- },
- ],
- ) => {
- let snippet = snippet_with_applicability(
- cx,
- first.span.source_callsite().to(last.span.source_callsite()),
- "..",
- &mut applicability,
- );
- (macro_call.span, format!("({snippet})"))
- },
- _ => return,
- };
-
self.prev_ctxt = cur_syntax_ctxt;
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
DBG_MACRO,
- sugg_span,
+ macro_call.span,
"the `dbg!` macro is intended as a debugging tool",
- "remove the invocation before committing it to a version control system",
- suggestion,
- applicability,
+ |diag| {
+ let mut applicability = Applicability::MachineApplicable;
+
+ let (sugg_span, suggestion) = match expr.peel_drop_temps().kind {
+ // dbg!()
+ ExprKind::Block(..) => {
+ // If the `dbg!` macro is a "free" statement and not contained within other expressions,
+ // remove the whole statement.
+ if let Node::Stmt(_) = cx.tcx.parent_hir_node(expr.hir_id)
+ && let Some(semi_span) = cx.sess().source_map().mac_call_stmt_semi_span(macro_call.span)
+ {
+ (macro_call.span.to(semi_span), String::new())
+ } else {
+ (macro_call.span, String::from("()"))
+ }
+ },
+ // dbg!(1)
+ ExprKind::Match(val, ..) => (
+ macro_call.span,
+ snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability)
+ .to_string(),
+ ),
+ // dbg!(2, 3)
+ ExprKind::Tup(
+ [
+ Expr {
+ kind: ExprKind::Match(first, ..),
+ ..
+ },
+ ..,
+ Expr {
+ kind: ExprKind::Match(last, ..),
+ ..
+ },
+ ],
+ ) => {
+ let snippet = snippet_with_applicability(
+ cx,
+ first.span.source_callsite().to(last.span.source_callsite()),
+ "..",
+ &mut applicability,
+ );
+ (macro_call.span, format!("({snippet})"))
+ },
+ _ => unreachable!(),
+ };
+
+ diag.span_suggestion(
+ sugg_span,
+ "remove the invocation before committing it to a version control system",
+ suggestion,
+ applicability,
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/declared_lints.rs b/src/tools/clippy/clippy_lints/src/declared_lints.rs
index 69f9eb6842bcd..3fb083dd83310 100644
--- a/src/tools/clippy/clippy_lints/src/declared_lints.rs
+++ b/src/tools/clippy/clippy_lints/src/declared_lints.rs
@@ -14,8 +14,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
#[cfg(feature = "internal")]
crate::utils::internal_lints::invalid_paths::INVALID_PATHS_INFO,
#[cfg(feature = "internal")]
- crate::utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON_INFO,
- #[cfg(feature = "internal")]
crate::utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT_INFO,
#[cfg(feature = "internal")]
crate::utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE_INFO,
@@ -741,6 +739,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
crate::unused_async::UNUSED_ASYNC_INFO,
crate::unused_io_amount::UNUSED_IO_AMOUNT_INFO,
crate::unused_peekable::UNUSED_PEEKABLE_INFO,
+ crate::unused_result_ok::UNUSED_RESULT_OK_INFO,
crate::unused_rounding::UNUSED_ROUNDING_INFO,
crate::unused_self::UNUSED_SELF_INFO,
crate::unused_unit::UNUSED_UNIT_INFO,
diff --git a/src/tools/clippy/clippy_lints/src/default.rs b/src/tools/clippy/clippy_lints/src/default.rs
index 72fa05be3cc60..0b7279f2b360d 100644
--- a/src/tools/clippy/clippy_lints/src/default.rs
+++ b/src/tools/clippy/clippy_lints/src/default.rs
@@ -221,7 +221,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
.map(ToString::to_string)
.collect::<Vec<_>>()
.join(", ");
- format!("{adt_def_ty_name}::<{}>", &tys_str)
+ format!("{adt_def_ty_name}::<{tys_str}>")
} else {
binding_type.to_string()
};
diff --git a/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs b/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs
index 9af73db6849f4..a74b3a8c8362c 100644
--- a/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs
+++ b/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs
@@ -92,20 +92,8 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
let (suffix, is_float) = match lit_ty.kind() {
ty::Int(IntTy::I32) => ("i32", false),
ty::Float(FloatTy::F64) => ("f64", true),
- // Default numeric fallback never results in other types.
_ => return,
};
-
- let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
- src
- } else {
- match lit.node {
- LitKind::Int(src, _) => format!("{src}"),
- LitKind::Float(src, _) => format!("{src}"),
- _ => return,
- }
- };
- let sugg = numeric_literal::format(&src, Some(suffix), is_float);
span_lint_hir_and_then(
self.cx,
DEFAULT_NUMERIC_FALLBACK,
@@ -113,6 +101,17 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
lit.span,
"default numeric fallback might occur",
|diag| {
+ let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
+ src
+ } else {
+ match lit.node {
+ LitKind::Int(src, _) => format!("{src}"),
+ LitKind::Float(src, _) => format!("{src}"),
+ _ => unreachable!("Default numeric fallback never results in other types"),
+ }
+ };
+
+ let sugg = numeric_literal::format(&src, Some(suffix), is_float);
diag.span_suggestion(lit.span, "consider adding suffix", sugg, Applicability::MaybeIncorrect);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/default_union_representation.rs b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
index 3fa9bad0d03da..9f020d3081c40 100644
--- a/src/tools/clippy/clippy_lints/src/default_union_representation.rs
+++ b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_hir::{HirId, Item, ItemKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::layout::LayoutOf;
@@ -56,16 +56,18 @@ impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
&& is_union_with_two_non_zst_fields(cx, item)
&& !has_c_repr_attr(cx, item.hir_id())
{
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
DEFAULT_UNION_REPRESENTATION,
item.span,
"this union has the default representation",
- None,
- format!(
- "consider annotating `{}` with `#[repr(C)]` to explicitly specify memory layout",
- cx.tcx.def_path_str(item.owner_id)
- ),
+ |diag| {
+ diag.help(format!(
+ "consider annotating `{}` with `#[repr(C)]` to explicitly specify memory layout",
+ cx.tcx.def_path_str(item.owner_id)
+ ));
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/deprecated_lints.rs b/src/tools/clippy/clippy_lints/src/deprecated_lints.rs
index a0900f46f6aa6..0066ed643251a 100644
--- a/src/tools/clippy/clippy_lints/src/deprecated_lints.rs
+++ b/src/tools/clippy/clippy_lints/src/deprecated_lints.rs
@@ -1,243 +1,181 @@
-// NOTE: Entries should be created with `cargo dev deprecate`
-
-/// This struct fakes the `Lint` declaration that is usually created by `declare_lint!`. This
-/// enables the simple extraction of the metadata without changing the current deprecation
-/// declaration.
-pub struct ClippyDeprecatedLint {
- #[allow(dead_code)]
- pub desc: &'static str,
-}
-
-#[macro_export]
-macro_rules! declare_deprecated_lint {
- { $(#[$attr:meta])* pub $name: ident, $reason: literal} => {
- $(#[$attr])*
- #[allow(dead_code)]
- pub static $name: ClippyDeprecatedLint = ClippyDeprecatedLint {
- desc: $reason
- };
- }
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This used to check for `assert!(a == b)` and recommend
- /// replacement with `assert_eq!(a, b)`, but this is no longer needed after RFC 2011.
+// This file is managed by `cargo dev rename_lint` and `cargo dev deprecate_lint`.
+// Prefer to use those when possible.
+
+macro_rules! declare_with_version {
+ ($name:ident($name_version:ident): &[$ty:ty] = &[$(
+ #[clippy::version = $version:literal]
+ $e:expr,
+ )*]) => {
+ pub static $name: &[$ty] = &[$($e),*];
+ #[allow(unused)]
+ pub static $name_version: &[&str] = &[$($version),*];
+ };
+}
+
+#[rustfmt::skip]
+declare_with_version! { DEPRECATED(DEPRECATED_VERSION): &[(&str, &str)] = &[
#[clippy::version = "pre 1.29.0"]
- pub SHOULD_ASSERT_EQ,
- "`assert!()` will be more flexible with RFC 2011"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This used to check for `Vec::extend`, which was slower than
- /// `Vec::extend_from_slice`. Thanks to specialization, this is no longer true.
+ ("clippy::should_assert_eq", "`assert!(a == b)` can now print the values the same way `assert_eq!(a, b) can"),
#[clippy::version = "pre 1.29.0"]
- pub EXTEND_FROM_SLICE,
- "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// `Range::step_by(0)` used to be linted since it's
- /// an infinite iterator, which is better expressed by `iter::repeat`,
- /// but the method has been removed for `Iterator::step_by` which panics
- /// if given a zero
+ ("clippy::extend_from_slice", "`Vec::extend_from_slice` is no longer faster than `Vec::extend` due to specialization"),
#[clippy::version = "pre 1.29.0"]
- pub RANGE_STEP_BY_ZERO,
- "`iterator.step_by(0)` panics nowadays"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This used to check for `Vec::as_slice`, which was unstable with good
- /// stable alternatives. `Vec::as_slice` has now been stabilized.
+ ("clippy::range_step_by_zero", "`Iterator::step_by(0)` now panics and is no longer an infinite iterator"),
#[clippy::version = "pre 1.29.0"]
- pub UNSTABLE_AS_SLICE,
- "`Vec::as_slice` has been stabilized in 1.7"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This used to check for `Vec::as_mut_slice`, which was unstable with good
- /// stable alternatives. `Vec::as_mut_slice` has now been stabilized.
+ ("clippy::unstable_as_slice", "`Vec::as_slice` is now stable"),
#[clippy::version = "pre 1.29.0"]
- pub UNSTABLE_AS_MUT_SLICE,
- "`Vec::as_mut_slice` has been stabilized in 1.7"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint should never have applied to non-pointer types, as transmuting
- /// between non-pointer types of differing alignment is well-defined behavior (it's semantically
- /// equivalent to a memcpy). This lint has thus been refactored into two separate lints:
- /// cast_ptr_alignment and transmute_ptr_to_ptr.
+ ("clippy::unstable_as_mut_slice", "`Vec::as_mut_slice` is now stable"),
#[clippy::version = "pre 1.29.0"]
- pub MISALIGNED_TRANSMUTE,
- "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint is too subjective, not having a good reason for being in clippy.
- /// Additionally, compound assignment operators may be overloaded separately from their non-assigning
- /// counterparts, so this lint may suggest a change in behavior or the code may not compile.
+ ("clippy::misaligned_transmute", "split into `clippy::cast_ptr_alignment` and `clippy::transmute_ptr_to_ptr`"),
#[clippy::version = "1.30.0"]
- pub ASSIGN_OPS,
- "using compound assignment operators (e.g., `+=`) is harmless"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// The original rule will only lint for `if let`. After
- /// making it support to lint `match`, naming as `if let` is not suitable for it.
- /// So, this lint is deprecated.
+ ("clippy::assign_ops", "compound operators are harmless and linting on them is not in scope for clippy"),
#[clippy::version = "pre 1.29.0"]
- pub IF_LET_REDUNDANT_PATTERN_MATCHING,
- "this lint has been changed to redundant_pattern_matching"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint used to suggest replacing `let mut vec =
- /// Vec::with_capacity(n); vec.set_len(n);` with `let vec = vec![0; n];`. The
- /// replacement has very different performance characteristics so the lint is
- /// deprecated.
- #[clippy::version = "pre 1.29.0"]
- pub UNSAFE_VECTOR_INITIALIZATION,
- "the replacement suggested by this lint had substantially different behavior"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint has been superseded by #[must_use] in rustc.
+ ("clippy::unsafe_vector_initialization", "the suggested alternative could be substantially slower"),
#[clippy::version = "1.39.0"]
- pub UNUSED_COLLECT,
- "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// Associated-constants are now preferred.
+ ("clippy::unused_collect", "`Iterator::collect` is now marked as `#[must_use]`"),
#[clippy::version = "1.44.0"]
- pub REPLACE_CONSTS,
- "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// The regex! macro does not exist anymore.
+ ("clippy::replace_consts", "`min_value` and `max_value` are now deprecated"),
#[clippy::version = "1.47.0"]
- pub REGEX_MACRO,
- "the regex! macro has been removed from the regex crate in 2018"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint has been replaced by `manual_find_map`, a
- /// more specific lint.
- #[clippy::version = "1.51.0"]
- pub FIND_MAP,
- "this lint has been replaced by `manual_find_map`, a more specific lint"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint has been replaced by `manual_filter_map`, a
- /// more specific lint.
- #[clippy::version = "1.53.0"]
- pub FILTER_MAP,
- "this lint has been replaced by `manual_filter_map`, a more specific lint"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// The `avoid_breaking_exported_api` config option was added, which
- /// enables the `enum_variant_names` lint for public items.
+ ("clippy::regex_macro", "the `regex!` macro was removed from the regex crate in 2018"),
#[clippy::version = "1.54.0"]
- pub PUB_ENUM_VARIANT_NAMES,
- "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// The `avoid_breaking_exported_api` config option was added, which
- /// enables the `wrong_self_conversion` lint for public items.
+ ("clippy::pub_enum_variant_names", "`clippy::enum_variant_names` now covers this case via the `avoid-breaking-exported-api` config"),
#[clippy::version = "1.54.0"]
- pub WRONG_PUB_SELF_CONVENTION,
- "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint has been superseded by rustc's own [`unexpected_cfgs`] lint that is able to detect the `#[cfg(features)]` and `#[cfg(tests)]` typos.
- ///
- /// [`unexpected_cfgs`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#unexpected-cfgs
+ ("clippy::wrong_pub_self_convention", "`clippy::wrong_self_convention` now covers this case via the `avoid-breaking-exported-api` config"),
+ // end deprecated lints. used by `cargo dev deprecate_lint`
+]}
+
+#[rustfmt::skip]
+declare_with_version! { RENAMED(RENAMED_VERSION): &[(&str, &str)] = &[
+ #[clippy::version = ""]
+ ("clippy::almost_complete_letter_range", "clippy::almost_complete_range"),
+ #[clippy::version = ""]
+ ("clippy::blacklisted_name", "clippy::disallowed_names"),
+ #[clippy::version = ""]
+ ("clippy::block_in_if_condition_expr", "clippy::blocks_in_conditions"),
+ #[clippy::version = ""]
+ ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_conditions"),
+ #[clippy::version = ""]
+ ("clippy::blocks_in_if_conditions", "clippy::blocks_in_conditions"),
+ #[clippy::version = ""]
+ ("clippy::box_vec", "clippy::box_collection"),
+ #[clippy::version = ""]
+ ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
+ #[clippy::version = ""]
+ ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
+ #[clippy::version = ""]
+ ("clippy::derive_hash_xor_eq", "clippy::derived_hash_with_manual_eq"),
+ #[clippy::version = ""]
+ ("clippy::disallowed_method", "clippy::disallowed_methods"),
+ #[clippy::version = ""]
+ ("clippy::disallowed_type", "clippy::disallowed_types"),
+ #[clippy::version = ""]
+ ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
+ #[clippy::version = "1.51.0"]
+ ("clippy::find_map", "clippy::manual_find_map"),
+ #[clippy::version = "1.53.0"]
+ ("clippy::filter_map", "clippy::manual_filter_map"),
+ #[clippy::version = ""]
+ ("clippy::identity_conversion", "clippy::useless_conversion"),
+ #[clippy::version = "pre 1.29.0"]
+ ("clippy::if_let_redundant_pattern_matching", "clippy::redundant_pattern_matching"),
+ #[clippy::version = ""]
+ ("clippy::if_let_some_result", "clippy::match_result_ok"),
+ #[clippy::version = ""]
+ ("clippy::incorrect_clone_impl_on_copy_type", "clippy::non_canonical_clone_impl"),
+ #[clippy::version = ""]
+ ("clippy::incorrect_partial_ord_impl_on_ord_type", "clippy::non_canonical_partial_ord_impl"),
+ #[clippy::version = ""]
+ ("clippy::integer_arithmetic", "clippy::arithmetic_side_effects"),
+ #[clippy::version = ""]
+ ("clippy::logic_bug", "clippy::overly_complex_bool_expr"),
+ #[clippy::version = ""]
+ ("clippy::new_without_default_derive", "clippy::new_without_default"),
+ #[clippy::version = ""]
+ ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
+ #[clippy::version = ""]
+ ("clippy::option_expect_used", "clippy::expect_used"),
+ #[clippy::version = ""]
+ ("clippy::option_map_unwrap_or", "clippy::map_unwrap_or"),
+ #[clippy::version = ""]
+ ("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or"),
+ #[clippy::version = ""]
+ ("clippy::option_unwrap_used", "clippy::unwrap_used"),
+ #[clippy::version = ""]
+ ("clippy::overflow_check_conditional", "clippy::panicking_overflow_checks"),
+ #[clippy::version = ""]
+ ("clippy::ref_in_deref", "clippy::needless_borrow"),
+ #[clippy::version = ""]
+ ("clippy::result_expect_used", "clippy::expect_used"),
+ #[clippy::version = ""]
+ ("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or"),
+ #[clippy::version = ""]
+ ("clippy::result_unwrap_used", "clippy::unwrap_used"),
+ #[clippy::version = ""]
+ ("clippy::single_char_push_str", "clippy::single_char_add_str"),
+ #[clippy::version = ""]
+ ("clippy::stutter", "clippy::module_name_repetitions"),
+ #[clippy::version = ""]
+ ("clippy::thread_local_initializer_can_be_made_const", "clippy::missing_const_for_thread_local"),
+ #[clippy::version = ""]
+ ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
+ #[clippy::version = ""]
+ ("clippy::unwrap_or_else_default", "clippy::unwrap_or_default"),
+ #[clippy::version = ""]
+ ("clippy::zero_width_space", "clippy::invisible_characters"),
+ #[clippy::version = ""]
+ ("clippy::cast_ref_to_mut", "invalid_reference_casting"),
+ #[clippy::version = ""]
+ ("clippy::clone_double_ref", "suspicious_double_ref_op"),
+ #[clippy::version = ""]
+ ("clippy::cmp_nan", "invalid_nan_comparisons"),
+ #[clippy::version = ""]
+ ("clippy::drop_bounds", "drop_bounds"),
+ #[clippy::version = ""]
+ ("clippy::drop_copy", "dropping_copy_types"),
+ #[clippy::version = ""]
+ ("clippy::drop_ref", "dropping_references"),
+ #[clippy::version = ""]
+ ("clippy::fn_null_check", "useless_ptr_null_checks"),
+ #[clippy::version = ""]
+ ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
+ #[clippy::version = ""]
+ ("clippy::for_loop_over_result", "for_loops_over_fallibles"),
+ #[clippy::version = ""]
+ ("clippy::for_loops_over_fallibles", "for_loops_over_fallibles"),
+ #[clippy::version = ""]
+ ("clippy::forget_copy", "forgetting_copy_types"),
+ #[clippy::version = ""]
+ ("clippy::forget_ref", "forgetting_references"),
+ #[clippy::version = ""]
+ ("clippy::into_iter_on_array", "array_into_iter"),
+ #[clippy::version = ""]
+ ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
+ #[clippy::version = ""]
+ ("clippy::invalid_ref", "invalid_value"),
+ #[clippy::version = ""]
+ ("clippy::invalid_utf8_in_unchecked", "invalid_from_utf8_unchecked"),
+ #[clippy::version = ""]
+ ("clippy::let_underscore_drop", "let_underscore_drop"),
#[clippy::version = "1.80.0"]
- pub MAYBE_MISUSED_CFG,
- "this lint has been replaced by `unexpected_cfgs`"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint has been superseded by rustc's own [`unexpected_cfgs`] lint that is able to detect invalid `#[cfg(linux)]` attributes.
- ///
- /// [`unexpected_cfgs`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#unexpected-cfgs
+ ("clippy::maybe_misused_cfg", "unexpected_cfgs"),
+ #[clippy::version = ""]
+ ("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums"),
#[clippy::version = "1.80.0"]
- pub MISMATCHED_TARGET_OS,
- "this lint has been replaced by `unexpected_cfgs`"
-}
+ ("clippy::mismatched_target_os", "unexpected_cfgs"),
+ #[clippy::version = ""]
+ ("clippy::panic_params", "non_fmt_panics"),
+ #[clippy::version = ""]
+ ("clippy::positional_named_format_parameters", "named_arguments_used_positionally"),
+ #[clippy::version = ""]
+ ("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr"),
+ #[clippy::version = ""]
+ ("clippy::undropped_manually_drops", "undropped_manually_drops"),
+ #[clippy::version = ""]
+ ("clippy::unknown_clippy_lints", "unknown_lints"),
+ #[clippy::version = ""]
+ ("clippy::unused_label", "unused_labels"),
+ #[clippy::version = ""]
+ ("clippy::vtable_address_comparisons", "ambiguous_wide_pointer_comparisons"),
+ #[clippy::version = ""]
+ ("clippy::reverse_range_loop", "clippy::reversed_empty_ranges"),
+ // end renamed lints. used by `cargo dev rename_lint`
+]}
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs
index 253f9959e13e7..d0cb24884686a 100644
--- a/src/tools/clippy/clippy_lints/src/dereference.rs
+++ b/src/tools/clippy/clippy_lints/src/dereference.rs
@@ -1,7 +1,7 @@
use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{implements_trait, is_manually_drop, peel_mid_ty_refs};
+use clippy_utils::ty::{implements_trait, is_manually_drop};
use clippy_utils::{
expr_use_ctxt, get_parent_expr, is_block_like, is_lint_allowed, path_to_local, peel_middle_ty_refs, DefinedTy,
ExprUseNode,
@@ -947,7 +947,7 @@ fn report<'tcx>(
let (expr_str, _expr_is_macro_call) =
snippet_with_context(cx, expr.span, data.first_expr.span.ctxt(), "..", &mut app);
let ty = typeck.expr_ty(expr);
- let (_, ref_count) = peel_mid_ty_refs(ty);
+ let (_, ref_count) = peel_middle_ty_refs(ty);
let deref_str = if ty_changed_count >= ref_count && ref_count != 0 {
// a deref call changing &T -> &U requires two deref operators the first time
// this occurs. One to remove the reference, a second to call the deref impl.
diff --git a/src/tools/clippy/clippy_lints/src/doc/mod.rs b/src/tools/clippy/clippy_lints/src/doc/mod.rs
index 5b6a5b08aa94c..d7b3a7c74f3ce 100644
--- a/src/tools/clippy/clippy_lints/src/doc/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/mod.rs
@@ -5,7 +5,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
use clippy_utils::macros::{is_panic, root_macro_call_first_node};
use clippy_utils::ty::is_type_diagnostic_item;
use clippy_utils::visitors::Visitable;
-use clippy_utils::{in_constant, is_entrypoint_fn, is_trait_impl_item, method_chain_args};
+use clippy_utils::{is_entrypoint_fn, is_trait_impl_item, method_chain_args};
use pulldown_cmark::Event::{
Code, DisplayMath, End, FootnoteReference, HardBreak, Html, InlineHtml, InlineMath, Rule, SoftBreak, Start,
TaskListMarker, Text,
@@ -768,7 +768,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
);
}
},
- FootnoteReference(text) | Text(text) => {
+ Text(text) => {
paragraph_range.end = range.end;
let range_ = range.clone();
ticks_unbalanced |= text.contains('`')
@@ -812,7 +812,8 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
}
text_to_check.push((text, range, code_level));
}
- },
+ }
+ FootnoteReference(_) => {}
}
}
headers
@@ -857,7 +858,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
"assert" | "assert_eq" | "assert_ne"
)
{
- self.is_const = in_constant(self.cx, expr.hir_id);
+ self.is_const = self.cx.tcx.hir().is_inside_const_context(expr.hir_id);
self.panic_span = Some(macro_call.span);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/drop_forget_ref.rs b/src/tools/clippy/clippy_lints/src/drop_forget_ref.rs
index 4a6ffcd9a7888..c7dd7292a14be 100644
--- a/src/tools/clippy/clippy_lints/src/drop_forget_ref.rs
+++ b/src/tools/clippy/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);
+ }
+ });
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/else_if_without_else.rs b/src/tools/clippy/clippy_lints/src/else_if_without_else.rs
index 7a6dc46972767..02f9c2c36488d 100644
--- a/src/tools/clippy/clippy_lints/src/else_if_without_else.rs
+++ b/src/tools/clippy/clippy_lints/src/else_if_without_else.rs
@@ -1,6 +1,6 @@
//! Lint on if expressions with an else if, but without a final else branch.
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_ast::ast::{Expr, ExprKind};
use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
use rustc_middle::lint::in_external_macro;
@@ -54,13 +54,15 @@ impl EarlyLintPass for ElseIfWithoutElse {
&& let ExprKind::If(_, _, None) = els.kind
&& !in_external_macro(cx.sess(), item.span)
{
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
ELSE_IF_WITHOUT_ELSE,
els.span,
"`if` expression with an `else if`, but without a final `else`",
- None,
- "add an `else` block here",
+ |diag| {
+ diag.help("add an `else` block here");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/empty_drop.rs b/src/tools/clippy/clippy_lints/src/empty_drop.rs
index c5fc72b5e2d8e..b66dd2108fc9b 100644
--- a/src/tools/clippy/clippy_lints/src/empty_drop.rs
+++ b/src/tools/clippy/clippy_lints/src/empty_drop.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::peel_blocks;
use rustc_errors::Applicability;
use rustc_hir::{Body, ExprKind, Impl, ImplItemKind, Item, ItemKind, Node};
@@ -50,15 +50,14 @@ impl LateLintPass<'_> for EmptyDrop {
&& block.stmts.is_empty()
&& block.expr.is_none()
{
- span_lint_and_sugg(
- cx,
- EMPTY_DROP,
- item.span,
- "empty drop implementation",
- "try removing this impl",
- String::new(),
- Applicability::MaybeIncorrect,
- );
+ span_lint_and_then(cx, EMPTY_DROP, item.span, "empty drop implementation", |diag| {
+ diag.span_suggestion_hidden(
+ item.span,
+ "try removing this impl",
+ String::new(),
+ Applicability::MaybeIncorrect,
+ );
+ });
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/endian_bytes.rs b/src/tools/clippy/clippy_lints/src/endian_bytes.rs
index 5bba9c562b931..209104c5385c9 100644
--- a/src/tools/clippy/clippy_lints/src/endian_bytes.rs
+++ b/src/tools/clippy/clippy_lints/src/endian_bytes.rs
@@ -7,7 +7,6 @@ use rustc_middle::lint::in_external_macro;
use rustc_middle::ty::Ty;
use rustc_session::declare_lint_pass;
use rustc_span::Symbol;
-use std::borrow::Cow;
declare_clippy_lint! {
/// ### What it does
@@ -141,52 +140,6 @@ fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: Prefix
_ => return,
};
- let mut help = None;
-
- 'build_help: {
- // all lints disallowed, don't give help here
- if [&[lint], other_lints.as_slice()]
- .concat()
- .iter()
- .all(|lint| !lint.allowed(cx, expr))
- {
- break 'build_help;
- }
-
- // ne_bytes and all other lints allowed
- if lint.as_name(prefix) == ne && other_lints.iter().all(|lint| lint.allowed(cx, expr)) {
- help = Some(Cow::Borrowed("specify the desired endianness explicitly"));
- break 'build_help;
- }
-
- // le_bytes where ne_bytes allowed but be_bytes is not, or le_bytes where ne_bytes allowed but
- // le_bytes is not
- if (lint.as_name(prefix) == le || lint.as_name(prefix) == be) && LintKind::Host.allowed(cx, expr) {
- help = Some(Cow::Borrowed("use the native endianness instead"));
- break 'build_help;
- }
-
- let allowed_lints = other_lints.iter().filter(|lint| lint.allowed(cx, expr));
- let len = allowed_lints.clone().count();
-
- let mut help_str = "use ".to_owned();
-
- for (i, lint) in allowed_lints.enumerate() {
- let only_one = len == 1;
- if !only_one {
- help_str.push_str("either of ");
- }
-
- help_str.push_str(&format!("`{ty}::{}` ", lint.as_name(prefix)));
-
- if i != len && !only_one {
- help_str.push_str("or ");
- }
- }
-
- help = Some(Cow::Owned(help_str + "instead"));
- }
-
span_lint_and_then(
cx,
lint.as_lint(),
@@ -198,9 +151,47 @@ fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: Prefix
if prefix == Prefix::To { " method" } else { "" },
),
move |diag| {
- if let Some(help) = help {
- diag.help(help);
+ // all lints disallowed, don't give help here
+ if [&[lint], other_lints.as_slice()]
+ .concat()
+ .iter()
+ .all(|lint| !lint.allowed(cx, expr))
+ {
+ return;
+ }
+
+ // ne_bytes and all other lints allowed
+ if lint.as_name(prefix) == ne && other_lints.iter().all(|lint| lint.allowed(cx, expr)) {
+ diag.help("specify the desired endianness explicitly");
+ return;
+ }
+
+ // le_bytes where ne_bytes allowed but be_bytes is not, or le_bytes where ne_bytes allowed but
+ // le_bytes is not
+ if (lint.as_name(prefix) == le || lint.as_name(prefix) == be) && LintKind::Host.allowed(cx, expr) {
+ diag.help("use the native endianness instead");
+ return;
+ }
+
+ let allowed_lints = other_lints.iter().filter(|lint| lint.allowed(cx, expr));
+ let len = allowed_lints.clone().count();
+
+ let mut help_str = "use ".to_owned();
+
+ for (i, lint) in allowed_lints.enumerate() {
+ let only_one = len == 1;
+ if !only_one {
+ help_str.push_str("either of ");
+ }
+
+ help_str.push_str(&format!("`{ty}::{}` ", lint.as_name(prefix)));
+
+ if i != len && !only_one {
+ help_str.push_str("or ");
+ }
}
+ help_str.push_str("instead");
+ diag.help(help_str);
},
);
}
diff --git a/src/tools/clippy/clippy_lints/src/enum_clike.rs b/src/tools/clippy/clippy_lints/src/enum_clike.rs
index 30eb643c42ece..e54cd248ead29 100644
--- a/src/tools/clippy/clippy_lints/src/enum_clike.rs
+++ b/src/tools/clippy/clippy_lints/src/enum_clike.rs
@@ -51,7 +51,7 @@ impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
.const_eval_poly(def_id.to_def_id())
.ok()
.map(|val| rustc_middle::mir::Const::from_value(val, ty));
- if let Some(Constant::Int(val)) = constant.and_then(|c| mir_to_const(cx, c)) {
+ if let Some(Constant::Int(val)) = constant.and_then(|c| mir_to_const(cx.tcx, c)) {
if let ty::Adt(adt, _) = ty.kind() {
if adt.is_enum() {
ty = adt.repr().discr_type().to_ty(cx.tcx);
diff --git a/src/tools/clippy/clippy_lints/src/eta_reduction.rs b/src/tools/clippy/clippy_lints/src/eta_reduction.rs
index 0ed7859418bc5..5a7226d590c4d 100644
--- a/src/tools/clippy/clippy_lints/src/eta_reduction.rs
+++ b/src/tools/clippy/clippy_lints/src/eta_reduction.rs
@@ -9,8 +9,7 @@ use rustc_hir::{BindingMode, Expr, ExprKind, FnRetTy, Param, PatKind, QPath, Saf
use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::{
- self, Binder, ClosureArgs, ClosureKind, FnSig, GenericArg, GenericArgKind, List, Region, RegionKind, Ty, TyCtxt,
- TypeVisitableExt, TypeckResults,
+ self, Binder, ClosureKind, FnSig, GenericArg, GenericArgKind, List, Region, Ty, TypeVisitableExt, TypeckResults,
};
use rustc_session::declare_lint_pass;
use rustc_span::symbol::sym;
@@ -74,159 +73,184 @@ declare_clippy_lint! {
declare_lint_pass!(EtaReduction => [REDUNDANT_CLOSURE, REDUNDANT_CLOSURE_FOR_METHOD_CALLS]);
impl<'tcx> LateLintPass<'tcx> for EtaReduction {
- #[allow(clippy::too_many_lines)]
- fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
- let body = if let ExprKind::Closure(c) = expr.kind
- && c.fn_decl.inputs.iter().all(|ty| matches!(ty.kind, TyKind::Infer))
- && matches!(c.fn_decl.output, FnRetTy::DefaultReturn(_))
- && !expr.span.from_expansion()
- {
- cx.tcx.hir().body(c.body)
- } else {
- return;
- };
-
- if body.value.span.from_expansion() {
- if body.params.is_empty() {
- if let Some(VecArgs::Vec(&[])) = VecArgs::hir(cx, body.value) {
- // replace `|| vec![]` with `Vec::new`
- span_lint_and_sugg(
- cx,
- REDUNDANT_CLOSURE,
- expr.span,
- "redundant closure",
- "replace the closure with `Vec::new`",
- "std::vec::Vec::new".into(),
- Applicability::MachineApplicable,
- );
- }
+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+ if let ExprKind::MethodCall(_method, receiver, args, _) = expr.kind {
+ for arg in args {
+ check_clousure(cx, Some(receiver), arg);
}
- // skip `foo(|| macro!())`
- return;
}
+ if let ExprKind::Call(func, args) = expr.kind {
+ check_clousure(cx, None, func);
+ for arg in args {
+ check_clousure(cx, None, arg);
+ }
+ }
+ }
+}
- let typeck = cx.typeck_results();
- let closure = if let ty::Closure(_, closure_subs) = typeck.expr_ty(expr).kind() {
- closure_subs.as_closure()
- } else {
- return;
- };
+#[allow(clippy::too_many_lines)]
+fn check_clousure<'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))
+ && matches!(c.fn_decl.output, FnRetTy::DefaultReturn(_))
+ && !expr.span.from_expansion()
+ {
+ cx.tcx.hir().body(c.body)
+ } else {
+ return;
+ };
- if is_adjusted(cx, body.value) {
- return;
+ if body.value.span.from_expansion() {
+ if body.params.is_empty() {
+ if let Some(VecArgs::Vec(&[])) = VecArgs::hir(cx, body.value) {
+ // replace `|| vec![]` with `Vec::new`
+ span_lint_and_sugg(
+ cx,
+ REDUNDANT_CLOSURE,
+ expr.span,
+ "redundant closure",
+ "replace the closure with `Vec::new`",
+ "std::vec::Vec::new".into(),
+ Applicability::MachineApplicable,
+ );
+ }
}
+ // skip `foo(|| macro!())`
+ return;
+ }
- match body.value.kind {
- ExprKind::Call(callee, args)
- if matches!(
- callee.kind,
- ExprKind::Path(QPath::Resolved(..) | QPath::TypeRelative(..))
- ) =>
+ if is_adjusted(cx, body.value) {
+ return;
+ }
+
+ let typeck = cx.typeck_results();
+ let closure = if let ty::Closure(_, closure_subs) = typeck.expr_ty(expr).kind() {
+ closure_subs.as_closure()
+ } else {
+ return;
+ };
+ let closure_sig = cx.tcx.signature_unclosure(closure.sig(), Safety::Safe).skip_binder();
+ match body.value.kind {
+ ExprKind::Call(callee, args)
+ if matches!(
+ callee.kind,
+ ExprKind::Path(QPath::Resolved(..) | QPath::TypeRelative(..))
+ ) =>
+ {
+ let callee_ty_raw = typeck.expr_ty(callee);
+ let callee_ty = callee_ty_raw.peel_refs();
+ if matches!(type_diagnostic_name(cx, callee_ty), Some(sym::Arc | sym::Rc))
+ || !check_inputs(typeck, body.params, None, args)
{
- let callee_ty_raw = typeck.expr_ty(callee);
- let callee_ty = callee_ty_raw.peel_refs();
- if matches!(type_diagnostic_name(cx, callee_ty), Some(sym::Arc | sym::Rc))
- || !check_inputs(typeck, body.params, None, args)
- {
- return;
- }
- let callee_ty_adjusted = typeck
- .expr_adjustments(callee)
- .last()
- .map_or(callee_ty, |a| a.target.peel_refs());
+ return;
+ }
+ let callee_ty_adjusted = typeck
+ .expr_adjustments(callee)
+ .last()
+ .map_or(callee_ty, |a| a.target.peel_refs());
- let sig = match callee_ty_adjusted.kind() {
- ty::FnDef(def, _) => {
- // Rewriting `x(|| f())` to `x(f)` where f is marked `#[track_caller]` moves the `Location`
- if cx.tcx.has_attr(*def, sym::track_caller) {
- return;
- }
+ let sig = match callee_ty_adjusted.kind() {
+ ty::FnDef(def, _) => {
+ // Rewriting `x(|| f())` to `x(f)` where f is marked `#[track_caller]` moves the `Location`
+ if cx.tcx.has_attr(*def, sym::track_caller) {
+ return;
+ }
- cx.tcx.fn_sig(def).skip_binder().skip_binder()
- },
- ty::FnPtr(sig) => sig.skip_binder(),
- ty::Closure(_, subs) => cx
- .tcx
- .signature_unclosure(subs.as_closure().sig(), Safety::Safe)
- .skip_binder(),
- _ => {
- if typeck.type_dependent_def_id(body.value.hir_id).is_some()
- && let subs = typeck.node_args(body.value.hir_id)
- && let output = typeck.expr_ty(body.value)
- && let ty::Tuple(tys) = *subs.type_at(1).kind()
- {
- cx.tcx.mk_fn_sig(tys, output, false, Safety::Safe, Abi::Rust)
- } else {
- return;
- }
- },
- };
- if check_sig(cx, closure, sig)
- && let generic_args = typeck.node_args(callee.hir_id)
- // Given some trait fn `fn f() -> ()` and some type `T: Trait`, `T::f` is not
- // `'static` unless `T: 'static`. The cast `T::f as fn()` will, however, result
- // in a type which is `'static`.
- // For now ignore all callee types which reference a type parameter.
- && !generic_args.types().any(|t| matches!(t.kind(), ty::Param(_)))
- {
- span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
- if let Some(mut snippet) = snippet_opt(cx, callee.span) {
- if path_to_local(callee).map_or(false, |l| {
- // FIXME: Do we really need this `local_used_in` check?
- // Isn't it checking something like... `callee(callee)`?
- // If somehow this check is needed, add some test for it,
- // 'cuz currently nothing changes after deleting this check.
- local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr)
- }) {
- match cx.tcx.infer_ctxt().build().err_ctxt().type_implements_fn_trait(
- cx.param_env,
- Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
- ty::PredicatePolarity::Positive,
- ) {
- // Mutable closure is used after current expr; we cannot consume it.
- Ok((ClosureKind::FnMut, _)) => snippet = format!("&mut {snippet}"),
- Ok((ClosureKind::Fn, _)) if !callee_ty_raw.is_ref() => {
- snippet = format!("&{snippet}");
- },
- _ => (),
- }
+ cx.tcx.fn_sig(def).skip_binder().skip_binder()
+ },
+ ty::FnPtr(sig) => sig.skip_binder(),
+ ty::Closure(_, subs) => cx
+ .tcx
+ .signature_unclosure(subs.as_closure().sig(), Safety::Safe)
+ .skip_binder(),
+ _ => {
+ if typeck.type_dependent_def_id(body.value.hir_id).is_some()
+ && let subs = typeck.node_args(body.value.hir_id)
+ && let output = typeck.expr_ty(body.value)
+ && let ty::Tuple(tys) = *subs.type_at(1).kind()
+ {
+ cx.tcx.mk_fn_sig(tys, output, false, Safety::Safe, Abi::Rust)
+ } else {
+ return;
+ }
+ },
+ };
+ if let Some(outer) = outer_receiver
+ && ty_has_static(sig.output())
+ && let generic_args = typeck.node_args(outer.hir_id)
+ // HACK: Given a closure in `T.method(|| f())`, where `fn f() -> U where U: 'static`, `T.method(f)`
+ // will succeed iff `T: 'static`. But the region of `T` is always erased by `typeck.expr_ty()` when
+ // T is a generic type. For example, return type of `Option<String>::as_deref()` is a generic.
+ // So we have a hack like this.
+ && generic_args.len() > 0
+ {
+ return;
+ }
+ if check_sig(closure_sig, sig)
+ && let generic_args = typeck.node_args(callee.hir_id)
+ // Given some trait fn `fn f() -> ()` and some type `T: Trait`, `T::f` is not
+ // `'static` unless `T: 'static`. The cast `T::f as fn()` will, however, result
+ // in a type which is `'static`.
+ // For now ignore all callee types which reference a type parameter.
+ && !generic_args.types().any(|t| matches!(t.kind(), ty::Param(_)))
+ {
+ span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
+ if let Some(mut snippet) = snippet_opt(cx, callee.span) {
+ if path_to_local(callee).map_or(false, |l| {
+ // FIXME: Do we really need this `local_used_in` check?
+ // Isn't it checking something like... `callee(callee)`?
+ // If somehow this check is needed, add some test for it,
+ // 'cuz currently nothing changes after deleting this check.
+ local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr)
+ }) {
+ match cx.tcx.infer_ctxt().build().err_ctxt().type_implements_fn_trait(
+ cx.param_env,
+ Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
+ ty::PredicatePolarity::Positive,
+ ) {
+ // Mutable closure is used after current expr; we cannot consume it.
+ Ok((ClosureKind::FnMut, _)) => snippet = format!("&mut {snippet}"),
+ Ok((ClosureKind::Fn, _)) if !callee_ty_raw.is_ref() => {
+ snippet = format!("&{snippet}");
+ },
+ _ => (),
}
- diag.span_suggestion(
- expr.span,
- "replace the closure with the function itself",
- snippet,
- Applicability::MachineApplicable,
- );
}
- });
- }
- },
- ExprKind::MethodCall(path, self_, args, _) if check_inputs(typeck, body.params, Some(self_), args) => {
- if let Some(method_def_id) = typeck.type_dependent_def_id(body.value.hir_id)
- && !cx.tcx.has_attr(method_def_id, sym::track_caller)
- && check_sig(cx, closure, cx.tcx.fn_sig(method_def_id).skip_binder().skip_binder())
- {
- span_lint_and_then(
- cx,
- REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
- expr.span,
- "redundant closure",
- |diag| {
- let args = typeck.node_args(body.value.hir_id);
- let caller = self_.hir_id.owner.def_id;
- let type_name = get_path_from_caller_to_method_type(cx.tcx, caller, method_def_id, args);
- diag.span_suggestion(
- expr.span,
- "replace the closure with the method itself",
- format!("{}::{}", type_name, path.ident.name),
- Applicability::MachineApplicable,
- );
- },
- );
- }
- },
- _ => (),
- }
+ diag.span_suggestion(
+ expr.span,
+ "replace the closure with the function itself",
+ snippet,
+ Applicability::MachineApplicable,
+ );
+ }
+ });
+ }
+ },
+ ExprKind::MethodCall(path, self_, args, _) if check_inputs(typeck, body.params, Some(self_), args) => {
+ if let Some(method_def_id) = typeck.type_dependent_def_id(body.value.hir_id)
+ && !cx.tcx.has_attr(method_def_id, sym::track_caller)
+ && check_sig(closure_sig, cx.tcx.fn_sig(method_def_id).skip_binder().skip_binder())
+ {
+ span_lint_and_then(
+ cx,
+ REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+ expr.span,
+ "redundant closure",
+ |diag| {
+ let args = typeck.node_args(body.value.hir_id);
+ let caller = self_.hir_id.owner.def_id;
+ let type_name = get_path_from_caller_to_method_type(cx.tcx, caller, method_def_id, args);
+ diag.span_suggestion(
+ expr.span,
+ "replace the closure with the method itself",
+ format!("{}::{}", type_name, path.ident.name),
+ Applicability::MachineApplicable,
+ );
+ },
+ );
+ }
+ },
+ _ => (),
}
}
@@ -251,12 +275,8 @@ fn check_inputs(
})
}
-fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure: ClosureArgs<TyCtxt<'tcx>>, call_sig: FnSig<'_>) -> bool {
- call_sig.safety == Safety::Safe
- && !has_late_bound_to_non_late_bound_regions(
- cx.tcx.signature_unclosure(closure.sig(), Safety::Safe).skip_binder(),
- call_sig,
- )
+fn check_sig<'tcx>(closure_sig: FnSig<'tcx>, call_sig: FnSig<'tcx>) -> bool {
+ call_sig.safety == Safety::Safe && !has_late_bound_to_non_late_bound_regions(closure_sig, call_sig)
}
/// This walks through both signatures and checks for any time a late-bound region is expected by an
@@ -265,7 +285,7 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure: ClosureArgs<TyCtxt<'tcx>>, c
/// This is needed because rustc is unable to late bind early-bound regions in a function signature.
fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'_>) -> bool {
fn check_region(from_region: Region<'_>, to_region: Region<'_>) -> bool {
- matches!(from_region.kind(), RegionKind::ReBound(..)) && !matches!(to_region.kind(), RegionKind::ReBound(..))
+ from_region.is_bound() && !to_region.is_bound()
}
fn check_subs(from_subs: &[GenericArg<'_>], to_subs: &[GenericArg<'_>]) -> bool {
@@ -318,3 +338,8 @@ fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'
.zip(to_sig.inputs_and_output)
.any(|(from_ty, to_ty)| check_ty(from_ty, to_ty))
}
+
+fn ty_has_static(ty: Ty<'_>) -> bool {
+ ty.walk()
+ .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(re) if re.is_static()))
+}
diff --git a/src/tools/clippy/clippy_lints/src/exhaustive_items.rs b/src/tools/clippy/clippy_lints/src/exhaustive_items.rs
index 0f4176ec73bb2..9bf3baba4b597 100644
--- a/src/tools/clippy/clippy_lints/src/exhaustive_items.rs
+++ b/src/tools/clippy/clippy_lints/src/exhaustive_items.rs
@@ -88,11 +88,11 @@ impl LateLintPass<'_> for ExhaustiveItems {
&& !attrs.iter().any(|a| a.has_name(sym::non_exhaustive))
&& fields.iter().all(|f| cx.tcx.visibility(f.def_id).is_public())
{
- let suggestion_span = item.span.shrink_to_lo();
- let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
span_lint_and_then(cx, lint, item.span, msg, |diag| {
+ let suggestion_span = item.span.shrink_to_lo();
+ let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
let sugg = format!("#[non_exhaustive]\n{indent}");
- diag.span_suggestion(
+ diag.span_suggestion_verbose(
suggestion_span,
"try adding #[non_exhaustive]",
sugg,
diff --git a/src/tools/clippy/clippy_lints/src/field_scoped_visibility_modifiers.rs b/src/tools/clippy/clippy_lints/src/field_scoped_visibility_modifiers.rs
index bb74e345703ff..95b8e882da792 100644
--- a/src/tools/clippy/clippy_lints/src/field_scoped_visibility_modifiers.rs
+++ b/src/tools/clippy/clippy_lints/src/field_scoped_visibility_modifiers.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_ast::ast::{Item, ItemKind, VisibilityKind};
use rustc_lint::{EarlyContext, EarlyLintPass};
use rustc_session::declare_lint_pass;
@@ -62,13 +62,15 @@ impl EarlyLintPass for FieldScopedVisibilityModifiers {
// pub(self) is equivalent to not using pub at all, so we ignore it
continue;
}
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
FIELD_SCOPED_VISIBILITY_MODIFIERS,
field.vis.span,
"scoped visibility modifier on a field",
- None,
- "consider making the field private and adding a scoped visibility method for it",
+ |diag| {
+ diag.help("consider making the field private and adding a scoped visibility method for it");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/float_literal.rs b/src/tools/clippy/clippy_lints/src/float_literal.rs
index 6adcd2235dc52..f095c1add91f8 100644
--- a/src/tools/clippy/clippy_lints/src/float_literal.rs
+++ b/src/tools/clippy/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,
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic.rs
index 68bdf88d0a7e4..bf4bcabfe8911 100644
--- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic.rs
+++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic.rs
@@ -1,9 +1,9 @@
use clippy_utils::consts::Constant::{Int, F32, F64};
-use clippy_utils::consts::{constant, constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::{
- eq_expr_value, get_parent_expr, higher, in_constant, is_inherent_method_call, is_no_std_crate, numeric_literal,
- peel_blocks, sugg,
+ eq_expr_value, get_parent_expr, higher, is_in_const_context, is_inherent_method_call, is_no_std_crate,
+ numeric_literal, peel_blocks, sugg,
};
use rustc_errors::Applicability;
use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
@@ -112,7 +112,7 @@ declare_lint_pass!(FloatingPointArithmetic => [
// Returns the specialized log method for a given base if base is constant
// and is one of 2, 10 and e
fn get_specialized_log_method(cx: &LateContext<'_>, base: &Expr<'_>) -> Option<&'static str> {
- if let Some(value) = constant(cx, cx.typeck_results(), base) {
+ if let Some(value) = ConstEvalCtxt::new(cx).eval(base) {
if F32(2.0) == value || F64(2.0) == value {
return Some("log2");
} else if F32(10.0) == value || F64(10.0) == value {
@@ -182,10 +182,8 @@ fn check_ln1p(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) {
rhs,
) = receiver.kind
{
- let recv = match (
- constant(cx, cx.typeck_results(), lhs),
- constant(cx, cx.typeck_results(), rhs),
- ) {
+ let ecx = ConstEvalCtxt::new(cx);
+ let recv = match (ecx.eval(lhs), ecx.eval(rhs)) {
(Some(value), _) if F32(1.0) == value || F64(1.0) == value => rhs,
(_, Some(value)) if F32(1.0) == value || F64(1.0) == value => lhs,
_ => return,
@@ -230,7 +228,7 @@ fn get_integer_from_float_constant(value: &Constant<'_>) -> Option<i32> {
fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
// Check receiver
- if let Some(value) = constant(cx, cx.typeck_results(), receiver) {
+ if let Some(value) = ConstEvalCtxt::new(cx).eval(receiver) {
if let Some(method) = if F32(f32_consts::E) == value || F64(f64_consts::E) == value {
Some("exp")
} else if F32(2.0) == value || F64(2.0) == value {
@@ -251,7 +249,7 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
}
// Check argument
- if let Some(value) = constant(cx, cx.typeck_results(), &args[0]) {
+ if let Some(value) = ConstEvalCtxt::new(cx).eval(&args[0]) {
let (lint, help, suggestion) = if F32(1.0 / 2.0) == value || F64(1.0 / 2.0) == value {
(
SUBOPTIMAL_FLOPS,
@@ -291,7 +289,7 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
}
fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
- if let Some(value) = constant(cx, cx.typeck_results(), &args[0]) {
+ if let Some(value) = ConstEvalCtxt::new(cx).eval(&args[0]) {
if value == Int(2) {
if let Some(parent) = get_parent_expr(cx, expr) {
if let Some(grandparent) = get_parent_expr(cx, parent) {
@@ -397,8 +395,9 @@ fn detect_hypot(cx: &LateContext<'_>, receiver: &Expr<'_>) -> Option<String> {
) = &add_rhs.kind
&& lmethod_name.as_str() == "powi"
&& rmethod_name.as_str() == "powi"
- && let Some(lvalue) = constant(cx, cx.typeck_results(), largs_1)
- && let Some(rvalue) = constant(cx, cx.typeck_results(), rargs_1)
+ && let ecx = ConstEvalCtxt::new(cx)
+ && let Some(lvalue) = ecx.eval(largs_1)
+ && let Some(rvalue) = ecx.eval(rargs_1)
&& Int(2) == lvalue
&& Int(2) == rvalue
{
@@ -438,7 +437,7 @@ fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
rhs,
) = expr.kind
&& cx.typeck_results().expr_ty(lhs).is_floating_point()
- && let Some(value) = constant(cx, cx.typeck_results(), rhs)
+ && let Some(value) = ConstEvalCtxt::new(cx).eval(rhs)
&& (F32(1.0) == value || F64(1.0) == value)
&& let ExprKind::MethodCall(path, self_arg, ..) = &lhs.kind
&& cx.typeck_results().expr_ty(self_arg).is_floating_point()
@@ -552,7 +551,7 @@ fn is_testing_negative(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -
/// Returns true iff expr is some zero literal
fn is_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
- match constant_simple(cx, cx.typeck_results(), expr) {
+ match ConstEvalCtxt::new(cx).eval_simple(expr) {
Some(Int(i)) => i == 0,
Some(F32(f)) => f == 0.0,
Some(F64(f)) => f == 0.0,
@@ -696,8 +695,9 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
mul_lhs,
mul_rhs,
) = &div_lhs.kind
- && let Some(rvalue) = constant(cx, cx.typeck_results(), div_rhs)
- && let Some(lvalue) = constant(cx, cx.typeck_results(), mul_rhs)
+ && let ecx = ConstEvalCtxt::new(cx)
+ && let Some(rvalue) = ecx.eval(div_rhs)
+ && let Some(lvalue) = ecx.eval(mul_rhs)
{
// TODO: also check for constant values near PI/180 or 180/PI
if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue)
@@ -753,7 +753,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
// All of these operations are currently not const and are in std.
- if in_constant(cx, expr.hir_id) {
+ if is_in_const_context(cx) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/format_push_string.rs b/src/tools/clippy/clippy_lints/src/format_push_string.rs
index a75538dd329b5..d05c5a01f41ce 100644
--- a/src/tools/clippy/clippy_lints/src/format_push_string.rs
+++ b/src/tools/clippy/clippy_lints/src/format_push_string.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_lang_item;
use clippy_utils::{higher, match_def_path, paths};
use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem, MatchSource};
@@ -81,13 +81,15 @@ impl<'tcx> LateLintPass<'tcx> for FormatPushString {
_ => return,
};
if is_format(cx, arg) {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
FORMAT_PUSH_STRING,
expr.span,
"`format!(..)` appended to existing `String`",
- None,
- "consider using `write!` to avoid the extra allocation",
+ |diag| {
+ diag.help("consider using `write!` to avoid the extra allocation");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs b/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs
index 9acb72b2e3729..6ab7bbc2dfc0c 100644
--- a/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs
+++ b/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs
@@ -1,7 +1,7 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::sugg::Sugg;
use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
-use clippy_utils::{in_constant, is_integer_literal};
+use clippy_utils::{is_in_const_context, is_integer_literal};
use rustc_errors::Applicability;
use rustc_hir::{def, Expr, ExprKind, LangItem, PrimTy, QPath, TyKind};
use rustc_lint::{LateContext, LateLintPass};
@@ -62,8 +62,8 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
&& matches!(prim_ty, PrimTy::Int(_) | PrimTy::Uint(_))
// do not lint in constant context, because the suggestion won't work.
- // NB: keep this check until a new `const_trait_impl` is available and stablized.
- && !in_constant(cx, exp.hir_id)
+ // NB: keep this check until a new `const_trait_impl` is available and stabilized.
+ && !is_in_const_context(cx)
{
let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind {
let ty = cx.typeck_results().expr_ty(expr);
diff --git a/src/tools/clippy/clippy_lints/src/if_let_mutex.rs b/src/tools/clippy/clippy_lints/src/if_let_mutex.rs
index b38cc7b36a123..1c52514a330d4 100644
--- a/src/tools/clippy/clippy_lints/src/if_let_mutex.rs
+++ b/src/tools/clippy/clippy_lints/src/if_let_mutex.rs
@@ -1,7 +1,7 @@
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::ty::is_type_diagnostic_item;
use clippy_utils::visitors::for_each_expr_without_closures;
-use clippy_utils::{higher, SpanlessEq};
+use clippy_utils::{eq_expr_value, higher};
use core::ops::ControlFlow;
use rustc_errors::Diag;
use rustc_hir::{Expr, ExprKind};
@@ -51,53 +51,45 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
if_else: Some(if_else),
..
}) = higher::IfLet::hir(cx, expr)
+ && let Some(op_mutex) = for_each_expr_without_closures(let_expr, |e| mutex_lock_call(cx, e, None))
+ && let Some(arm_mutex) =
+ for_each_expr_without_closures((if_then, if_else), |e| mutex_lock_call(cx, e, Some(op_mutex)))
{
- let is_mutex_lock = |e: &'tcx Expr<'tcx>| {
- if let Some(mutex) = is_mutex_lock_call(cx, e) {
- ControlFlow::Break(mutex)
- } else {
- ControlFlow::Continue(())
- }
+ let diag = |diag: &mut Diag<'_, ()>| {
+ diag.span_label(
+ op_mutex.span,
+ "this Mutex will remain locked for the entire `if let`-block...",
+ );
+ diag.span_label(
+ arm_mutex.span,
+ "... and is tried to lock again here, which will always deadlock.",
+ );
+ diag.help("move the lock call outside of the `if let ...` expression");
};
-
- let op_mutex = for_each_expr_without_closures(let_expr, is_mutex_lock);
- if let Some(op_mutex) = op_mutex {
- let arm_mutex = for_each_expr_without_closures((if_then, if_else), is_mutex_lock);
- if let Some(arm_mutex) = arm_mutex
- && SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex)
- {
- let diag = |diag: &mut Diag<'_, ()>| {
- diag.span_label(
- op_mutex.span,
- "this Mutex will remain locked for the entire `if let`-block...",
- );
- diag.span_label(
- arm_mutex.span,
- "... and is tried to lock again here, which will always deadlock.",
- );
- diag.help("move the lock call outside of the `if let ...` expression");
- };
- span_lint_and_then(
- cx,
- IF_LET_MUTEX,
- expr.span,
- "calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock",
- diag,
- );
- }
- }
+ span_lint_and_then(
+ cx,
+ IF_LET_MUTEX,
+ expr.span,
+ "calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock",
+ diag,
+ );
}
}
}
-fn is_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+fn mutex_lock_call<'tcx>(
+ cx: &LateContext<'tcx>,
+ expr: &'tcx Expr<'_>,
+ op_mutex: Option<&'tcx Expr<'_>>,
+) -> ControlFlow<&'tcx Expr<'tcx>> {
if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind
&& path.ident.as_str() == "lock"
&& let ty = cx.typeck_results().expr_ty(self_arg).peel_refs()
&& is_type_diagnostic_item(cx, ty, sym::Mutex)
+ && op_mutex.map_or(true, |op| eq_expr_value(cx, self_arg, op))
{
- Some(self_arg)
+ ControlFlow::Break(self_arg)
} else {
- None
+ ControlFlow::Continue(())
}
}
diff --git a/src/tools/clippy/clippy_lints/src/if_not_else.rs b/src/tools/clippy/clippy_lints/src/if_not_else.rs
index 2f6daeeb90d9d..0ebd8d0c237b6 100644
--- a/src/tools/clippy/clippy_lints/src/if_not_else.rs
+++ b/src/tools/clippy/clippy_lints/src/if_not_else.rs
@@ -1,7 +1,7 @@
//! lint on if branches that could be swapped so no `!` operation is necessary
//! on the condition
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_help;
use clippy_utils::is_else_clause;
use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
@@ -49,7 +49,7 @@ declare_clippy_lint! {
declare_lint_pass!(IfNotElse => [IF_NOT_ELSE]);
fn is_zero_const(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
- if let Some(value) = constant_simple(cx, cx.typeck_results(), expr) {
+ if let Some(value) = ConstEvalCtxt::new(cx).eval_simple(expr) {
return Constant::Int(0) == value;
}
false
diff --git a/src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs b/src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs
index 39ea16b05d1ad..0bca53c1536de 100644
--- a/src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs
+++ b/src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs
@@ -1,10 +1,12 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::eager_or_lazy::switch_to_eager_eval;
use clippy_utils::source::snippet_with_context;
use clippy_utils::sugg::Sugg;
-use clippy_utils::{contains_return, higher, in_constant, is_else_clause, is_res_lang_ctor, path_res, peel_blocks};
+use clippy_utils::{
+ contains_return, higher, is_else_clause, is_in_const_context, is_res_lang_ctor, path_res, peel_blocks,
+};
use rustc_errors::Applicability;
use rustc_hir::LangItem::{OptionNone, OptionSome};
use rustc_hir::{Expr, ExprKind};
@@ -76,37 +78,44 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
&& is_res_lang_ctor(cx, path_res(cx, then_call), OptionSome)
&& is_res_lang_ctor(cx, path_res(cx, peel_blocks(els)), OptionNone)
&& !is_else_clause(cx.tcx, expr)
- && !in_constant(cx, expr.hir_id)
+ && !is_in_const_context(cx)
&& !in_external_macro(cx.sess(), expr.span)
&& self.msrv.meets(msrvs::BOOL_THEN)
&& !contains_return(then_block.stmts)
{
- let mut app = Applicability::Unspecified;
- let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app)
- .maybe_par()
- .to_string();
- let arg_snip = snippet_with_context(cx, then_arg.span, ctxt, "[body]", &mut app).0;
- let mut method_body = if then_block.stmts.is_empty() {
- arg_snip.into_owned()
- } else {
- format!("{{ /* snippet */ {arg_snip} }}")
- };
let method_name = if switch_to_eager_eval(cx, expr) && self.msrv.meets(msrvs::BOOL_THEN_SOME) {
"then_some"
} else {
- method_body.insert_str(0, "|| ");
"then"
};
- let help =
- format!("consider using `bool::{method_name}` like: `{cond_snip}.{method_name}({method_body})`",);
- span_lint_and_help(
+ span_lint_and_then(
cx,
IF_THEN_SOME_ELSE_NONE,
expr.span,
format!("this could be simplified with `bool::{method_name}`"),
- None,
- help,
+ |diag| {
+ let mut app = Applicability::Unspecified;
+ let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app)
+ .maybe_par()
+ .to_string();
+ let arg_snip = snippet_with_context(cx, then_arg.span, ctxt, "[body]", &mut app).0;
+ let method_body = if let Some(first_stmt) = then_block.stmts.first() {
+ let (block_snippet, _) =
+ snippet_with_context(cx, first_stmt.span.until(then_arg.span), ctxt, "..", &mut app);
+ let closure = if method_name == "then" { "|| " } else { "" };
+ format!("{closure} {{ {block_snippet}; {arg_snip} }}")
+ } else {
+ arg_snip.into_owned()
+ };
+
+ diag.span_suggestion(
+ expr.span,
+ "try",
+ format!("{cond_snip}.{method_name}({method_body})"),
+ app,
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/implicit_hasher.rs b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs
index 344a04e6e7e82..e56f33f8dcfe2 100644
--- a/src/tools/clippy/clippy_lints/src/implicit_hasher.rs
+++ b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs
@@ -1,7 +1,7 @@
use std::borrow::Cow;
use std::collections::BTreeMap;
-use rustc_errors::Diag;
+use rustc_errors::{Applicability, Diag};
use rustc_hir as hir;
use rustc_hir::intravisit::{walk_body, walk_expr, walk_inf, walk_ty, Visitor};
use rustc_hir::{Body, Expr, ExprKind, GenericArg, Item, ItemKind, QPath, TyKind};
@@ -13,7 +13,7 @@ use rustc_session::declare_lint_pass;
use rustc_span::symbol::sym;
use rustc_span::Span;
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::{snippet, IntoSpan, SpanRangeExt};
use clippy_utils::ty::is_type_diagnostic_item;
@@ -77,33 +77,32 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
&generics_snip[1..generics_snip.len() - 1]
};
- multispan_sugg(
- diag,
- "consider adding a type parameter",
- vec![
- (
- generics_suggestion_span,
- format!(
- "<{generics_snip}{}S: ::std::hash::BuildHasher{}>",
- if generics_snip.is_empty() { "" } else { ", " },
- if vis.suggestions.is_empty() {
- ""
- } else {
- // request users to add `Default` bound so that generic constructors can be used
- " + Default"
- },
- ),
- ),
- (
- target.span(),
- format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
+ let mut suggestions = vec![
+ (
+ generics_suggestion_span,
+ format!(
+ "<{generics_snip}{}S: ::std::hash::BuildHasher{}>",
+ if generics_snip.is_empty() { "" } else { ", " },
+ if vis.suggestions.is_empty() {
+ ""
+ } else {
+ // request users to add `Default` bound so that generic constructors can be used
+ " + Default"
+ },
),
- ],
+ ),
+ (
+ target.span(),
+ format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
+ ),
+ ];
+ suggestions.extend(vis.suggestions);
+
+ diag.multipart_suggestion(
+ "add a type parameter for `BuildHasher`",
+ suggestions,
+ Applicability::MaybeIncorrect,
);
-
- if !vis.suggestions.is_empty() {
- multispan_sugg(diag, "...and use generic constructor", vis.suggestions);
- }
}
if !cx.effective_visibilities.is_exported(item.owner_id.def_id) {
diff --git a/src/tools/clippy/clippy_lints/src/implicit_return.rs b/src/tools/clippy/clippy_lints/src/implicit_return.rs
index a102b434cfabb..b926e1e62ba0c 100644
--- a/src/tools/clippy/clippy_lints/src/implicit_return.rs
+++ b/src/tools/clippy/clippy_lints/src/implicit_return.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::{snippet_with_applicability, snippet_with_context, wal
use clippy_utils::visitors::for_each_expr_without_closures;
use clippy_utils::{get_async_fn_body, is_async_fn, is_from_proc_macro};
use core::ops::ControlFlow;
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, SuggestionStyle};
use rustc_hir::intravisit::FnKind;
use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, FnRetTy, HirId};
use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -45,8 +45,6 @@ declare_clippy_lint! {
declare_lint_pass!(ImplicitReturn => [IMPLICIT_RETURN]);
fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
- let mut app = Applicability::MachineApplicable;
- let snip = snippet_with_applicability(cx, span, "..", &mut app);
span_lint_hir_and_then(
cx,
IMPLICIT_RETURN,
@@ -54,14 +52,20 @@ fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
span,
"missing `return` statement",
|diag| {
- diag.span_suggestion(span, "add `return` as shown", format!("return {snip}"), app);
+ let mut app = Applicability::MachineApplicable;
+ let snip = snippet_with_applicability(cx, span, "..", &mut app);
+ diag.span_suggestion_with_style(
+ span,
+ "add `return` as shown",
+ format!("return {snip}"),
+ app,
+ SuggestionStyle::ShowAlways,
+ );
},
);
}
fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: Span, expr_span: Span) {
- let mut app = Applicability::MachineApplicable;
- let snip = snippet_with_context(cx, expr_span, break_span.ctxt(), "..", &mut app).0;
span_lint_hir_and_then(
cx,
IMPLICIT_RETURN,
@@ -69,11 +73,14 @@ fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: Span, exp
break_span,
"missing `return` statement",
|diag| {
- diag.span_suggestion(
+ let mut app = Applicability::MachineApplicable;
+ let snip = snippet_with_context(cx, expr_span, break_span.ctxt(), "..", &mut app).0;
+ diag.span_suggestion_with_style(
break_span,
"change `break` to `return` as shown",
format!("return {snip}"),
app,
+ SuggestionStyle::ShowAlways,
);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs b/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs
index f225c6e7f049f..dd5908553e59b 100644
--- a/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs
+++ b/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::get_parent_expr;
use clippy_utils::source::snippet_with_context;
@@ -117,11 +117,11 @@ fn get_int_max(ty: Ty<'_>) -> Option<u128> {
fn get_const<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(u128, BinOpKind, &'tcx Expr<'tcx>)> {
if let ExprKind::Binary(op, l, r) = expr.kind {
- let tr = cx.typeck_results();
- if let Some(Constant::Int(c)) = constant(cx, tr, r) {
+ let ecx = ConstEvalCtxt::new(cx);
+ if let Some(Constant::Int(c)) = ecx.eval(r) {
return Some((c, op.node, l));
};
- if let Some(Constant::Int(c)) = constant(cx, tr, l) {
+ if let Some(Constant::Int(c)) = ecx.eval(l) {
return Some((c, invert_op(op.node)?, r));
}
}
diff --git a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
index 12ca6d43b27bc..0ef5b803a89d6 100644
--- a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
+++ b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
@@ -55,7 +55,6 @@ impl IncompatibleMsrv {
}
}
- #[allow(clippy::cast_lossless)]
fn get_def_id_version(&mut self, tcx: TyCtxt<'_>, def_id: DefId) -> RustcVersion {
if let Some(version) = self.is_above_msrv.get(&def_id) {
return *version;
@@ -67,9 +66,9 @@ impl IncompatibleMsrv {
since: StableSince::Version(version),
..
} => Some(RustcVersion::new(
- version.major as _,
- version.minor as _,
- version.patch as _,
+ version.major.into(),
+ version.minor.into(),
+ version.patch.into(),
)),
_ => None,
}) {
diff --git a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
index 526b4e1fba0e9..2f9661c9ea385 100644
--- a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
+++ b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
@@ -1,6 +1,6 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::higher::IfLet;
use clippy_utils::ty::is_copy;
@@ -246,7 +246,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SliceIndexLintingVisitor<'a, 'tcx> {
&& let parent_id = cx.tcx.parent_hir_id(expr.hir_id)
&& let hir::Node::Expr(parent_expr) = cx.tcx.hir_node(parent_id)
&& let hir::ExprKind::Index(_, index_expr, _) = parent_expr.kind
- && let Some(Constant::Int(index_value)) = constant(cx, cx.typeck_results(), index_expr)
+ && let Some(Constant::Int(index_value)) = ConstEvalCtxt::new(cx).eval(index_expr)
&& let Ok(index_value) = index_value.try_into()
&& index_value < max_suggested_slice
diff --git a/src/tools/clippy/clippy_lints/src/indexing_slicing.rs b/src/tools/clippy/clippy_lints/src/indexing_slicing.rs
index 6729c7c8d1018..3ac50b8f1fba5 100644
--- a/src/tools/clippy/clippy_lints/src/indexing_slicing.rs
+++ b/src/tools/clippy/clippy_lints/src/indexing_slicing.rs
@@ -1,7 +1,7 @@
//! lint on indexing and slicing operations
use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
use clippy_utils::ty::{deref_chain, get_adt_inherent_method};
use clippy_utils::{higher, is_from_proc_macro};
@@ -70,8 +70,6 @@ declare_clippy_lint! {
///
/// Use instead:
/// ```no_run
- /// # #![allow(unused)]
- ///
/// # let x = vec![0; 5];
/// # let y = [0, 1, 2, 3];
/// x.get(2);
@@ -179,7 +177,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
return;
}
// Index is a constant uint.
- if let Some(constant) = constant(cx, cx.typeck_results(), index) {
+ if let Some(constant) = ConstEvalCtxt::new(cx).eval(index) {
// only `usize` index is legal in rust array index
// leave other type to rustc
if let Constant::Int(off) = constant
@@ -217,14 +215,15 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
/// Returns a tuple of options with the start and end (exclusive) values of
/// the range. If the start or end is not constant, None is returned.
fn to_const_range(cx: &LateContext<'_>, range: higher::Range<'_>, array_size: u128) -> (Option<u128>, Option<u128>) {
- let s = range.start.map(|expr| constant(cx, cx.typeck_results(), expr));
+ let ecx = ConstEvalCtxt::new(cx);
+ let s = range.start.map(|expr| ecx.eval(expr));
let start = match s {
Some(Some(Constant::Int(x))) => Some(x),
Some(_) => None,
None => Some(0),
};
- let e = range.end.map(|expr| constant(cx, cx.typeck_results(), expr));
+ let e = range.end.map(|expr| ecx.eval(expr));
let end = match e {
Some(Some(Constant::Int(x))) => {
if range.limits == RangeLimits::Closed {
diff --git a/src/tools/clippy/clippy_lints/src/infinite_iter.rs b/src/tools/clippy/clippy_lints/src/infinite_iter.rs
index fa7e7f6b76d16..676d50c4951b1 100644
--- a/src/tools/clippy/clippy_lints/src/infinite_iter.rs
+++ b/src/tools/clippy/clippy_lints/src/infinite_iter.rs
@@ -41,7 +41,6 @@ declare_clippy_lint! {
/// ### Example
/// ```no_run
/// let infinite_iter = 0..;
- /// # #[allow(unused)]
/// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
/// ```
#[clippy::version = "pre 1.29.0"]
diff --git a/src/tools/clippy/clippy_lints/src/inherent_impl.rs b/src/tools/clippy/clippy_lints/src/inherent_impl.rs
index 0d3786dad4b1e..9eed7aa924339 100644
--- a/src/tools/clippy/clippy_lints/src/inherent_impl.rs
+++ b/src/tools/clippy/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");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/invalid_upcast_comparisons.rs b/src/tools/clippy/clippy_lints/src/invalid_upcast_comparisons.rs
index 30f2285bdd235..1929fbded3b56 100644
--- a/src/tools/clippy/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/src/tools/clippy/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -7,7 +7,7 @@ use rustc_span::Span;
use clippy_utils::comparisons;
use clippy_utils::comparisons::Rel;
-use clippy_utils::consts::{constant_full_int, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, FullInt};
use clippy_utils::diagnostics::span_lint;
use clippy_utils::source::snippet;
@@ -95,7 +95,7 @@ fn upcast_comparison_bounds_err<'tcx>(
invert: bool,
) {
if let Some((lb, ub)) = lhs_bounds {
- if let Some(norm_rhs_val) = constant_full_int(cx, cx.typeck_results(), rhs) {
+ if let Some(norm_rhs_val) = ConstEvalCtxt::new(cx).eval_full_int(rhs) {
if rel == Rel::Eq || rel == Rel::Ne {
if norm_rhs_val < lb || norm_rhs_val > ub {
err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
diff --git a/src/tools/clippy/clippy_lints/src/large_include_file.rs b/src/tools/clippy/clippy_lints/src/large_include_file.rs
index c67da689aaee0..f2f841dcec33d 100644
--- a/src/tools/clippy/clippy_lints/src/large_include_file.rs
+++ b/src/tools/clippy/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
+ ));
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/let_underscore.rs b/src/tools/clippy/clippy_lints/src/let_underscore.rs
index 8fa63f3e8fde0..b522c22a44d70 100644
--- a/src/tools/clippy/clippy_lints/src/let_underscore.rs
+++ b/src/tools/clippy/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",
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/lib.deprecated.rs b/src/tools/clippy/clippy_lints/src/lib.deprecated.rs
deleted file mode 100644
index 0d21261822dd0..0000000000000
--- a/src/tools/clippy/clippy_lints/src/lib.deprecated.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-{
- store.register_removed(
- "clippy::should_assert_eq",
- "`assert!()` will be more flexible with RFC 2011",
- );
- store.register_removed(
- "clippy::extend_from_slice",
- "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice",
- );
- store.register_removed(
- "clippy::range_step_by_zero",
- "`iterator.step_by(0)` panics nowadays",
- );
- store.register_removed(
- "clippy::unstable_as_slice",
- "`Vec::as_slice` has been stabilized in 1.7",
- );
- store.register_removed(
- "clippy::unstable_as_mut_slice",
- "`Vec::as_mut_slice` has been stabilized in 1.7",
- );
- store.register_removed(
- "clippy::misaligned_transmute",
- "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
- );
- store.register_removed(
- "clippy::assign_ops",
- "using compound assignment operators (e.g., `+=`) is harmless",
- );
- store.register_removed(
- "clippy::if_let_redundant_pattern_matching",
- "this lint has been changed to redundant_pattern_matching",
- );
- store.register_removed(
- "clippy::unsafe_vector_initialization",
- "the replacement suggested by this lint had substantially different behavior",
- );
- store.register_removed(
- "clippy::unused_collect",
- "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint",
- );
- store.register_removed(
- "clippy::replace_consts",
- "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants",
- );
- store.register_removed(
- "clippy::regex_macro",
- "the regex! macro has been removed from the regex crate in 2018",
- );
- store.register_removed(
- "clippy::find_map",
- "this lint has been replaced by `manual_find_map`, a more specific lint",
- );
- store.register_removed(
- "clippy::filter_map",
- "this lint has been replaced by `manual_filter_map`, a more specific lint",
- );
- store.register_removed(
- "clippy::pub_enum_variant_names",
- "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items",
- );
- store.register_removed(
- "clippy::wrong_pub_self_convention",
- "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items",
- );
- store.register_removed(
- "clippy::maybe_misused_cfg",
- "this lint has been replaced by `unexpected_cfgs`",
- );
- store.register_removed(
- "clippy::mismatched_target_os",
- "this lint has been replaced by `unexpected_cfgs`",
- );
-}
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
index a388b6b2eaab3..ce13a9afef5b0 100644
--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -13,7 +13,6 @@
#![feature(stmt_expr_attributes)]
#![feature(unwrap_infallible)]
#![recursion_limit = "512"]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![allow(
clippy::missing_docs_in_private_items,
clippy::must_use_candidate,
@@ -64,13 +63,11 @@ extern crate clippy_utils;
#[macro_use]
extern crate declare_clippy_lint;
-#[cfg(feature = "internal")]
-pub mod deprecated_lints;
#[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
mod utils;
mod declared_lints;
-mod renamed_lints;
+mod deprecated_lints;
// begin lints modules, do not remove this comment, it’s used in `update_lints`
mod absolute_paths;
@@ -372,6 +369,7 @@ mod unsafe_removed_from_name;
mod unused_async;
mod unused_io_amount;
mod unused_peekable;
+mod unused_result_ok;
mod unused_rounding;
mod unused_self;
mod unused_unit;
@@ -495,7 +493,7 @@ pub fn explain(name: &str) -> i32 {
// Check if the lint has configuration
let mut mdconf = get_configuration_metadata();
let name = name.to_ascii_lowercase();
- mdconf.retain(|cconf| cconf.lints.contains(&name));
+ mdconf.retain(|cconf| cconf.lints.contains(&&*name));
if !mdconf.is_empty() {
println!("### Configuration for {}:\n", info.lint.name_lower());
for conf in mdconf {
@@ -531,10 +529,14 @@ fn register_categories(store: &mut rustc_lint::LintStore) {
/// Used in `./src/driver.rs`.
#[expect(clippy::too_many_lines)]
pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
- register_removed_non_tool_lints(store);
register_categories(store);
- include!("lib.deprecated.rs");
+ for (old_name, new_name) in deprecated_lints::RENAMED {
+ store.register_renamed(old_name, new_name);
+ }
+ for (name, reason) in deprecated_lints::DEPRECATED {
+ store.register_removed(name, reason);
+ }
#[cfg(feature = "internal")]
{
@@ -669,6 +671,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
store.register_late_pass(move |_| Box::new(missing_doc::MissingDoc::new(conf)));
store.register_late_pass(|_| Box::new(missing_inline::MissingInline));
store.register_late_pass(move |_| Box::new(exhaustive_items::ExhaustiveItems));
+ store.register_late_pass(|_| Box::new(unused_result_ok::UnusedResultOk));
store.register_late_pass(|_| Box::new(match_result_ok::MatchResultOk));
store.register_late_pass(|_| Box::new(partialeq_ne_impl::PartialEqNeImpl));
store.register_late_pass(|_| Box::new(unused_io_amount::UnusedIoAmount));
@@ -818,7 +821,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
store.register_late_pass(move |_| Box::new(manual_retain::ManualRetain::new(conf)));
store.register_late_pass(move |_| Box::new(manual_rotate::ManualRotate));
store.register_late_pass(move |_| Box::new(operators::Operators::new(conf)));
- store.register_late_pass(|_| Box::<std_instead_of_core::StdReexports>::default());
+ store.register_late_pass(move |_| Box::new(std_instead_of_core::StdReexports::new(conf)));
store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(conf)));
store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(conf)));
@@ -907,68 +910,8 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
store.register_late_pass(move |_| Box::new(macro_metavars_in_unsafe::ExprMetavarsInUnsafe::new(conf)));
store.register_late_pass(move |_| Box::new(string_patterns::StringPatterns::new(conf)));
store.register_early_pass(|| Box::new(field_scoped_visibility_modifiers::FieldScopedVisibilityModifiers));
- store.register_late_pass(|_| Box::new(set_contains_or_insert::HashsetInsertAfterContains));
+ store.register_late_pass(|_| Box::new(set_contains_or_insert::SetContainsOrInsert));
store.register_early_pass(|| Box::new(byte_char_slices::ByteCharSlice));
store.register_early_pass(|| Box::new(cfg_not_test::CfgNotTest));
// add lints here, do not remove this comment, it's used in `new_lint`
}
-
-#[rustfmt::skip]
-fn register_removed_non_tool_lints(store: &mut rustc_lint::LintStore) {
- store.register_removed(
- "should_assert_eq",
- "`assert!()` will be more flexible with RFC 2011",
- );
- store.register_removed(
- "extend_from_slice",
- "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice",
- );
- store.register_removed(
- "range_step_by_zero",
- "`iterator.step_by(0)` panics nowadays",
- );
- store.register_removed(
- "unstable_as_slice",
- "`Vec::as_slice` has been stabilized in 1.7",
- );
- store.register_removed(
- "unstable_as_mut_slice",
- "`Vec::as_mut_slice` has been stabilized in 1.7",
- );
- store.register_removed(
- "misaligned_transmute",
- "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
- );
- store.register_removed(
- "assign_ops",
- "using compound assignment operators (e.g., `+=`) is harmless",
- );
- store.register_removed(
- "if_let_redundant_pattern_matching",
- "this lint has been changed to redundant_pattern_matching",
- );
- store.register_removed(
- "unsafe_vector_initialization",
- "the replacement suggested by this lint had substantially different behavior",
- );
- store.register_removed(
- "reverse_range_loop",
- "this lint is now included in reversed_empty_ranges",
- );
-}
-
-/// Register renamed lints.
-///
-/// Used in `./src/driver.rs`.
-pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
- for (old_name, new_name) in renamed_lints::RENAMED_LINTS {
- ls.register_renamed(old_name, new_name);
- }
-}
-
-// only exists to let the dogfood integration test works.
-// Don't run clippy as an executable directly
-#[allow(dead_code)]
-fn main() {
- panic!("Please use the cargo-clippy executable");
-}
diff --git a/src/tools/clippy/clippy_lints/src/literal_representation.rs b/src/tools/clippy/clippy_lints/src/literal_representation.rs
index b685d1dad1a75..259e4d6c08fb7 100644
--- a/src/tools/clippy/clippy_lints/src/literal_representation.rs
+++ b/src/tools/clippy/clippy_lints/src/literal_representation.rs
@@ -2,13 +2,13 @@
//! floating-point literal expressions.
use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::numeric_literal::{NumericLiteral, Radix};
use clippy_utils::source::snippet_opt;
use rustc_ast::ast::{Expr, ExprKind, LitKind};
use rustc_ast::token;
use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
use rustc_middle::lint::in_external_macro;
use rustc_session::impl_lint_pass;
use rustc_span::Span;
@@ -159,63 +159,39 @@ enum WarningType {
}
impl WarningType {
- fn display(&self, suggested_format: String, cx: &EarlyContext<'_>, span: Span) {
+ fn lint_and_text(&self) -> (&'static Lint, &'static str, &'static str) {
match self {
- Self::MistypedLiteralSuffix => span_lint_and_sugg(
- cx,
+ Self::MistypedLiteralSuffix => (
MISTYPED_LITERAL_SUFFIXES,
- span,
"mistyped literal suffix",
"did you mean to write",
- suggested_format,
- Applicability::MaybeIncorrect,
),
- Self::UnreadableLiteral => span_lint_and_sugg(
- cx,
- UNREADABLE_LITERAL,
- span,
- "long literal lacking separators",
- "consider",
- suggested_format,
- Applicability::MachineApplicable,
- ),
- Self::LargeDigitGroups => span_lint_and_sugg(
- cx,
- LARGE_DIGIT_GROUPS,
- span,
- "digit groups should be smaller",
- "consider",
- suggested_format,
- Applicability::MachineApplicable,
- ),
- Self::InconsistentDigitGrouping => span_lint_and_sugg(
- cx,
+ Self::UnreadableLiteral => (UNREADABLE_LITERAL, "long literal lacking separators", "consider"),
+ Self::LargeDigitGroups => (LARGE_DIGIT_GROUPS, "digit groups should be smaller", "consider"),
+ Self::InconsistentDigitGrouping => (
INCONSISTENT_DIGIT_GROUPING,
- span,
"digits grouped inconsistently by underscores",
"consider",
- suggested_format,
- Applicability::MachineApplicable,
),
- Self::DecimalRepresentation => span_lint_and_sugg(
- cx,
+ Self::DecimalRepresentation => (
DECIMAL_LITERAL_REPRESENTATION,
- span,
"integer literal has a better hexadecimal representation",
"consider",
- suggested_format,
- Applicability::MachineApplicable,
),
- Self::UnusualByteGroupings => span_lint_and_sugg(
- cx,
+ Self::UnusualByteGroupings => (
UNUSUAL_BYTE_GROUPINGS,
- span,
"digits of hex, binary or octal literal not in groups of equal size",
"consider",
- suggested_format,
- Applicability::MachineApplicable,
),
- };
+ }
+ }
+
+ fn display(&self, num_lit: &NumericLiteral<'_>, cx: &EarlyContext<'_>, span: Span) {
+ let (lint, message, try_msg) = self.lint_and_text();
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, lint, span, message, |diag| {
+ diag.span_suggestion(span, try_msg, num_lit.format(), Applicability::MaybeIncorrect);
+ });
}
}
@@ -293,7 +269,7 @@ impl LiteralDigitGrouping {
WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => true,
};
if should_warn {
- warning_type.display(num_lit.format(), cx, span);
+ warning_type.display(&num_lit, cx, span);
}
}
}
@@ -346,11 +322,14 @@ impl LiteralDigitGrouping {
}
}
*part = main_part;
- let mut sugg = num_lit.format();
- sugg.push('_');
- sugg.push(missing_char);
- sugg.push_str(last_group);
- WarningType::MistypedLiteralSuffix.display(sugg, cx, span);
+ let (lint, message, try_msg) = WarningType::MistypedLiteralSuffix.lint_and_text();
+ span_lint_and_then(cx, lint, span, message, |diag| {
+ let mut sugg = num_lit.format();
+ sugg.push('_');
+ sugg.push(missing_char);
+ sugg.push_str(last_group);
+ diag.span_suggestion(span, try_msg, sugg, Applicability::MaybeIncorrect);
+ });
false
} else {
true
@@ -471,7 +450,7 @@ impl DecimalLiteralRepresentation {
let hex = format!("{val:#X}");
let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
let _: Result<(), ()> = Self::do_lint(num_lit.integer).map_err(|warning_type| {
- warning_type.display(num_lit.format(), cx, span);
+ warning_type.display(&num_lit, cx, span);
});
}
}
diff --git a/src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs b/src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs
index f0ee64d714e05..73a23615c2dc7 100644
--- a/src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -2,6 +2,7 @@ use super::{make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT
use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::{get_enclosing_block, is_integer_const};
+use rustc_ast::Label;
use rustc_errors::Applicability;
use rustc_hir::intravisit::{walk_block, walk_expr};
use rustc_hir::{Expr, Pat};
@@ -17,6 +18,7 @@ pub(super) fn check<'tcx>(
arg: &'tcx Expr<'_>,
body: &'tcx Expr<'_>,
expr: &'tcx Expr<'_>,
+ label: Option<Label>,
) {
// Look for variables that are incremented once per loop iteration.
let mut increment_visitor = IncrementVisitor::new(cx);
@@ -34,7 +36,7 @@ pub(super) fn check<'tcx>(
{
let mut applicability = Applicability::MaybeIncorrect;
let span = expr.span.with_hi(arg.span.hi());
-
+ let loop_label = label.map_or(String::new(), |l| format!("{}: ", l.ident.name));
let int_name = match ty.map(Ty::kind) {
// usize or inferred
Some(ty::Uint(UintTy::Usize)) | None => {
@@ -45,7 +47,7 @@ pub(super) fn check<'tcx>(
format!("the variable `{name}` is used as a loop counter"),
"consider using",
format!(
- "for ({name}, {}) in {}.enumerate()",
+ "{loop_label}for ({name}, {}) in {}.enumerate()",
snippet_with_applicability(cx, pat.span, "item", &mut applicability),
make_iterator_snippet(cx, arg, &mut applicability),
),
@@ -68,7 +70,7 @@ pub(super) fn check<'tcx>(
span,
"consider using",
format!(
- "for ({name}, {}) in (0_{int_name}..).zip({})",
+ "{loop_label}for ({name}, {}) in (0_{int_name}..).zip({})",
snippet_with_applicability(cx, pat.span, "item", &mut applicability),
make_iterator_snippet(cx, arg, &mut applicability),
),
diff --git a/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs b/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs
index 6922533fbe9d3..185d834becafc 100644
--- a/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs
@@ -1,8 +1,9 @@
use super::FOR_KV_MAP;
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet;
use clippy_utils::ty::is_type_diagnostic_item;
use clippy_utils::{pat_is_wild, sugg};
+use rustc_errors::Applicability;
use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
use rustc_lint::LateContext;
use rustc_middle::ty;
@@ -40,13 +41,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
format!("you seem to want to iterate on a map's {kind}s"),
|diag| {
let map = sugg::Sugg::hir(cx, arg, "map");
- multispan_sugg(
- diag,
+ diag.multipart_suggestion(
"use the corresponding method",
vec![
(pat_span, snippet(cx, new_pat_span, kind).into_owned()),
(arg_span, format!("{}.{kind}s{mutbl}()", map.maybe_par())),
],
+ Applicability::MachineApplicable,
);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs b/src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs
index b00a082bb8cf9..57434f3554443 100644
--- a/src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet;
use clippy_utils::{match_def_path, paths, SpanlessEq};
use rustc_errors::Applicability;
@@ -38,11 +38,10 @@ fn report_lint(cx: &LateContext<'_>, pop_span: Span, pop_stmt_kind: PopStmt<'_>,
};
let loop_replacement = format!("while let Some({}) = {}.pop()", pat, snippet(cx, receiver_span, ".."));
- multispan_sugg_with_applicability(
- diag,
+ diag.multipart_suggestion(
"consider using a `while..let` loop",
+ vec![(loop_span, loop_replacement), (pop_span, pop_replacement)],
Applicability::MachineApplicable,
- [(loop_span, loop_replacement), (pop_span, pop_replacement)],
);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/loops/mod.rs b/src/tools/clippy/clippy_lints/src/loops/mod.rs
index 7c2a8098af287..92ccc0cc0a15e 100644
--- a/src/tools/clippy/clippy_lints/src/loops/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/mod.rs
@@ -25,6 +25,7 @@ mod while_let_on_iterator;
use clippy_config::msrvs::Msrv;
use clippy_config::Conf;
use clippy_utils::higher;
+use rustc_ast::Label;
use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
use rustc_lint::{LateContext, LateLintPass};
use rustc_session::impl_lint_pass;
@@ -448,7 +449,7 @@ declare_clippy_lint! {
#[clippy::version = "1.80.0"]
pub WHILE_FLOAT,
nursery,
- "while loops comaparing floating point values"
+ "while loops comparing floating point values"
}
declare_clippy_lint! {
@@ -760,6 +761,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
body,
loop_id,
span,
+ label,
}) = for_loop
{
// we don't want to check expanded macros
@@ -768,7 +770,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
if body.span.from_expansion() {
return;
}
- self.check_for_loop(cx, pat, arg, body, expr, span);
+ self.check_for_loop(cx, pat, arg, body, expr, span, label);
if let ExprKind::Block(block, _) = body.kind {
never_loop::check(cx, block, loop_id, span, for_loop.as_ref());
}
@@ -808,6 +810,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
}
impl Loops {
+ #[allow(clippy::too_many_arguments)]
fn check_for_loop<'tcx>(
&self,
cx: &LateContext<'tcx>,
@@ -816,11 +819,12 @@ impl Loops {
body: &'tcx Expr<'_>,
expr: &'tcx Expr<'_>,
span: Span,
+ label: Option<Label>,
) {
let is_manual_memcpy_triggered = manual_memcpy::check(cx, pat, arg, body, expr);
if !is_manual_memcpy_triggered {
needless_range_loop::check(cx, pat, arg, body, expr);
- explicit_counter_loop::check(cx, pat, arg, body, expr);
+ explicit_counter_loop::check(cx, pat, arg, body, expr, label);
}
self.check_for_loop_arg(cx, pat, arg);
for_kv_map::check(cx, pat, arg, body);
diff --git a/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs b/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs
index de7ec81bc0108..e18e4374667de 100644
--- a/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs
@@ -1,11 +1,12 @@
use super::NEEDLESS_RANGE_LOOP;
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet;
use clippy_utils::ty::has_iter_method;
use clippy_utils::visitors::is_local_used;
use clippy_utils::{contains_name, higher, is_integer_const, sugg, SpanlessEq};
use rustc_ast::ast;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::intravisit::{walk_expr, Visitor};
use rustc_hir::{BinOpKind, BorrowKind, Closure, Expr, ExprKind, HirId, Mutability, Pat, PatKind, QPath};
@@ -145,8 +146,7 @@ pub(super) fn check<'tcx>(
arg.span,
format!("the loop variable `{}` is used to index `{indexed}`", ident.name),
|diag| {
- multispan_sugg(
- diag,
+ diag.multipart_suggestion(
"consider using an iterator and enumerate()",
vec![
(pat.span, format!("({}, <item>)", ident.name)),
@@ -155,6 +155,7 @@ pub(super) fn check<'tcx>(
format!("{indexed}.{method}().enumerate(){method_1}{method_2}"),
),
],
+ Applicability::HasPlaceholders,
);
},
);
@@ -171,10 +172,10 @@ pub(super) fn check<'tcx>(
arg.span,
format!("the loop variable `{}` is only used to index `{indexed}`", ident.name),
|diag| {
- multispan_sugg(
- diag,
+ diag.multipart_suggestion(
"consider using an iterator",
vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
+ Applicability::HasPlaceholders,
);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/loops/unused_enumerate_index.rs b/src/tools/clippy/clippy_lints/src/loops/unused_enumerate_index.rs
index 40ccfec02be58..51e21aa9734ed 100644
--- a/src/tools/clippy/clippy_lints/src/loops/unused_enumerate_index.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/unused_enumerate_index.rs
@@ -1,7 +1,8 @@
use super::UNUSED_ENUMERATE_INDEX;
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet;
use clippy_utils::{pat_is_wild, sugg};
+use rustc_errors::Applicability;
use rustc_hir::def::DefKind;
use rustc_hir::{Expr, ExprKind, Pat, PatKind};
use rustc_lint::LateContext;
@@ -28,13 +29,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>, arg: &Expr<'_
"you seem to use `.enumerate()` and immediately discard the index",
|diag| {
let base_iter = sugg::Sugg::hir(cx, self_arg, "base iter");
- multispan_sugg(
- diag,
+ diag.multipart_suggestion(
"remove the `.enumerate()` call",
vec![
(pat.span, snippet(cx, elem.span, "..").into_owned()),
(arg.span, base_iter.to_string()),
],
+ Applicability::MachineApplicable,
);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/loops/while_immutable_condition.rs b/src/tools/clippy/clippy_lints/src/loops/while_immutable_condition.rs
index e7b3a2c4973cf..cc1bd5929d0fc 100644
--- a/src/tools/clippy/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/while_immutable_condition.rs
@@ -1,5 +1,5 @@
use super::WHILE_IMMUTABLE_CONDITION;
-use clippy_utils::consts::constant;
+use clippy_utils::consts::ConstEvalCtxt;
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::usage::mutated_variables;
use rustc_hir::def::{DefKind, Res};
@@ -10,7 +10,7 @@ use rustc_lint::LateContext;
use std::ops::ControlFlow;
pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
- if constant(cx, cx.typeck_results(), cond).is_some() {
+ if ConstEvalCtxt::new(cx).eval(cond).is_some() {
// A pure constant condition (e.g., `while false`) is not linted.
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/loops/while_let_on_iterator.rs b/src/tools/clippy/clippy_lints/src/loops/while_let_on_iterator.rs
index 194dd4752f91b..c171fa1c622af 100644
--- a/src/tools/clippy/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -14,7 +14,7 @@ use rustc_span::symbol::sym;
use rustc_span::Symbol;
pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
- if let Some(higher::WhileLet { if_then, let_pat, let_expr, .. }) = higher::WhileLet::hir(expr)
+ if let Some(higher::WhileLet { if_then, let_pat, let_expr, label, .. }) = higher::WhileLet::hir(expr)
// check for `Some(..)` pattern
&& let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind
&& is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome)
@@ -27,6 +27,9 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
&& !uses_iter(cx, &iter_expr_struct, if_then)
{
let mut applicability = Applicability::MachineApplicable;
+
+ let loop_label = label.map_or(String::new(), |l| format!("{}: ", l.ident.name));
+
let loop_var = if let Some(some_pat) = some_pat.first() {
if is_refutable(cx, some_pat) {
// Refutable patterns don't work with for loops.
@@ -57,7 +60,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
expr.span.with_hi(let_expr.span.hi()),
"this loop could be written as a `for` loop",
"try",
- format!("for {loop_var} in {iterator}{by_ref}"),
+ format!("{loop_label}for {loop_var} in {iterator}{by_ref}"),
applicability,
);
}
diff --git a/src/tools/clippy/clippy_lints/src/manual_clamp.rs b/src/tools/clippy/clippy_lints/src/manual_clamp.rs
index a79ad018a042f..4123c933660bc 100644
--- a/src/tools/clippy/clippy_lints/src/manual_clamp.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_clamp.rs
@@ -1,13 +1,13 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
use clippy_utils::higher::If;
use clippy_utils::sugg::Sugg;
use clippy_utils::ty::implements_trait;
use clippy_utils::visitors::is_const_evaluatable;
use clippy_utils::{
- eq_expr_value, in_constant, is_diag_trait_item, is_trait_method, path_res, path_to_local_id, peel_blocks,
+ eq_expr_value, is_diag_trait_item, is_in_const_context, is_trait_method, path_res, path_to_local_id, peel_blocks,
peel_blocks_with_stmt, MaybePath,
};
use itertools::Itertools;
@@ -122,8 +122,9 @@ impl<'tcx> ClampSuggestion<'tcx> {
if max_type != min_type {
return false;
}
- if let Some(max) = constant(cx, cx.typeck_results(), self.params.max)
- && let Some(min) = constant(cx, cx.typeck_results(), self.params.min)
+ let ecx = ConstEvalCtxt::new(cx);
+ if let Some(max) = ecx.eval(self.params.max)
+ && let Some(min) = ecx.eval(self.params.min)
&& let Some(ord) = Constant::partial_cmp(cx.tcx, max_type, &min, &max)
{
ord != Ordering::Greater
@@ -146,7 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualClamp {
if !self.msrv.meets(msrvs::CLAMP) {
return;
}
- if !expr.span.from_expansion() && !in_constant(cx, expr.hir_id) {
+ if !expr.span.from_expansion() && !is_in_const_context(cx) {
let suggestion = is_if_elseif_else_pattern(cx, expr)
.or_else(|| is_max_min_pattern(cx, expr))
.or_else(|| is_call_max_min_pattern(cx, expr))
@@ -159,7 +160,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualClamp {
}
fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
- if !self.msrv.meets(msrvs::CLAMP) || in_constant(cx, block.hir_id) {
+ if !self.msrv.meets(msrvs::CLAMP) || is_in_const_context(cx) {
return;
}
for suggestion in is_two_if_pattern(cx, block) {
diff --git a/src/tools/clippy/clippy_lints/src/manual_float_methods.rs b/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
index 03416ba96de73..6bdc79129a9bc 100644
--- a/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet_opt;
use clippy_utils::{is_from_proc_macro, path_to_local};
@@ -95,8 +95,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
|| cx.tcx.features().declared(sym!(const_float_classify))
)
&& let [first, second, const_1, const_2] = exprs
- && let Some(const_1) = constant(cx, cx.typeck_results(), const_1)
- && let Some(const_2) = constant(cx, cx.typeck_results(), const_2)
+ && let ecx = ConstEvalCtxt::new(cx)
+ && let Some(const_1) = ecx.eval(const_1)
+ && let Some(const_2) = ecx.eval(const_2)
&& path_to_local(first).is_some_and(|f| path_to_local(second).is_some_and(|s| f == s))
// The actual infinity check, we also allow `NEG_INFINITY` before` INFINITY` just in
// case somebody does that for some reason
diff --git a/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs b/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs
index a9f21d34e4cee..31c37c3bc3b14 100644
--- a/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs
@@ -3,7 +3,7 @@ use clippy_config::Conf;
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::macros::matching_root_macro_call;
use clippy_utils::sugg::Sugg;
-use clippy_utils::{higher, in_constant, path_to_local, peel_ref_operators};
+use clippy_utils::{higher, is_in_const_context, path_to_local, peel_ref_operators};
use rustc_ast::ast::RangeLimits;
use rustc_ast::LitKind::{Byte, Char};
use rustc_errors::Applicability;
@@ -95,7 +95,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
return;
}
- if in_constant(cx, expr.hir_id) && !self.msrv.meets(msrvs::IS_ASCII_DIGIT_CONST) {
+ if is_in_const_context(cx) && !self.msrv.meets(msrvs::IS_ASCII_DIGIT_CONST) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs b/src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs
index 78a750f0dcd04..6cf5d272d7d82 100644
--- a/src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs
@@ -1,9 +1,9 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
-use clippy_utils::consts::{constant_full_int, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, FullInt};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_context;
-use clippy_utils::{in_constant, path_to_local};
+use clippy_utils::{is_in_const_context, path_to_local};
use rustc_errors::Applicability;
use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -62,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
&& add_rhs.span.ctxt() == ctxt
&& !in_external_macro(cx.sess(), expr.span)
&& self.msrv.meets(msrvs::REM_EUCLID)
- && (self.msrv.meets(msrvs::REM_EUCLID_CONST) || !in_constant(cx, expr.hir_id))
+ && (self.msrv.meets(msrvs::REM_EUCLID_CONST) || !is_in_const_context(cx))
&& let Some(const1) = check_for_unsigned_int_constant(cx, rem_rhs)
&& let Some((const2, add_other)) = check_for_either_unsigned_int_constant(cx, add_lhs, add_rhs)
&& let ExprKind::Binary(rem2_op, rem2_lhs, rem2_rhs) = add_other.kind
@@ -117,7 +117,7 @@ fn check_for_either_unsigned_int_constant<'a>(
}
fn check_for_unsigned_int_constant<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<u128> {
- let int_const = constant_full_int(cx, cx.typeck_results(), expr)?;
+ let int_const = ConstEvalCtxt::new(cx).eval_full_int(expr)?;
match int_const {
FullInt::S(s) => s.try_into().ok(),
FullInt::U(u) => Some(u),
diff --git a/src/tools/clippy/clippy_lints/src/manual_rotate.rs b/src/tools/clippy/clippy_lints/src/manual_rotate.rs
index a517a4d507526..07537fc65c08c 100644
--- a/src/tools/clippy/clippy_lints/src/manual_rotate.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_rotate.rs
@@ -1,6 +1,6 @@
use std::fmt::Display;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::sugg;
use rustc_errors::Applicability;
@@ -66,7 +66,7 @@ fn parse_shift<'tcx>(
BinOpKind::Shr => ShiftDirection::Right,
_ => return None,
};
- let const_expr = constant(cx, cx.typeck_results(), r)?;
+ let const_expr = ConstEvalCtxt::new(cx).eval(r)?;
if let Constant::Int(shift) = const_expr {
return Some((dir, shift, l));
}
diff --git a/src/tools/clippy/clippy_lints/src/manual_slice_size_calculation.rs b/src/tools/clippy/clippy_lints/src/manual_slice_size_calculation.rs
index 429ee2637c2fa..b24a0f4695a6c 100644
--- a/src/tools/clippy/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_slice_size_calculation.rs
@@ -1,6 +1,6 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_context;
-use clippy_utils::{expr_or_init, in_constant, std_or_core};
+use clippy_utils::{expr_or_init, is_in_const_context, std_or_core};
use rustc_errors::Applicability;
use rustc_hir::{BinOpKind, Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
@@ -44,7 +44,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
&& BinOpKind::Mul == op.node
&& !expr.span.from_expansion()
// Does not apply inside const because size_of_val is not cost in stable.
- && !in_constant(cx, expr.hir_id)
+ && !is_in_const_context(cx)
&& let Some(receiver) = simplify(cx, left, right)
{
let ctxt = expr.span.ctxt();
diff --git a/src/tools/clippy/clippy_lints/src/manual_strip.rs b/src/tools/clippy/clippy_lints/src/manual_strip.rs
index 686ecccf8294c..85cabd2800a65 100644
--- a/src/tools/clippy/clippy_lints/src/manual_strip.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_strip.rs
@@ -1,11 +1,12 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet;
use clippy_utils::usage::mutated_variables;
use clippy_utils::{eq_expr_value, higher, match_def_path, paths};
use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
use rustc_hir::def::Res;
use rustc_hir::intravisit::{walk_expr, Visitor};
use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind};
@@ -14,6 +15,7 @@ use rustc_middle::ty;
use rustc_session::impl_lint_pass;
use rustc_span::source_map::Spanned;
use rustc_span::Span;
+use std::iter;
declare_clippy_lint! {
/// ### What it does
@@ -108,19 +110,19 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
format!("stripping a {kind_word} manually"),
|diag| {
diag.span_note(test_span, format!("the {kind_word} was tested here"));
- multispan_sugg(
- diag,
+ diag.multipart_suggestion(
format!("try using the `strip_{kind_word}` method"),
- vec![(
+ iter::once((
test_span,
format!(
"if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
snippet(cx, target_arg.span, ".."),
snippet(cx, pattern.span, "..")
),
- )]
- .into_iter()
- .chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
+ ))
+ .chain(strippings.into_iter().map(|span| (span, "<stripped>".into())))
+ .collect(),
+ Applicability::HasPlaceholders,
);
},
);
@@ -145,7 +147,7 @@ fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx E
// Returns the length of the `expr` if it's a constant string or char.
fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
- let value = constant(cx, cx.typeck_results(), expr)?;
+ let value = ConstEvalCtxt::new(cx).eval(expr)?;
match value {
Constant::Str(value) => Some(value.len() as u128),
Constant::Char(value) => Some(value.len_utf8() as u128),
@@ -183,9 +185,9 @@ fn peel_ref<'a>(expr: &'a Expr<'_>) -> &'a Expr<'a> {
}
}
-// Find expressions where `target` is stripped using the length of `pattern`.
-// We'll suggest replacing these expressions with the result of the `strip_{prefix,suffix}`
-// method.
+/// Find expressions where `target` is stripped using the length of `pattern`.
+/// We'll suggest replacing these expressions with the result of the `strip_{prefix,suffix}`
+/// method.
fn find_stripping<'tcx>(
cx: &LateContext<'tcx>,
strip_kind: StripKind,
diff --git a/src/tools/clippy/clippy_lints/src/manual_unwrap_or_default.rs b/src/tools/clippy/clippy_lints/src/manual_unwrap_or_default.rs
index f1acc4b217480..8f8390b6f3f9e 100644
--- a/src/tools/clippy/clippy_lints/src/manual_unwrap_or_default.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_unwrap_or_default.rs
@@ -10,7 +10,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::higher::IfLetOrMatch;
use clippy_utils::sugg::Sugg;
use clippy_utils::ty::implements_trait;
-use clippy_utils::{in_constant, is_default_equivalent, peel_blocks, span_contains_comment};
+use clippy_utils::{is_default_equivalent, is_in_const_context, peel_blocks, span_contains_comment};
declare_clippy_lint! {
/// ### What it does
@@ -174,7 +174,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualUnwrapOrDefault {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
if let Some(if_let_or_match) = IfLetOrMatch::parse(cx, expr)
&& !expr.span.from_expansion()
- && !in_constant(cx, expr.hir_id)
+ && !is_in_const_context(cx)
{
handle(cx, if_let_or_match, expr);
}
diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs b/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs
index 85a08f81c2f34..2d4c8daf5cb66 100644
--- a/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::constant_simple;
+use clippy_utils::consts::ConstEvalCtxt;
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
use clippy_utils::ty::is_type_diagnostic_item;
@@ -69,7 +69,7 @@ fn check_and_lint<'tcx>(
&& let Some(ty_name) = find_type_name(cx, ty)
&& let Some(or_body_snippet) = snippet_opt(cx, else_expr.span)
&& let Some(indent) = indent_of(cx, expr.span)
- && constant_simple(cx, cx.typeck_results(), else_expr).is_some()
+ && ConstEvalCtxt::new(cx).eval_simple(else_expr).is_some()
{
lint(cx, expr, let_expr, ty_name, or_body_snippet, indent);
}
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs b/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs
index aba4c85c59e28..5445ee1f04296 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::{snippet, walk_span_to_context};
use clippy_utils::sugg::Sugg;
use core::iter::once;
@@ -54,7 +54,11 @@ where
span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |diag| {
if !expr.span.from_expansion() {
- multispan_sugg(diag, msg, first_sugg.chain(remaining_suggs));
+ diag.multipart_suggestion(
+ msg,
+ first_sugg.chain(remaining_suggs).collect(),
+ Applicability::MachineApplicable,
+ );
}
});
}
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs b/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs
index 8d22ceb47f859..91e40e4275c07 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
use clippy_utils::ty::is_type_diagnostic_item;
use clippy_utils::{is_refutable, peel_hir_pat_refs, recurse_or_patterns};
use rustc_errors::Applicability;
@@ -148,23 +148,27 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
Applicability::MaybeIncorrect,
),
variants => {
- let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
- let message = if adt_def.is_variant_list_non_exhaustive() || has_external_hidden {
- suggestions.push("_".into());
- "wildcard matches known variants and will also match future added variants"
+ let (message, add_wildcard) = if adt_def.is_variant_list_non_exhaustive() || has_external_hidden {
+ (
+ "wildcard matches known variants and will also match future added variants",
+ true,
+ )
} else {
- "wildcard match will also match any future added variants"
+ ("wildcard match will also match any future added variants", false)
};
- span_lint_and_sugg(
- cx,
- WILDCARD_ENUM_MATCH_ARM,
- wildcard_span,
- message,
- "try",
- suggestions.join(" | "),
- Applicability::MaybeIncorrect,
- );
+ span_lint_and_then(cx, WILDCARD_ENUM_MATCH_ARM, wildcard_span, message, |diag| {
+ let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
+ if add_wildcard {
+ suggestions.push("_".into());
+ }
+ diag.span_suggestion(
+ wildcard_span,
+ "try",
+ suggestions.join(" | "),
+ Applicability::MaybeIncorrect,
+ );
+ });
},
};
}
@@ -176,9 +180,8 @@ enum CommonPrefixSearcher<'a> {
}
impl<'a> CommonPrefixSearcher<'a> {
fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
- match path {
- [path @ .., _] => self.with_prefix(path),
- [] => (),
+ if let [path @ .., _] = path {
+ self.with_prefix(path);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs b/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs
index 310675d01a204..d0d2025878e48 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_note;
use clippy_utils::macros::{is_panic, root_macro_call};
use clippy_utils::ty::is_type_diagnostic_item;
use clippy_utils::visitors::is_local_used;
-use clippy_utils::{in_constant, is_wild, peel_blocks_with_stmt};
+use clippy_utils::{is_in_const_context, is_wild, peel_blocks_with_stmt};
use rustc_hir::{Arm, Expr, PatKind};
use rustc_lint::LateContext;
use rustc_span::symbol::{kw, sym};
@@ -11,7 +11,7 @@ use super::MATCH_WILD_ERR_ARM;
pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
// `unwrap`/`expect` is not (yet) const, so we want to allow this in const contexts for now
- if in_constant(cx, ex.hir_id) {
+ if is_in_const_context(cx) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/matches/mod.rs b/src/tools/clippy/clippy_lints/src/matches/mod.rs
index cec3504ed8d09..cf5377e0725dd 100644
--- a/src/tools/clippy/clippy_lints/src/matches/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/mod.rs
@@ -27,7 +27,7 @@ mod wild_in_or_pats;
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
use clippy_utils::source::walk_span_to_context;
-use clippy_utils::{higher, in_constant, is_direct_expn_of, is_span_match, span_contains_cfg};
+use clippy_utils::{higher, is_direct_expn_of, is_in_const_context, is_span_match, span_contains_cfg};
use rustc_hir::{Arm, Expr, ExprKind, LetStmt, MatchSource, Pat, PatKind};
use rustc_lint::{LateContext, LateLintPass, LintContext};
use rustc_middle::lint::in_external_macro;
@@ -1069,7 +1069,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
match_str_case_mismatch::check(cx, ex, arms);
redundant_guards::check(cx, arms, &self.msrv);
- if !in_constant(cx, expr.hir_id) {
+ if !is_in_const_context(cx) {
manual_unwrap_or::check_match(cx, expr, ex, arms);
manual_map::check_match(cx, expr, ex, arms);
manual_filter::check_match(cx, ex, arms, expr);
@@ -1098,7 +1098,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
else_expr,
);
}
- if !in_constant(cx, expr.hir_id) {
+ if !is_in_const_context(cx) {
manual_unwrap_or::check_if_let(
cx,
expr,
diff --git a/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs b/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs
index 45b375dbe3d72..71f211be925bf 100644
--- a/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, constant_full_int, mir_to_const, FullInt};
+use clippy_utils::consts::{mir_to_const, ConstEvalCtxt, FullInt};
use clippy_utils::diagnostics::span_lint_and_note;
use core::cmp::Ordering;
use rustc_hir::{Arm, Expr, PatKind, RangeEnd};
@@ -33,22 +33,20 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
.filter_map(|arm| {
if let Arm { pat, guard: None, .. } = *arm {
if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
- let lhs_const = match lhs {
- Some(lhs) => constant(cx, cx.typeck_results(), lhs)?,
- None => {
- let min_val_const = ty.numeric_min_val(cx.tcx)?;
- mir_to_const(cx, mir::Const::from_ty_const(min_val_const, ty, cx.tcx))?
- },
+ let lhs_const = if let Some(lhs) = lhs {
+ ConstEvalCtxt::new(cx).eval(lhs)?
+ } else {
+ let min_val_const = ty.numeric_min_val(cx.tcx)?;
+ mir_to_const(cx.tcx, mir::Const::from_ty_const(min_val_const, ty, cx.tcx))?
};
- let rhs_const = match rhs {
- Some(rhs) => constant(cx, cx.typeck_results(), rhs)?,
- None => {
- let max_val_const = ty.numeric_max_val(cx.tcx)?;
- mir_to_const(cx, mir::Const::from_ty_const(max_val_const, ty, cx.tcx))?
- },
+ let rhs_const = if let Some(rhs) = rhs {
+ ConstEvalCtxt::new(cx).eval(rhs)?
+ } else {
+ let max_val_const = ty.numeric_max_val(cx.tcx)?;
+ mir_to_const(cx.tcx, mir::Const::from_ty_const(max_val_const, ty, cx.tcx))?
};
- let lhs_val = lhs_const.int_value(cx, ty)?;
- let rhs_val = rhs_const.int_value(cx, ty)?;
+ let lhs_val = lhs_const.int_value(cx.tcx, ty)?;
+ let rhs_val = rhs_const.int_value(cx.tcx, ty)?;
let rhs_bound = match range_end {
RangeEnd::Included => EndBound::Included(rhs_val),
RangeEnd::Excluded => EndBound::Excluded(rhs_val),
@@ -60,7 +58,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
}
if let PatKind::Lit(value) = pat.kind {
- let value = constant_full_int(cx, cx.typeck_results(), value)?;
+ let value = ConstEvalCtxt::new(cx).eval_full_int(value)?;
return Some(SpannedRange {
span: pat.span,
node: (value, EndBound::Included(value)),
diff --git a/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs b/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
index c2c0fbf439d51..8222c3057f73e 100644
--- a/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::macros::matching_root_macro_call;
use clippy_utils::source::snippet;
use clippy_utils::visitors::{for_each_expr_without_closures, is_local_used};
-use clippy_utils::{in_constant, path_to_local};
+use clippy_utils::{is_in_const_context, path_to_local};
use rustc_ast::{BorrowKind, LitKind};
use rustc_errors::Applicability;
use rustc_hir::def::{DefKind, Res};
@@ -116,7 +116,7 @@ fn check_method_calls<'tcx>(
// `s if s.is_empty()` becomes ""
// `arr if arr.is_empty()` becomes []
- if ty.is_str() && !in_constant(cx, if_expr.hir_id) {
+ if ty.is_str() && !is_in_const_context(cx) {
r#""""#.into()
} else if slice_like {
"[]".into()
diff --git a/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs b/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
index 316b2f63e4eaa..2154cd5b24a54 100644
--- a/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_hir::{Pat, PatKind, QPath};
use rustc_lint::LateContext;
use rustc_middle::ty;
@@ -15,13 +15,15 @@ pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
&& fields.len() == def.non_enum_variant().fields.len()
&& !def.non_enum_variant().is_field_list_non_exhaustive()
{
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
REST_PAT_IN_FULLY_BOUND_STRUCTS,
pat.span,
"unnecessary use of `..` pattern in struct binding. All fields were already bound",
- None,
- "consider removing `..` from this binding",
+ |diag| {
+ diag.help("consider removing `..` from this binding");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/matches/single_match.rs b/src/tools/clippy/clippy_lints/src/matches/single_match.rs
index 99fdbcff890b4..24dea03601c5f 100644
--- a/src/tools/clippy/clippy_lints/src/matches/single_match.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/single_match.rs
@@ -1,12 +1,17 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::{expr_block, snippet, SpanRangeExt};
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, peel_mid_ty_refs};
-use clippy_utils::{is_lint_allowed, is_unit_expr, is_wild, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs};
-use core::cmp::max;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{
+ is_lint_allowed, is_unit_expr, peel_blocks, peel_hir_pat_refs, peel_middle_ty_refs, peel_n_hir_expr_refs,
+};
+use core::ops::ControlFlow;
+use rustc_arena::DroplessArena;
use rustc_errors::Applicability;
-use rustc_hir::{Arm, BindingMode, Block, Expr, ExprKind, Pat, PatKind};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_pat, Visitor};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatKind, QPath};
use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, AdtDef, ParamEnv, TyCtxt, TypeckResults, VariantDef};
use rustc_span::{sym, Span};
use super::{MATCH_BOOL, SINGLE_MATCH, SINGLE_MATCH_ELSE};
@@ -27,52 +32,58 @@ fn empty_arm_has_comment(cx: &LateContext<'_>, span: Span) -> bool {
}
#[rustfmt::skip]
-pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
- if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
- if expr.span.from_expansion() {
- // Don't lint match expressions present in
- // macro_rules! block
- return;
- }
- if let PatKind::Or(..) = arms[0].pat.kind {
- // don't lint for or patterns for now, this makes
- // the lint noisy in unnecessary situations
- return;
- }
- let els = arms[1].body;
- let els = if is_unit_expr(peel_blocks(els)) && !empty_arm_has_comment(cx, els.span) {
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>], expr: &'tcx Expr<'_>) {
+ if let [arm1, arm2] = arms
+ && arm1.guard.is_none()
+ && arm2.guard.is_none()
+ && !expr.span.from_expansion()
+ // don't lint for or patterns for now, this makes
+ // the lint noisy in unnecessary situations
+ && !matches!(arm1.pat.kind, PatKind::Or(..))
+ {
+ let els = if is_unit_expr(peel_blocks(arm2.body)) && !empty_arm_has_comment(cx, arm2.body.span) {
None
- } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
- if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
+ } else if let ExprKind::Block(block, _) = arm2.body.kind {
+ if matches!((block.stmts, block.expr), ([], Some(_)) | ([_], None)) {
// single statement/expr "else" block, don't lint
return;
}
// block with 2+ statements or 1 expr and 1+ statement
- Some(els)
+ Some(arm2.body)
} else {
// not a block or an empty block w/ comments, don't lint
return;
};
- let ty = cx.typeck_results().expr_ty(ex);
- if (*ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id)) &&
- (check_single_pattern(arms) || check_opt_like(cx, arms, ty)) {
- report_single_pattern(cx, ex, arms, expr, els);
+ let typeck = cx.typeck_results();
+ if *typeck.expr_ty(ex).peel_refs().kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
+ let mut v = PatVisitor {
+ typeck,
+ has_enum: false,
+ };
+ if v.visit_pat(arm2.pat).is_break() {
+ return;
+ }
+ if v.has_enum {
+ let cx = PatCtxt {
+ tcx: cx.tcx,
+ param_env: cx.param_env,
+ typeck,
+ arena: DroplessArena::default(),
+ };
+ let mut state = PatState::Other;
+ if !(state.add_pat(&cx, arm2.pat) || state.add_pat(&cx, arm1.pat)) {
+ // Don't lint if the pattern contains an enum which doesn't have a wild match.
+ return;
+ }
+ }
+
+ report_single_pattern(cx, ex, arm1, expr, els);
}
}
}
-fn check_single_pattern(arms: &[Arm<'_>]) -> bool {
- is_wild(arms[1].pat)
-}
-
-fn report_single_pattern(
- cx: &LateContext<'_>,
- ex: &Expr<'_>,
- arms: &[Arm<'_>],
- expr: &Expr<'_>,
- els: Option<&Expr<'_>>,
-) {
+fn report_single_pattern(cx: &LateContext<'_>, ex: &Expr<'_>, arm: &Arm<'_>, expr: &Expr<'_>, els: Option<&Expr<'_>>) {
let lint = if els.is_some() { SINGLE_MATCH_ELSE } else { SINGLE_MATCH };
let ctxt = expr.span.ctxt();
let mut app = Applicability::MachineApplicable;
@@ -80,9 +91,9 @@ fn report_single_pattern(
format!(" else {}", expr_block(cx, els, ctxt, "..", Some(expr.span), &mut app))
});
- let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
+ let (pat, pat_ref_count) = peel_hir_pat_refs(arm.pat);
let (msg, sugg) = if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind
- && let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex))
+ && let (ty, ty_ref_count) = peel_middle_ty_refs(cx.typeck_results().expr_ty(ex))
&& let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait()
&& let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait()
&& (ty.is_integral()
@@ -114,17 +125,17 @@ fn report_single_pattern(
snippet(cx, ex.span, ".."),
// PartialEq for different reference counts may not exist.
"&".repeat(ref_count_diff),
- snippet(cx, arms[0].pat.span, ".."),
- expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
+ snippet(cx, arm.pat.span, ".."),
+ expr_block(cx, arm.body, ctxt, "..", Some(expr.span), &mut app),
);
(msg, sugg)
} else {
let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
let sugg = format!(
"if let {} = {} {}{els_str}",
- snippet(cx, arms[0].pat.span, ".."),
+ snippet(cx, arm.pat.span, ".."),
snippet(cx, ex.span, ".."),
- expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
+ expr_block(cx, arm.body, ctxt, "..", Some(expr.span), &mut app),
);
(msg, sugg)
};
@@ -132,106 +143,227 @@ fn report_single_pattern(
span_lint_and_sugg(cx, lint, expr.span, msg, "try", sugg, app);
}
-fn check_opt_like<'a>(cx: &LateContext<'a>, arms: &[Arm<'_>], ty: Ty<'a>) -> bool {
- // We don't want to lint if the second arm contains an enum which could
- // have more variants in the future.
- form_exhaustive_matches(cx, ty, arms[0].pat, arms[1].pat)
+struct PatVisitor<'tcx> {
+ typeck: &'tcx TypeckResults<'tcx>,
+ has_enum: bool,
}
-
-/// Returns `true` if all of the types in the pattern are enums which we know
-/// won't be expanded in the future
-fn pat_in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'a>, pat: &Pat<'_>) -> bool {
- let mut paths_and_types = Vec::new();
- collect_pat_paths(&mut paths_and_types, cx, pat, ty);
- paths_and_types.iter().all(|ty| in_candidate_enum(cx, *ty))
+impl<'tcx> Visitor<'tcx> for PatVisitor<'tcx> {
+ type Result = ControlFlow<()>;
+ fn visit_pat(&mut self, pat: &'tcx Pat<'_>) -> Self::Result {
+ if matches!(pat.kind, PatKind::Binding(..)) {
+ ControlFlow::Break(())
+ } else {
+ self.has_enum |= self.typeck.pat_ty(pat).ty_adt_def().map_or(false, AdtDef::is_enum);
+ walk_pat(self, pat)
+ }
+ }
}
-/// Returns `true` if the given type is an enum we know won't be expanded in the future
-fn in_candidate_enum(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
- // list of candidate `Enum`s we know will never get any more members
- let candidates = [sym::Cow, sym::Option, sym::Result];
+/// The context needed to manipulate a `PatState`.
+struct PatCtxt<'tcx> {
+ tcx: TyCtxt<'tcx>,
+ param_env: ParamEnv<'tcx>,
+ typeck: &'tcx TypeckResults<'tcx>,
+ arena: DroplessArena,
+}
- for candidate_ty in candidates {
- if is_type_diagnostic_item(cx, ty, candidate_ty) {
- return true;
+/// State for tracking whether a match can become non-exhaustive by adding a variant to a contained
+/// enum.
+///
+/// This treats certain std enums as if they will never be extended.
+enum PatState<'a> {
+ /// Either a wild match or an uninteresting type. Uninteresting types include:
+ /// * builtin types (e.g. `i32` or `!`)
+ /// * A struct/tuple/array containing only uninteresting types.
+ /// * A std enum containing only uninteresting types.
+ Wild,
+ /// A std enum we know won't be extended. Tracks the states of each variant separately.
+ ///
+ /// This is not used for `Option` since it uses the current pattern to track it's state.
+ StdEnum(&'a mut [PatState<'a>]),
+ /// Either the initial state for a pattern or a non-std enum. There is currently no need to
+ /// distinguish these cases.
+ ///
+ /// For non-std enums there's no need to track the state of sub-patterns as the state of just
+ /// this pattern on it's own is enough for linting. Consider two cases:
+ /// * This enum has no wild match. This case alone is enough to determine we can lint.
+ /// * This enum has a wild match and therefore all sub-patterns also have a wild match.
+ ///
+ /// In both cases the sub patterns are not needed to determine whether to lint.
+ Other,
+}
+impl<'a> PatState<'a> {
+ /// Adds a set of patterns as a product type to the current state. Returns whether or not the
+ /// current state is a wild match after the merge.
+ fn add_product_pat<'tcx>(
+ &mut self,
+ cx: &'a PatCtxt<'tcx>,
+ pats: impl IntoIterator<Item = &'tcx Pat<'tcx>>,
+ ) -> bool {
+ // Ideally this would actually keep track of the state separately for each pattern. Doing so would
+ // require implementing something similar to exhaustiveness checking which is a significant increase
+ // in complexity.
+ //
+ // For now treat this as a wild match only if all the sub-patterns are wild
+ let is_wild = pats.into_iter().all(|p| {
+ let mut state = Self::Other;
+ state.add_pat(cx, p)
+ });
+ if is_wild {
+ *self = Self::Wild;
}
+ is_wild
}
- false
-}
-/// Collects types from the given pattern
-fn collect_pat_paths<'a>(acc: &mut Vec<Ty<'a>>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) {
- match pat.kind {
- PatKind::Tuple(inner, _) => inner.iter().for_each(|p| {
- let p_ty = cx.typeck_results().pat_ty(p);
- collect_pat_paths(acc, cx, p, p_ty);
- }),
- PatKind::TupleStruct(..) | PatKind::Binding(BindingMode::NONE, .., None) | PatKind::Path(_) => {
- acc.push(ty);
- },
- _ => {},
+ /// Attempts to get the state for the enum variant, initializing the current state if necessary.
+ fn get_std_enum_variant<'tcx>(
+ &mut self,
+ cx: &'a PatCtxt<'tcx>,
+ adt: AdtDef<'tcx>,
+ path: &'tcx QPath<'_>,
+ hir_id: HirId,
+ ) -> Option<(&mut Self, &'tcx VariantDef)> {
+ let states = match self {
+ Self::Wild => return None,
+ Self::Other => {
+ *self = Self::StdEnum(cx.arena.alloc_from_iter((0..adt.variants().len()).map(|_| Self::Other)));
+ let Self::StdEnum(x) = self else {
+ unreachable!();
+ };
+ x
+ },
+ Self::StdEnum(x) => x,
+ };
+ let i = match cx.typeck.qpath_res(path, hir_id) {
+ Res::Def(DefKind::Ctor(..), id) => adt.variant_index_with_ctor_id(id),
+ Res::Def(DefKind::Variant, id) => adt.variant_index_with_id(id),
+ _ => return None,
+ };
+ Some((&mut states[i.as_usize()], adt.variant(i)))
}
-}
-/// Returns true if the given arm of pattern matching contains wildcard patterns.
-fn contains_only_wilds(pat: &Pat<'_>) -> bool {
- match pat.kind {
- PatKind::Wild => true,
- PatKind::Tuple(inner, _) | PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_only_wilds),
- _ => false,
+ fn check_all_wild_enum(&mut self) -> bool {
+ if let Self::StdEnum(states) = self
+ && states.iter().all(|s| matches!(s, Self::Wild))
+ {
+ *self = Self::Wild;
+ true
+ } else {
+ false
+ }
}
-}
-/// Returns true if the given patterns forms only exhaustive matches that don't contain enum
-/// patterns without a wildcard.
-fn form_exhaustive_matches<'a>(cx: &LateContext<'a>, ty: Ty<'a>, left: &Pat<'_>, right: &Pat<'_>) -> bool {
- match (&left.kind, &right.kind) {
- (PatKind::Wild, _) | (_, PatKind::Wild) => true,
- (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
- // We don't actually know the position and the presence of the `..` (dotdot) operator
- // in the arms, so we need to evaluate the correct offsets here in order to iterate in
- // both arms at the same time.
- let left_pos = left_pos.as_opt_usize();
- let right_pos = right_pos.as_opt_usize();
- let len = max(
- left_in.len() + usize::from(left_pos.is_some()),
- right_in.len() + usize::from(right_pos.is_some()),
- );
- let mut left_pos = left_pos.unwrap_or(usize::MAX);
- let mut right_pos = right_pos.unwrap_or(usize::MAX);
- let mut left_dot_space = 0;
- let mut right_dot_space = 0;
- for i in 0..len {
- let mut found_dotdot = false;
- if i == left_pos {
- left_dot_space += 1;
- if left_dot_space < len - left_in.len() {
- left_pos += 1;
- }
- found_dotdot = true;
- }
- if i == right_pos {
- right_dot_space += 1;
- if right_dot_space < len - right_in.len() {
- right_pos += 1;
- }
- found_dotdot = true;
- }
- if found_dotdot {
- continue;
+ #[expect(clippy::similar_names)]
+ fn add_struct_pats<'tcx>(
+ &mut self,
+ cx: &'a PatCtxt<'tcx>,
+ pat: &'tcx Pat<'tcx>,
+ path: &'tcx QPath<'tcx>,
+ single_pat: Option<&'tcx Pat<'tcx>>,
+ pats: impl IntoIterator<Item = &'tcx Pat<'tcx>>,
+ ) -> bool {
+ let ty::Adt(adt, _) = *cx.typeck.pat_ty(pat).kind() else {
+ // Should never happen
+ *self = Self::Wild;
+ return true;
+ };
+ if adt.is_struct() {
+ return if let Some(pat) = single_pat
+ && adt.non_enum_variant().fields.len() == 1
+ {
+ self.add_pat(cx, pat)
+ } else {
+ self.add_product_pat(cx, pats)
+ };
+ }
+ match cx.tcx.get_diagnostic_name(adt.did()) {
+ Some(sym::Option) => {
+ if let Some(pat) = single_pat {
+ self.add_pat(cx, pat)
+ } else {
+ *self = Self::Wild;
+ true
}
- if !contains_only_wilds(&left_in[i - left_dot_space])
- && !contains_only_wilds(&right_in[i - right_dot_space])
+ },
+ Some(sym::Result | sym::Cow) => {
+ let Some((state, variant)) = self.get_std_enum_variant(cx, adt, path, pat.hir_id) else {
+ return matches!(self, Self::Wild);
+ };
+ let is_wild = if let Some(pat) = single_pat
+ && variant.fields.len() == 1
{
- return false;
- }
- }
- true
- },
- (PatKind::TupleStruct(..), PatKind::Path(_)) => pat_in_candidate_enum(cx, ty, right),
- (PatKind::TupleStruct(..), PatKind::TupleStruct(_, inner, _)) => {
- pat_in_candidate_enum(cx, ty, right) && inner.iter().all(contains_only_wilds)
- },
- _ => false,
+ state.add_pat(cx, pat)
+ } else {
+ state.add_product_pat(cx, pats)
+ };
+ is_wild && self.check_all_wild_enum()
+ },
+ _ => matches!(self, Self::Wild),
+ }
+ }
+
+ /// Adds the pattern into the current state. Returns whether or not the current state is a wild
+ /// match after the merge.
+ #[expect(clippy::similar_names)]
+ fn add_pat<'tcx>(&mut self, cx: &'a PatCtxt<'tcx>, pat: &'tcx Pat<'_>) -> bool {
+ match pat.kind {
+ PatKind::Path(_)
+ if match *cx.typeck.pat_ty(pat).peel_refs().kind() {
+ ty::Adt(adt, _) => adt.is_enum() || (adt.is_struct() && !adt.non_enum_variant().fields.is_empty()),
+ ty::Tuple(tys) => !tys.is_empty(),
+ ty::Array(_, len) => len.try_eval_target_usize(cx.tcx, cx.param_env) != Some(1),
+ ty::Slice(..) => true,
+ _ => false,
+ } =>
+ {
+ matches!(self, Self::Wild)
+ },
+
+ // Patterns for things which can only contain a single sub-pattern.
+ PatKind::Binding(_, _, _, Some(pat)) | PatKind::Ref(pat, _) | PatKind::Box(pat) | PatKind::Deref(pat) => {
+ self.add_pat(cx, pat)
+ },
+ PatKind::Tuple([sub_pat], pos)
+ if pos.as_opt_usize().is_none() || cx.typeck.pat_ty(pat).tuple_fields().len() == 1 =>
+ {
+ self.add_pat(cx, sub_pat)
+ },
+ PatKind::Slice([sub_pat], _, []) | PatKind::Slice([], _, [sub_pat])
+ if let ty::Array(_, len) = *cx.typeck.pat_ty(pat).kind()
+ && len.try_eval_target_usize(cx.tcx, cx.param_env) == Some(1) =>
+ {
+ self.add_pat(cx, sub_pat)
+ },
+
+ PatKind::Or(pats) => pats.iter().any(|p| self.add_pat(cx, p)),
+ PatKind::Tuple(pats, _) => self.add_product_pat(cx, pats),
+ PatKind::Slice(head, _, tail) => self.add_product_pat(cx, head.iter().chain(tail)),
+
+ PatKind::TupleStruct(ref path, pats, _) => self.add_struct_pats(
+ cx,
+ pat,
+ path,
+ if let [pat] = pats { Some(pat) } else { None },
+ pats.iter(),
+ ),
+ PatKind::Struct(ref path, pats, _) => self.add_struct_pats(
+ cx,
+ pat,
+ path,
+ if let [pat] = pats { Some(pat.pat) } else { None },
+ pats.iter().map(|p| p.pat),
+ ),
+
+ PatKind::Wild
+ | PatKind::Binding(_, _, _, None)
+ | PatKind::Lit(_)
+ | PatKind::Range(..)
+ | PatKind::Path(_)
+ | PatKind::Never
+ | PatKind::Err(_) => {
+ *self = PatState::Wild;
+ true
+ },
+ }
}
}
diff --git a/src/tools/clippy/clippy_lints/src/matches/try_err.rs b/src/tools/clippy/clippy_lints/src/matches/try_err.rs
index dd489fc250b7b..b7ffa8b8a7814 100644
--- a/src/tools/clippy/clippy_lints/src/matches/try_err.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/try_err.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::is_type_diagnostic_item;
use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res};
@@ -48,29 +48,28 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
return;
};
- let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
- let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
- let mut applicability = Applicability::MachineApplicable;
- let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
- let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
- "" // already returns
- } else {
- "return "
- };
- let suggestion = if err_ty == expr_err_ty {
- format!("{ret_prefix}{prefix}{origin_snippet}{suffix}")
- } else {
- format!("{ret_prefix}{prefix}{origin_snippet}.into(){suffix}")
- };
-
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
TRY_ERR,
expr.span,
"returning an `Err(_)` with the `?` operator",
- "try",
- suggestion,
- applicability,
+ |diag| {
+ let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
+ let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
+ let mut applicability = Applicability::MachineApplicable;
+ let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
+ let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
+ "" // already returns
+ } else {
+ "return "
+ };
+ let suggestion = if err_ty == expr_err_ty {
+ format!("{ret_prefix}{prefix}{origin_snippet}{suffix}")
+ } else {
+ format!("{ret_prefix}{prefix}{origin_snippet}.into(){suffix}")
+ };
+ diag.span_suggestion(expr.span, "try", suggestion, applicability);
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/bind_instead_of_map.rs b/src/tools/clippy/clippy_lints/src/methods/bind_instead_of_map.rs
index 20f3722e173ad..2a8a5fcc3b6f9 100644
--- a/src/tools/clippy/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,5 +1,5 @@
use super::{contains_return, BIND_INSTEAD_OF_MAP};
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
use clippy_utils::peel_blocks;
use clippy_utils::source::{snippet, snippet_with_context};
use clippy_utils::visitors::find_all_ret_expressions;
@@ -136,15 +136,16 @@ impl BindInsteadOfMap {
return false;
};
span_lint_and_then(cx, BIND_INSTEAD_OF_MAP, expr.span, msg, |diag| {
- multispan_sugg_with_applicability(
- diag,
- "try",
+ diag.multipart_suggestion(
+ format!("use `{}` instead", self.good_method_name),
+ std::iter::once((span, self.good_method_name.into()))
+ .chain(
+ suggs
+ .into_iter()
+ .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
+ )
+ .collect(),
Applicability::MachineApplicable,
- std::iter::once((span, self.good_method_name.into())).chain(
- suggs
- .into_iter()
- .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
- ),
);
});
true
diff --git a/src/tools/clippy/clippy_lints/src/methods/clone_on_ref_ptr.rs b/src/tools/clippy/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 926bd06bacbd2..e0826b53004b6 100644
--- a/src/tools/clippy/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet_with_context;
use rustc_errors::Applicability;
use rustc_hir as hir;
@@ -29,19 +29,22 @@ pub(super) fn check(
sym::RcWeak | sym::ArcWeak => "Weak",
_ => return,
};
-
- // Sometimes unnecessary ::<_> after Rc/Arc/Weak
- let mut app = Applicability::Unspecified;
- let snippet = snippet_with_context(cx, receiver.span, expr.span.ctxt(), "..", &mut app).0;
-
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
CLONE_ON_REF_PTR,
expr.span,
"using `.clone()` on a ref-counted pointer",
- "try",
- format!("{caller_type}::<{}>::clone(&{snippet})", subst.type_at(0)),
- app,
+ |diag| {
+ // Sometimes unnecessary ::<_> after Rc/Arc/Weak
+ let mut app = Applicability::Unspecified;
+ let snippet = snippet_with_context(cx, receiver.span, expr.span.ctxt(), "..", &mut app).0;
+ diag.span_suggestion(
+ expr.span,
+ "try",
+ format!("{caller_type}::<{}>::clone(&{snippet})", subst.type_at(0)),
+ app,
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/filetype_is_file.rs b/src/tools/clippy/clippy_lints/src/methods/filetype_is_file.rs
index eab536b88a5b3..2ab0401947c4c 100644
--- a/src/tools/clippy/clippy_lints/src/methods/filetype_is_file.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/filetype_is_file.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::get_parent_expr;
use clippy_utils::ty::is_type_diagnostic_item;
use rustc_hir as hir;
@@ -33,6 +33,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
span = expr.span;
}
let lint_msg = format!("`{lint_unary}FileType::is_file()` only {verb} regular files");
- let help_msg = format!("use `{help_unary}FileType::is_dir()` instead");
- span_lint_and_help(cx, FILETYPE_IS_FILE, span, lint_msg, None, help_msg);
+
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, FILETYPE_IS_FILE, span, lint_msg, |diag| {
+ diag.help(format!("use `{help_unary}FileType::is_dir()` instead"));
+ });
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/get_unwrap.rs b/src/tools/clippy/clippy_lints/src/methods/get_unwrap.rs
index 455274a442854..c6285c87a2636 100644
--- a/src/tools/clippy/clippy_lints/src/methods/get_unwrap.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/get_unwrap.rs
@@ -1,5 +1,5 @@
use super::utils::derefs_to_slice;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::get_parent_expr;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::is_type_diagnostic_item;
@@ -19,9 +19,7 @@ pub(super) fn check<'tcx>(
) {
// Note: we don't want to lint `get_mut().unwrap` for `HashMap` or `BTreeMap`,
// because they do not implement `IndexMut`
- let mut applicability = Applicability::MachineApplicable;
let expr_ty = cx.typeck_results().expr_ty(recv);
- let get_args_str = snippet_with_applicability(cx, get_arg.span, "..", &mut applicability);
let caller_type = if derefs_to_slice(cx, recv, expr_ty).is_some() {
"slice"
} else if is_type_diagnostic_item(cx, expr_ty, sym::Vec) {
@@ -58,24 +56,34 @@ pub(super) fn check<'tcx>(
};
let mut_str = if is_mut { "_mut" } else { "" };
- let borrow_str = if !needs_ref {
- ""
- } else if is_mut {
- "&mut "
- } else {
- "&"
- };
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
GET_UNWRAP,
span,
- format!("called `.get{mut_str}().unwrap()` on a {caller_type}. Using `[]` is more clear and more concise"),
- "try",
- format!(
- "{borrow_str}{}[{get_args_str}]",
- snippet_with_applicability(cx, recv.span, "..", &mut applicability)
- ),
- applicability,
+ format!("called `.get{mut_str}().unwrap()` on a {caller_type}"),
+ |diag| {
+ let mut applicability = Applicability::MachineApplicable;
+ let get_args_str = snippet_with_applicability(cx, get_arg.span, "..", &mut applicability);
+
+ let borrow_str = if !needs_ref {
+ ""
+ } else if is_mut {
+ "&mut "
+ } else {
+ "&"
+ };
+
+ diag.span_suggestion_with_style(
+ span,
+ "using `[]` is clearer and more concise",
+ format!(
+ "{borrow_str}{}[{get_args_str}]",
+ snippet_with_applicability(cx, recv.span, "..", &mut applicability)
+ ),
+ applicability,
+ rustc_errors::SuggestionStyle::ShowAlways,
+ );
+ },
);
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs b/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs
index c510cd915d0c9..519091406ccf3 100644
--- a/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs
@@ -1,7 +1,7 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::{implements_trait, peel_mid_ty_refs};
-use clippy_utils::{is_diag_item_method, is_diag_trait_item};
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{is_diag_item_method, is_diag_trait_item, peel_middle_ty_refs};
use rustc_errors::Applicability;
use rustc_hir as hir;
use rustc_lint::LateContext;
@@ -14,7 +14,7 @@ pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv
&& is_clone_like(cx, method_name, method_def_id)
&& let return_type = cx.typeck_results().expr_ty(expr)
&& let input_type = cx.typeck_results().expr_ty(recv)
- && let (input_type, ref_count) = peel_mid_ty_refs(input_type)
+ && let (input_type, ref_count) = peel_middle_ty_refs(input_type)
&& !(ref_count > 0 && is_diag_trait_item(cx, method_def_id, sym::ToOwned))
&& let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did()))
&& return_type == input_type
diff --git a/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs b/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs
index 210e4ae0a7bc0..22d896433f07a 100644
--- a/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -2,7 +2,7 @@
use super::IS_DIGIT_ASCII_RADIX;
use clippy_config::msrvs::{self, Msrv};
-use clippy_utils::consts::{constant_full_int, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, FullInt};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
use rustc_errors::Applicability;
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(
return;
}
- if let Some(radix_val) = constant_full_int(cx, cx.typeck_results(), radix) {
+ if let Some(radix_val) = ConstEvalCtxt::new(cx).eval_full_int(radix) {
let (num, replacement) = match radix_val {
FullInt::S(10) | FullInt::U(10) => (10, "is_ascii_digit"),
FullInt::S(16) | FullInt::U(16) => (16, "is_ascii_hexdigit"),
diff --git a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
index d921b7ea14f5d..cc82f6cfd6384 100644
--- a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::constant_is_empty;
+use clippy_utils::consts::ConstEvalCtxt;
use clippy_utils::diagnostics::span_lint;
use clippy_utils::{find_binding_init, path_to_local};
use rustc_hir::{Expr, HirId};
@@ -18,7 +18,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, receiver: &Expr<'_
if !receiver.span.eq_ctxt(init_expr.span) {
return;
}
- if let Some(init_is_empty) = constant_is_empty(cx, init_expr) {
+ if let Some(init_is_empty) = ConstEvalCtxt::new(cx).eval_is_empty(init_expr) {
span_lint(
cx,
CONST_IS_EMPTY,
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
index 05e77386128f9..33de3b87abc82 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
@@ -1,15 +1,12 @@
-#![allow(unused_imports)]
-
use super::ITER_KV_MAP;
use clippy_config::msrvs::{self, Msrv};
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::pat_is_wild;
+use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{pat_is_wild, sugg};
-use rustc_hir::{BindingMode, Body, BorrowKind, ByRef, Expr, ExprKind, Mutability, Pat, PatKind};
-use rustc_lint::{LateContext, LintContext};
-use rustc_middle::ty;
-use rustc_span::{sym, Span};
+use rustc_hir::{Body, Expr, ExprKind, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
/// lint use of:
///
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_nth_zero.rs b/src/tools/clippy/clippy_lints/src/methods/iter_nth_zero.rs
index 262a57ab591a6..9ff6eaa348710 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_nth_zero.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::{is_lang_item_or_ctor, is_trait_method};
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
if let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir().get_parent_item(expr.hir_id))
&& let def_id = item.owner_id.to_def_id()
&& is_trait_method(cx, expr, sym::Iterator)
- && let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), arg)
+ && let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval(arg)
&& !is_lang_item_or_ctor(cx, def_id, LangItem::IteratorNext)
{
let mut app = Applicability::MachineApplicable;
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_skip_zero.rs b/src/tools/clippy/clippy_lints/src/methods/iter_skip_zero.rs
index 6b696b42a6931..39e440e784f6d 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_skip_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_skip_zero.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::{is_from_proc_macro, is_trait_method};
use rustc_errors::Applicability;
@@ -11,7 +11,7 @@ use super::ITER_SKIP_ZERO;
pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg_expr: &Expr<'_>) {
if !expr.span.from_expansion()
&& is_trait_method(cx, expr, sym::Iterator)
- && let Some(arg) = constant(cx, cx.typeck_results(), arg_expr).and_then(|constant| {
+ && let Some(arg) = ConstEvalCtxt::new(cx).eval(arg_expr).and_then(|constant| {
if let Constant::Int(arg) = constant {
Some(arg)
} else {
diff --git a/src/tools/clippy/clippy_lints/src/methods/iterator_step_by_zero.rs b/src/tools/clippy/clippy_lints/src/methods/iterator_step_by_zero.rs
index b631cd00cda43..9b358235a40df 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iterator_step_by_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint;
use clippy_utils::is_trait_method;
use rustc_hir as hir;
@@ -9,7 +9,7 @@ use super::ITERATOR_STEP_BY_ZERO;
pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
if is_trait_method(cx, expr, sym::Iterator) {
- if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), arg) {
+ if let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval(arg) {
span_lint(
cx,
ITERATOR_STEP_BY_ZERO,
diff --git a/src/tools/clippy/clippy_lints/src/methods/map_clone.rs b/src/tools/clippy/clippy_lints/src/methods/map_clone.rs
index a5ba5e5d8918c..08ce7e204dd27 100644
--- a/src/tools/clippy/clippy_lints/src/methods/map_clone.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/map_clone.rs
@@ -2,10 +2,10 @@ use clippy_config::msrvs::{self, Msrv};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::{is_copy, is_type_diagnostic_item, should_call_clone_as_function};
-use clippy_utils::{is_diag_trait_item, match_def_path, paths, peel_blocks};
+use clippy_utils::{is_diag_trait_item, peel_blocks};
use rustc_errors::Applicability;
-use rustc_hir as hir;
use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, LangItem};
use rustc_lint::LateContext;
use rustc_middle::mir::Mutability;
use rustc_middle::ty;
@@ -114,7 +114,7 @@ fn handle_path(
recv: &hir::Expr<'_>,
) {
if let Some(path_def_id) = cx.qpath_res(qpath, arg.hir_id).opt_def_id()
- && match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
+ && cx.tcx.lang_items().get(LangItem::CloneFn) == Some(path_def_id)
{
// The `copied` and `cloned` methods are only available on `&T` and `&mut T` in `Option`
// and `Result`.
diff --git a/src/tools/clippy/clippy_lints/src/methods/map_err_ignore.rs b/src/tools/clippy/clippy_lints/src/methods/map_err_ignore.rs
index fbb83c8ce5635..162f0ac564d7d 100644
--- a/src/tools/clippy/clippy_lints/src/methods/map_err_ignore.rs
+++ b/src/tools/clippy/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| ...`)",
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs
index aa4cad9342a17..1d7b10fe8f045 100644
--- a/src/tools/clippy/clippy_lints/src/methods/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs
@@ -133,7 +133,7 @@ mod zst_offset;
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
use clippy_utils::macros::FormatArgsStorage;
use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
@@ -749,7 +749,6 @@ declare_clippy_lint! {
///
/// ### Example
/// ```no_run
- /// # #![allow(unused)]
/// (0_i32..10)
/// .filter(|n| n.checked_add(1).is_some())
/// .map(|n| n.checked_add(1).unwrap());
@@ -757,7 +756,6 @@ declare_clippy_lint! {
///
/// Use instead:
/// ```no_run
- /// # #[allow(unused)]
/// (0_i32..10).filter_map(|n| n.checked_add(1));
/// ```
#[clippy::version = "1.51.0"]
@@ -850,7 +848,6 @@ declare_clippy_lint! {
///
/// ### Example
/// ```no_run
- /// # #![allow(unused)]
/// let vec = vec![1];
/// vec.iter().find(|x| **x == 0).is_some();
///
@@ -862,7 +859,6 @@ declare_clippy_lint! {
/// let vec = vec![1];
/// vec.iter().any(|x| *x == 0);
///
- /// # #[allow(unused)]
/// !"hello world".contains("world");
/// ```
#[clippy::version = "pre 1.29.0"]
@@ -1505,7 +1501,6 @@ declare_clippy_lint! {
///
/// ### Example
/// ```no_run
- /// # #[allow(unused)]
/// (0..3).fold(false, |acc, x| acc || x > 2);
/// ```
///
@@ -1897,7 +1892,9 @@ declare_clippy_lint! {
/// trait.
///
/// ### Why is this bad?
- /// It is recommended style to use collect. See
+ /// If it's needed to create a collection from the contents of an iterator, the `Iterator::collect(_)`
+ /// method is preferred. However, when it's needed to specify the container type,
+ /// `Vec::from_iter(_)` can be more readable than using a turbofish (e.g. `_.collect::<Vec<_>>()`). See
/// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
///
/// ### Example
@@ -1916,6 +1913,14 @@ declare_clippy_lint! {
///
/// assert_eq!(v, vec![5, 5, 5, 5, 5]);
/// ```
+ /// but prefer to use
+ /// ```no_run
+ /// let numbers: Vec<i32> = FromIterator::from_iter(1..=5);
+ /// ```
+ /// instead of
+ /// ```no_run
+ /// let numbers = (1..=5).collect::<Vec<_>>();
+ /// ```
#[clippy::version = "1.49.0"]
pub FROM_ITER_INSTEAD_OF_COLLECT,
pedantic,
@@ -2008,13 +2013,11 @@ declare_clippy_lint! {
///
/// ### Example
/// ```no_run
- /// # #[allow(unused)]
/// "Hello".bytes().nth(3);
/// ```
///
/// Use instead:
/// ```no_run
- /// # #[allow(unused)]
/// "Hello".as_bytes().get(3);
/// ```
#[clippy::version = "1.52.0"]
@@ -2059,7 +2062,6 @@ declare_clippy_lint! {
///
/// ### Example
/// ```no_run
- /// # #![allow(unused)]
/// let some_vec = vec![0, 1, 2, 3];
///
/// some_vec.iter().count();
@@ -3656,7 +3658,6 @@ declare_clippy_lint! {
///
/// ### Example
/// ```no_run
- /// # #![allow(unused)]
/// let owned_string = "This is a string".to_owned();
/// owned_string.as_str().as_bytes()
/// # ;
@@ -3664,7 +3665,6 @@ declare_clippy_lint! {
///
/// Use instead:
/// ```no_run
- /// # #![allow(unused)]
/// let owned_string = "This is a string".to_owned();
/// owned_string.as_bytes()
/// # ;
@@ -4915,13 +4915,13 @@ impl Methods {
str_split::check(cx, expr, recv, arg);
},
("splitn" | "rsplitn", [count_arg, pat_arg]) => {
- if let Some(Constant::Int(count)) = constant(cx, cx.typeck_results(), count_arg) {
+ if let Some(Constant::Int(count)) = ConstEvalCtxt::new(cx).eval(count_arg) {
suspicious_splitn::check(cx, name, expr, recv, count);
str_splitn::check(cx, name, expr, recv, pat_arg, count, &self.msrv);
}
},
("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
- if let Some(Constant::Int(count)) = constant(cx, cx.typeck_results(), count_arg) {
+ if let Some(Constant::Int(count)) = ConstEvalCtxt::new(cx).eval(count_arg) {
suspicious_splitn::check(cx, name, expr, recv, count);
}
},
diff --git a/src/tools/clippy/clippy_lints/src/methods/open_options.rs b/src/tools/clippy/clippy_lints/src/methods/open_options.rs
index d425b505a760c..cbeb48b6cc376 100644
--- a/src/tools/clippy/clippy_lints/src/methods/open_options.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/open_options.rs
@@ -151,7 +151,7 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, S
cx,
NONSENSICAL_OPEN_OPTIONS,
prev_span,
- format!("the method `{}` is called more than once", &option),
+ format!("the method `{option}` is called more than once"),
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/repeat_once.rs b/src/tools/clippy/clippy_lints/src/methods/repeat_once.rs
index bb4cdd2a6fa10..7837517ed5d8a 100644
--- a/src/tools/clippy/clippy_lints/src/methods/repeat_once.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/repeat_once.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet;
use clippy_utils::ty::is_type_lang_item;
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
recv: &'tcx Expr<'_>,
repeat_arg: &'tcx Expr<'_>,
) {
- if constant(cx, cx.typeck_results(), repeat_arg) == Some(Constant::Int(1)) {
+ if ConstEvalCtxt::new(cx).eval(repeat_arg) == Some(Constant::Int(1)) {
let ty = cx.typeck_results().expr_ty(recv).peel_refs();
if ty.is_str() {
span_lint_and_sugg(
diff --git a/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs b/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
index 4f42fb73547a7..12cabd43cb1b2 100644
--- a/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
@@ -1,5 +1,5 @@
use clippy_config::msrvs::{self, Msrv};
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
use clippy_utils::source::snippet_with_context;
use clippy_utils::usage::local_used_after_expr;
@@ -301,7 +301,7 @@ fn parse_iter_usage<'tcx>(
};
},
("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
- if let Some(Constant::Int(idx)) = constant(cx, cx.typeck_results(), idx_expr) {
+ if let Some(Constant::Int(idx)) = ConstEvalCtxt::new(cx).eval(idx_expr) {
let span = if name.ident.as_str() == "nth" {
e.span
} else if let Some((_, Node::Expr(next_expr))) = iter.next()
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_min_or_max.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_min_or_max.rs
index 78851d4122f12..86c0a6322b666 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_min_or_max.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_min_or_max.rs
@@ -3,7 +3,7 @@ use std::cmp::Ordering;
use super::UNNECESSARY_MIN_OR_MAX;
use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::consts::{constant, constant_with_source, Constant, ConstantSource, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, Constant, ConstantSource, FullInt};
use clippy_utils::source::snippet;
use rustc_errors::Applicability;
@@ -20,10 +20,9 @@ pub(super) fn check<'tcx>(
arg: &'tcx Expr<'_>,
) {
let typeck_results = cx.typeck_results();
- if let Some((left, ConstantSource::Local | ConstantSource::CoreConstant)) =
- constant_with_source(cx, typeck_results, recv)
- && let Some((right, ConstantSource::Local | ConstantSource::CoreConstant)) =
- constant_with_source(cx, typeck_results, arg)
+ let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.param_env, typeck_results);
+ if let Some((left, ConstantSource::Local | ConstantSource::CoreConstant)) = ecx.eval_with_source(recv)
+ && let Some((right, ConstantSource::Local | ConstantSource::CoreConstant)) = ecx.eval_with_source(arg)
{
let Some(ord) = Constant::partial_cmp(cx.tcx, typeck_results.expr_ty(recv), &left, &right) else {
return;
@@ -78,9 +77,9 @@ enum Extrema {
fn detect_extrema<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Extrema> {
let ty = cx.typeck_results().expr_ty(expr);
- let cv = constant(cx, cx.typeck_results(), expr)?;
+ let cv = ConstEvalCtxt::new(cx).eval(expr)?;
- match (cv.int_value(cx, ty)?, ty.kind()) {
+ match (cv.int_value(cx.tcx, ty)?, ty.kind()) {
(FullInt::S(i), &ty::Int(ity)) if i == i128::MIN >> (128 - ity.bit_width()?) => Some(Extrema::Minimum),
(FullInt::S(i), &ty::Int(ity)) if i == i128::MAX >> (128 - ity.bit_width()?) => Some(Extrema::Maximum),
(FullInt::U(i), &ty::Uint(uty)) if i == u128::MAX >> (128 - uty.bit_width()?) => Some(Extrema::Maximum),
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
index 5d899415d7728..fed2b128dcf30 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,12 +3,11 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
use clippy_config::msrvs::{self, Msrv};
use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
use clippy_utils::source::{snippet, snippet_opt};
-use clippy_utils::ty::{
- get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item, peel_mid_ty_refs,
-};
+use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item};
use clippy_utils::visitors::find_all_ret_expressions;
use clippy_utils::{
- fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, match_def_path, paths, return_ty,
+ fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, match_def_path, paths, peel_middle_ty_refs,
+ return_ty,
};
use rustc_errors::Applicability;
use rustc_hir::def::{DefKind, Res};
@@ -120,8 +119,8 @@ fn check_addr_of_expr(
},
] = adjustments[..]
&& let receiver_ty = cx.typeck_results().expr_ty(receiver)
- && let (target_ty, n_target_refs) = peel_mid_ty_refs(*target_ty)
- && let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty)
+ && let (target_ty, n_target_refs) = peel_middle_ty_refs(*target_ty)
+ && let (receiver_ty, n_receiver_refs) = peel_middle_ty_refs(receiver_ty)
// Only flag cases satisfying at least one of the following three conditions:
// * the referent and receiver types are distinct
// * the referent/receiver type is a copyable array
@@ -382,7 +381,7 @@ fn check_other_call_arg<'tcx>(
&& let fn_sig = cx.tcx.fn_sig(callee_def_id).instantiate_identity().skip_binder()
&& let Some(i) = recv.into_iter().chain(call_args).position(|arg| arg.hir_id == maybe_arg.hir_id)
&& let Some(input) = fn_sig.inputs().get(i)
- && let (input, n_refs) = peel_mid_ty_refs(*input)
+ && let (input, n_refs) = peel_middle_ty_refs(*input)
&& let (trait_predicates, _) = get_input_traits_and_projections(cx, callee_def_id, input)
&& let Some(sized_def_id) = cx.tcx.lang_items().sized_trait()
&& let [trait_predicate] = trait_predicates
diff --git a/src/tools/clippy/clippy_lints/src/methods/unused_enumerate_index.rs b/src/tools/clippy/clippy_lints/src/methods/unused_enumerate_index.rs
index 8b8a965b9f0c9..3004d9c4233a7 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unused_enumerate_index.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unused_enumerate_index.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_hir_and_then};
+use clippy_utils::diagnostics::span_lint_hir_and_then;
use clippy_utils::source::{snippet, snippet_opt};
use clippy_utils::{expr_or_init, is_trait_method, pat_is_wild};
use rustc_errors::Applicability;
@@ -97,10 +97,8 @@ pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>,
enumerate_span,
"you seem to use `.enumerate()` and immediately discard the index",
|diag| {
- multispan_sugg_with_applicability(
- diag,
+ diag.multipart_suggestion(
"remove the `.enumerate()` call",
- Applicability::MachineApplicable,
vec![
(closure_param.span, new_closure_param),
(
@@ -108,6 +106,7 @@ pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>,
String::new(),
),
],
+ Applicability::MachineApplicable,
);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs b/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs
index ae2b6e6347eb0..ebad4ae6ee95d 100644
--- a/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs
@@ -2,10 +2,10 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::{should_call_clone_as_function, walk_ptrs_ty_depth};
use clippy_utils::{
- get_parent_expr, is_diag_trait_item, match_def_path, path_to_local_id, paths, peel_blocks, strip_pat_refs,
+ get_parent_expr, is_diag_trait_item, match_def_path, path_to_local_id, peel_blocks, strip_pat_refs,
};
use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::{self as hir, LangItem};
use rustc_lint::LateContext;
use rustc_middle::ty::adjustment::Adjust;
use rustc_middle::ty::{Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
@@ -104,7 +104,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
fn check_qpath(cx: &LateContext<'_>, qpath: hir::QPath<'_>, hir_id: hir::HirId) -> bool {
// We check it's calling the `clone` method of the `Clone` trait.
if let Some(path_def_id) = cx.qpath_res(&qpath, hir_id).opt_def_id() {
- match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
+ cx.tcx.lang_items().get(LangItem::CloneFn) == Some(path_def_id)
} else {
false
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/verbose_file_reads.rs b/src/tools/clippy/clippy_lints/src/methods/verbose_file_reads.rs
index 181b413a18288..8ed61637eca21 100644
--- a/src/tools/clippy/clippy_lints/src/methods/verbose_file_reads.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/verbose_file_reads.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_trait_method;
use clippy_utils::ty::is_type_diagnostic_item;
use rustc_hir::{Expr, ExprKind, QPath};
@@ -23,6 +23,9 @@ pub(super) fn check<'tcx>(
&& matches!(recv.kind, ExprKind::Path(QPath::Resolved(None, _)))
&& is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(recv).peel_refs(), sym::File)
{
- span_lint_and_help(cx, VERBOSE_FILE_READS, expr.span, msg, None, help);
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, VERBOSE_FILE_READS, expr.span, msg, |diag| {
+ diag.help(help);
+ });
}
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/wrong_self_convention.rs b/src/tools/clippy/clippy_lints/src/methods/wrong_self_convention.rs
index 28068c6347325..7384e534ed7d7 100644
--- a/src/tools/clippy/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/wrong_self_convention.rs
@@ -127,7 +127,7 @@ pub(super) fn check<'tcx>(
.collect::<Vec<_>>()
.join(" and ");
- format!("methods with the following characteristics: ({})", &s)
+ format!("methods with the following characteristics: ({s})")
} else {
format!("methods called {}", &conventions[0])
}
diff --git a/src/tools/clippy/clippy_lints/src/minmax.rs b/src/tools/clippy/clippy_lints/src/minmax.rs
index c3fbca1d560e6..e95864c6db8b5 100644
--- a/src/tools/clippy/clippy_lints/src/minmax.rs
+++ b/src/tools/clippy/clippy_lints/src/minmax.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint;
use clippy_utils::is_trait_method;
use rustc_hir::{Expr, ExprKind};
@@ -106,15 +106,11 @@ fn fetch_const<'a, 'tcx>(
if args.next().is_some() {
return None;
}
- constant_simple(cx, cx.typeck_results(), first_arg).map_or_else(
- || constant_simple(cx, cx.typeck_results(), second_arg).map(|c| (m, c, first_arg)),
- |c| {
- if constant_simple(cx, cx.typeck_results(), second_arg).is_none() {
- // otherwise ignore
- Some((m, c, second_arg))
- } else {
- None
- }
- },
- )
+ let ecx = ConstEvalCtxt::new(cx);
+ match (ecx.eval_simple(first_arg), ecx.eval_simple(second_arg)) {
+ (Some(c), None) => Some((m, c, second_arg)),
+ (None, Some(c)) => Some((m, c, first_arg)),
+ // otherwise ignore
+ _ => None,
+ }
}
diff --git a/src/tools/clippy/clippy_lints/src/misc_early/literal_suffix.rs b/src/tools/clippy/clippy_lints/src/misc_early/literal_suffix.rs
index e0a5e401a50aa..22467999cd8d5 100644
--- a/src/tools/clippy/clippy_lints/src/misc_early/literal_suffix.rs
+++ b/src/tools/clippy/clippy_lints/src/misc_early/literal_suffix.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_errors::Applicability;
use rustc_lint::EarlyContext;
use rustc_span::Span;
@@ -12,24 +12,36 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit_span: Span, lit_snip: &str, suffi
// Do not lint when literal is unsuffixed.
if !suffix.is_empty() {
if lit_snip.as_bytes()[maybe_last_sep_idx] == b'_' {
- span_lint_and_sugg(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
SEPARATED_LITERAL_SUFFIX,
lit_span,
format!("{sugg_type} type suffix should not be separated by an underscore"),
- "remove the underscore",
- format!("{}{suffix}", &lit_snip[..maybe_last_sep_idx]),
- Applicability::MachineApplicable,
+ |diag| {
+ diag.span_suggestion(
+ lit_span,
+ "remove the underscore",
+ format!("{}{suffix}", &lit_snip[..maybe_last_sep_idx]),
+ Applicability::MachineApplicable,
+ );
+ },
);
} else {
- span_lint_and_sugg(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
UNSEPARATED_LITERAL_SUFFIX,
lit_span,
format!("{sugg_type} type suffix should be separated by an underscore"),
- "add an underscore",
- format!("{}_{suffix}", &lit_snip[..=maybe_last_sep_idx]),
- Applicability::MachineApplicable,
+ |diag| {
+ diag.span_suggestion(
+ lit_span,
+ "add an underscore",
+ format!("{}_{suffix}", &lit_snip[..=maybe_last_sep_idx]),
+ Applicability::MachineApplicable,
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/misc_early/unneeded_field_pattern.rs b/src/tools/clippy/clippy_lints/src/misc_early/unneeded_field_pattern.rs
index cb305cf5582d1..6db03adf44ac9 100644
--- a/src/tools/clippy/clippy_lints/src/misc_early/unneeded_field_pattern.rs
+++ b/src/tools/clippy/clippy_lints/src/misc_early/unneeded_field_pattern.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
use clippy_utils::source::snippet_opt;
use rustc_ast::ast::{Pat, PatKind};
use rustc_lint::EarlyContext;
@@ -21,13 +21,15 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
}
}
if !pfields.is_empty() && wilds == pfields.len() {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
UNNEEDED_FIELD_PATTERN,
pat.span,
"all the struct fields are matched to a wildcard pattern, consider using `..`",
- None,
- format!("try with `{type_name} {{ .. }}` instead"),
+ |diag| {
+ diag.help(format!("try with `{type_name} {{ .. }}` instead"));
+ },
);
return;
}
@@ -56,14 +58,15 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
}
}
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
UNNEEDED_FIELD_PATTERN,
field.span,
- "you matched a field with a wildcard pattern, consider using `..` \
- instead",
- None,
- format!("try with `{type_name} {{ {}, .. }}`", normal[..].join(", ")),
+ "you matched a field with a wildcard pattern, consider using `..` instead",
+ |diag| {
+ diag.help(format!("try with `{type_name} {{ {}, .. }}`", normal[..].join(", ")));
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/missing_assert_message.rs b/src/tools/clippy/clippy_lints/src/missing_assert_message.rs
index 935ed48dacc50..a9ea11f4c2b06 100644
--- a/src/tools/clippy/clippy_lints/src/missing_assert_message.rs
+++ b/src/tools/clippy/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");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs b/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
index 68c158330ab53..052d738b2e79e 100644
--- a/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
@@ -186,7 +186,7 @@ fn already_const(header: hir::FnHeader) -> bool {
fn could_be_const_with_abi(cx: &LateContext<'_>, msrv: &Msrv, abi: Abi) -> bool {
match abi {
Abi::Rust => true,
- // `const extern "C"` was stablized after 1.62.0
+ // `const extern "C"` was stabilized after 1.62.0
Abi::C { unwind: false } => msrv.meets(msrvs::CONST_EXTERN_FN),
// Rest ABIs are still unstable and need the `const_extern_fn` feature enabled.
_ => cx.tcx.features().const_extern_fn,
diff --git a/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs b/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
index 85029a5e6a0d4..7ee746365d102 100644
--- a/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
@@ -1,10 +1,9 @@
-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;
+use rustc_hir::def_id::DefIdSet;
use rustc_hir::{Impl, Item, ItemKind};
use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::AssocItem;
use rustc_session::declare_lint_pass;
declare_clippy_lint! {
@@ -68,33 +67,26 @@ impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
}) = item.kind
&& let Some(trait_id) = trait_ref.trait_def_id()
{
- let mut provided: DefIdMap<&AssocItem> = cx
- .tcx
- .provided_trait_methods(trait_id)
- .map(|assoc| (assoc.def_id, assoc))
+ let trait_item_ids: DefIdSet = items
+ .iter()
+ .filter_map(|impl_item| impl_item.trait_item_def_id)
.collect();
- for impl_item in *items {
- if let Some(def_id) = impl_item.trait_item_def_id {
- provided.remove(&def_id);
- }
+ for assoc in cx
+ .tcx
+ .provided_trait_methods(trait_id)
+ .filter(|assoc| !trait_item_ids.contains(&assoc.def_id))
+ {
+ span_lint_and_then(
+ cx,
+ MISSING_TRAIT_METHODS,
+ cx.tcx.def_span(item.owner_id),
+ format!("missing trait method provided by default: `{}`", assoc.name),
+ |diag| {
+ diag.span_help(cx.tcx.def_span(assoc.def_id), "implement the method");
+ },
+ );
}
-
- 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(
- 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",
- );
- }
- });
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs b/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
index 9c5a8a0cfcdfa..6964d8c8dbb33 100644
--- a/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
use rustc_hir::intravisit::{walk_expr, Visitor};
use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, LetStmt, Node, Stmt, StmtKind};
@@ -324,13 +324,17 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
if path_to_local_id(expr, self.var) {
// Check that this is a read, not a write.
if !is_in_assignment_position(self.cx, expr) {
- span_lint_and_note(
+ span_lint_and_then(
self.cx,
MIXED_READ_WRITE_IN_EXPRESSION,
expr.span,
format!("unsequenced read of `{}`", self.cx.tcx.hir().name(self.var)),
- Some(self.write_expr.span),
- "whether read occurs before this write depends on evaluation order",
+ |diag| {
+ diag.span_note(
+ self.write_expr.span,
+ "whether read occurs before this write depends on evaluation order",
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/module_style.rs b/src/tools/clippy/clippy_lints/src/module_style.rs
index 305499f9da43c..e9c5f64a2550d 100644
--- a/src/tools/clippy/clippy_lints/src/module_style.rs
+++ b/src/tools/clippy/clippy_lints/src/module_style.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_ast::ast;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
@@ -121,17 +121,18 @@ impl EarlyLintPass for ModStyle {
for folder in &folder_segments {
if !mod_folders.contains(folder) {
if let Some((file, path)) = file_map.get(folder) {
- let mut correct = path.to_path_buf();
- correct.pop();
- correct.push(folder);
- correct.push("mod.rs");
- span_lint_and_help(
+ span_lint_and_then(
cx,
SELF_NAMED_MODULE_FILES,
Span::new(file.start_pos, file.start_pos, SyntaxContext::root(), None),
format!("`mod.rs` files are required, found `{}`", path.display()),
- None,
- format!("move `{}` to `{}`", path.display(), correct.display(),),
+ |diag| {
+ let mut correct = path.to_path_buf();
+ correct.pop();
+ correct.push(folder);
+ correct.push("mod.rs");
+ diag.help(format!("move `{}` to `{}`", path.display(), correct.display(),));
+ },
);
}
}
@@ -161,17 +162,18 @@ fn process_paths_for_mod_files<'a>(
/// for code-sharing between tests.
fn check_self_named_mod_exists(cx: &EarlyContext<'_>, path: &Path, file: &SourceFile) {
if path.ends_with("mod.rs") && !path.starts_with("tests") {
- let mut mod_file = path.to_path_buf();
- mod_file.pop();
- mod_file.set_extension("rs");
-
- span_lint_and_help(
+ span_lint_and_then(
cx,
MOD_MODULE_FILES,
Span::new(file.start_pos, file.start_pos, SyntaxContext::root(), None),
format!("`mod.rs` files are not allowed, found `{}`", path.display()),
- None,
- format!("move `{}` to `{}`", path.display(), mod_file.display()),
+ |diag| {
+ let mut mod_file = path.to_path_buf();
+ mod_file.pop();
+ mod_file.set_extension("rs");
+
+ diag.help(format!("move `{}` to `{}`", path.display(), mod_file.display()));
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
index 67f9b52c352e6..32e7fde03b2c8 100644
--- a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -1,7 +1,7 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::mir::PossibleBorrowerMap;
+use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
use clippy_utils::source::snippet_with_context;
use clippy_utils::ty::{implements_trait, is_copy};
use clippy_utils::{expr_use_ctxt, peel_n_hir_expr_refs, DefinedTy, ExprUseNode};
@@ -12,6 +12,7 @@ use rustc_hir::{Body, Expr, ExprKind, Mutability, Path, QPath};
use rustc_index::bit_set::BitSet;
use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::{Rvalue, StatementKind};
use rustc_middle::ty::{
self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, ParamTy, ProjectionPredicate, Ty,
};
@@ -107,6 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> {
}
&& let count = needless_borrow_count(
cx,
+ &mut self.possible_borrowers,
fn_id,
cx.typeck_results().node_args(hir_id),
i,
@@ -155,9 +157,14 @@ fn path_has_args(p: &QPath<'_>) -> bool {
/// The following constraints will be checked:
/// * The borrowed expression meets all the generic type's constraints.
/// * The generic type appears only once in the functions signature.
-/// * The borrowed value is Copy itself OR not a variable (created by a function call)
+/// * The borrowed value is:
+/// - `Copy` itself, or
+/// - the only use of a mutable reference, or
+/// - not a variable (created by a function call)
+#[expect(clippy::too_many_arguments)]
fn needless_borrow_count<'tcx>(
cx: &LateContext<'tcx>,
+ possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
fn_id: DefId,
callee_args: ty::GenericArgsRef<'tcx>,
arg_index: usize,
@@ -232,9 +239,9 @@ fn needless_borrow_count<'tcx>(
let referent_ty = cx.typeck_results().expr_ty(referent);
- if (!is_copy(cx, referent_ty) && !referent_ty.is_ref())
- && let ExprKind::AddrOf(_, _, inner) = reference.kind
- && !matches!(inner.kind, ExprKind::Call(..) | ExprKind::MethodCall(..))
+ if !(is_copy(cx, referent_ty)
+ || referent_ty.is_ref() && referent_used_exactly_once(cx, possible_borrowers, reference)
+ || matches!(referent.kind, ExprKind::Call(..) | ExprKind::MethodCall(..)))
{
return false;
}
@@ -337,6 +344,37 @@ fn is_mixed_projection_predicate<'tcx>(
}
}
+fn referent_used_exactly_once<'tcx>(
+ cx: &LateContext<'tcx>,
+ possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
+ reference: &Expr<'tcx>,
+) -> bool {
+ if let Some(mir) = enclosing_mir(cx.tcx, reference.hir_id)
+ && let Some(local) = expr_local(cx.tcx, reference)
+ && let [location] = *local_assignments(mir, local).as_slice()
+ && let block_data = &mir.basic_blocks[location.block]
+ && let Some(statement) = block_data.statements.get(location.statement_index)
+ && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
+ && !place.is_indirect_first_projection()
+ {
+ let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
+ if possible_borrowers
+ .last()
+ .map_or(true, |&(local_def_id, _)| local_def_id != body_owner_local_def_id)
+ {
+ possible_borrowers.push((body_owner_local_def_id, PossibleBorrowerMap::new(cx, mir)));
+ }
+ let possible_borrower = &mut possible_borrowers.last_mut().unwrap().1;
+ // If `only_borrowers` were used here, the `copyable_iterator::warn` test would fail. The reason is
+ // that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible borrower of
+ // itself. See the comment in that method for an explanation as to why.
+ possible_borrower.bounded_borrowers(&[local], &[local, place.local], place.local, location)
+ && used_exactly_once(mir, place.local).unwrap_or(false)
+ } else {
+ false
+ }
+}
+
// Iteratively replaces `param_ty` with `new_ty` in `args`, and similarly for each resulting
// projected type that is a type parameter. Returns `false` if replacing the types would have an
// effect on the function signature beyond substituting `new_ty` for `param_ty`.
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
index f2e00cef7e9ff..a0bbf6b14b217 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::is_self;
use clippy_utils::ptr::get_spans;
use clippy_utils::source::{snippet, snippet_opt};
@@ -278,9 +278,12 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
}
}
- let spans = vec![(input.span, format!("&{}", snippet(cx, input.span, "_")))];
-
- multispan_sugg(diag, "consider taking a reference instead", spans);
+ diag.span_suggestion(
+ input.span,
+ "consider taking a reference instead",
+ format!("&{}", snippet(cx, input.span, "_")),
+ Applicability::MaybeIncorrect,
+ );
};
span_lint_and_then(
diff --git a/src/tools/clippy/clippy_lints/src/no_effect.rs b/src/tools/clippy/clippy_lints/src/no_effect.rs
index 9d326c06eff65..8232e69db3917 100644
--- a/src/tools/clippy/clippy_lints/src/no_effect.rs
+++ b/src/tools/clippy/clippy_lints/src/no_effect.rs
@@ -273,7 +273,7 @@ fn check_unnecessary_operation(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
}
let snippet =
if let (Some(arr), Some(func)) = (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span)) {
- format!("assert!({}.len() > {});", &arr, &func)
+ format!("assert!({arr}.len() > {func});")
} else {
return;
};
diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
index 15bb328b4465a..6915cd4061551 100644
--- a/src/tools/clippy/clippy_lints/src/non_copy_const.rs
+++ b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
@@ -6,7 +6,7 @@ use std::ptr;
use clippy_config::Conf;
use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::in_constant;
+use clippy_utils::is_in_const_context;
use clippy_utils::macros::macro_backtrace;
use clippy_utils::ty::{implements_trait, InteriorMut};
use rustc_hir::def::{DefKind, Res};
@@ -406,7 +406,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst<'tcx> {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
if let ExprKind::Path(qpath) = &expr.kind {
// Only lint if we use the const item inside a function.
- if in_constant(cx, expr.hir_id) {
+ if is_in_const_context(cx) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
index 8b8aabe7accc6..aadd729f32a45 100644
--- a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
+++ b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
@@ -243,7 +243,6 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
owner_id,
..
}) => {
- #[allow(trivial_casts)]
if let Node::Item(item) = cx.tcx.parent_hir_node(owner_id.into())
&& let Some(trait_ref) = cx
.tcx
diff --git a/src/tools/clippy/clippy_lints/src/operators/absurd_extreme_comparisons.rs b/src/tools/clippy/clippy_lints/src/operators/absurd_extreme_comparisons.rs
index 9769da6d3e9b1..a0de5ea711ca0 100644
--- a/src/tools/clippy/clippy_lints/src/operators/absurd_extreme_comparisons.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/absurd_extreme_comparisons.rs
@@ -3,7 +3,7 @@ use rustc_lint::LateContext;
use rustc_middle::ty;
use clippy_utils::comparisons::{normalize_comparison, Rel};
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_help;
use clippy_utils::source::snippet;
use clippy_utils::ty::is_isize_or_usize;
@@ -121,7 +121,7 @@ fn detect_absurd_comparison<'tcx>(
fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
let ty = cx.typeck_results().expr_ty(expr);
- let cv = constant(cx, cx.typeck_results(), expr)?;
+ let cv = ConstEvalCtxt::new(cx).eval(expr)?;
let which = match (ty.kind(), cv) {
(&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum,
diff --git a/src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs b/src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs
index a7e381be743d5..bc71a4790b9d4 100644
--- a/src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,6 +1,6 @@
use super::ARITHMETIC_SIDE_EFFECTS;
use clippy_config::Conf;
-use clippy_utils::consts::{constant, constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint;
use clippy_utils::ty::is_type_diagnostic_item;
use clippy_utils::{expr_or_init, is_from_proc_macro, is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary};
@@ -162,7 +162,7 @@ impl ArithmeticSideEffects {
{
return Some(n.get());
}
- if let Some(Constant::Int(n)) = constant(cx, cx.typeck_results(), expr) {
+ if let Some(Constant::Int(n)) = ConstEvalCtxt::new(cx).eval(expr) {
return Some(n);
}
None
@@ -200,7 +200,7 @@ impl ArithmeticSideEffects {
lhs: &'tcx hir::Expr<'_>,
rhs: &'tcx hir::Expr<'_>,
) {
- if constant_simple(cx, cx.typeck_results(), expr).is_some() {
+ if ConstEvalCtxt::new(cx).eval_simple(expr).is_some() {
return;
}
if !matches!(
@@ -280,7 +280,7 @@ impl ArithmeticSideEffects {
let Some(arg) = args.first() else {
return;
};
- if constant_simple(cx, cx.typeck_results(), receiver).is_some() {
+ if ConstEvalCtxt::new(cx).eval_simple(receiver).is_some() {
return;
}
let instance_ty = cx.typeck_results().expr_ty(receiver);
@@ -308,7 +308,7 @@ impl ArithmeticSideEffects {
let hir::UnOp::Neg = un_op else {
return;
};
- if constant(cx, cx.typeck_results(), un_expr).is_some() {
+ if ConstEvalCtxt::new(cx).eval(un_expr).is_some() {
return;
}
let ty = cx.typeck_results().expr_ty(expr).peel_refs();
diff --git a/src/tools/clippy/clippy_lints/src/operators/bit_mask.rs b/src/tools/clippy/clippy_lints/src/operators/bit_mask.rs
index 545e680ce0de5..4414056a467ca 100644
--- a/src/tools/clippy/clippy_lints/src/operators/bit_mask.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/bit_mask.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint;
use rustc_hir::{BinOpKind, Expr, ExprKind};
use rustc_lint::LateContext;
@@ -166,7 +166,7 @@ fn check_ineffective_gt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op:
}
fn fetch_int_literal(cx: &LateContext<'_>, lit: &Expr<'_>) -> Option<u128> {
- match constant(cx, cx.typeck_results(), lit)? {
+ match ConstEvalCtxt::new(cx).eval(lit)? {
Constant::Int(n) => Some(n),
_ => None,
}
diff --git a/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs b/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs
index 7bf9b8ef866a2..c131752439628 100644
--- a/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs
@@ -2,7 +2,7 @@
use std::cmp::Ordering;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use rustc_hir::{BinOpKind, Expr, ExprKind};
use rustc_lint::LateContext;
use rustc_middle::ty::layout::HasTyCtxt;
@@ -20,13 +20,14 @@ use super::{IMPOSSIBLE_COMPARISONS, REDUNDANT_COMPARISONS};
// Flip yoda conditionals, turnings expressions like `42 < x` into `x > 42`
fn comparison_to_const<'tcx>(
cx: &LateContext<'tcx>,
- typeck: &TypeckResults<'tcx>,
+ typeck: &'tcx TypeckResults<'tcx>,
expr: &'tcx Expr<'tcx>,
) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant<'tcx>, Ty<'tcx>)> {
if let ExprKind::Binary(operator, left, right) = expr.kind
&& let Ok(cmp_op) = CmpOp::try_from(operator.node)
{
- match (constant(cx, typeck, left), constant(cx, typeck, right)) {
+ let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.param_env, typeck);
+ match (ecx.eval(left), ecx.eval(right)) {
(Some(_), Some(_)) => None,
(_, Some(con)) => Some((cmp_op, left, right, con, typeck.expr_ty(right))),
(Some(con), _) => Some((cmp_op.reverse(), right, left, con, typeck.expr_ty(left))),
diff --git a/src/tools/clippy/clippy_lints/src/operators/duration_subsec.rs b/src/tools/clippy/clippy_lints/src/operators/duration_subsec.rs
index ca3112ce5c468..e3029f8438e5f 100644
--- a/src/tools/clippy/clippy_lints/src/operators/duration_subsec.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/duration_subsec.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::is_type_diagnostic_item;
@@ -19,7 +19,7 @@ pub(crate) fn check<'tcx>(
if op == BinOpKind::Div
&& let ExprKind::MethodCall(method_path, self_arg, [], _) = left.kind
&& is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_arg).peel_refs(), sym::Duration)
- && let Some(Constant::Int(divisor)) = constant(cx, cx.typeck_results(), right)
+ && let Some(Constant::Int(divisor)) = ConstEvalCtxt::new(cx).eval(right)
{
let suggested_fn = match (method_path.ident.as_str(), divisor) {
("subsec_micros", 1_000) | ("subsec_nanos", 1_000_000) => "subsec_millis",
diff --git a/src/tools/clippy/clippy_lints/src/operators/erasing_op.rs b/src/tools/clippy/clippy_lints/src/operators/erasing_op.rs
index 066e08f3bd4ca..24bfe2b050bb5 100644
--- a/src/tools/clippy/clippy_lints/src/operators/erasing_op.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/erasing_op.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint;
use clippy_utils::ty::same_type_and_consts;
@@ -34,12 +34,12 @@ fn different_types(tck: &TypeckResults<'_>, input: &Expr<'_>, output: &Expr<'_>)
fn check_op<'tcx>(
cx: &LateContext<'tcx>,
- tck: &TypeckResults<'tcx>,
+ tck: &'tcx TypeckResults<'tcx>,
op: &Expr<'tcx>,
other: &Expr<'tcx>,
parent: &Expr<'tcx>,
) {
- if constant_simple(cx, tck, op) == Some(Constant::Int(0)) {
+ if ConstEvalCtxt::with_env(cx.tcx, cx.param_env, tck).eval_simple(op) == Some(Constant::Int(0)) {
if different_types(tck, other, parent) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/operators/float_cmp.rs b/src/tools/clippy/clippy_lints/src/operators/float_cmp.rs
index 0e5b440c50f27..df6e67455965e 100644
--- a/src/tools/clippy/clippy_lints/src/operators/float_cmp.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/float_cmp.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_with_source, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::get_item_name;
use clippy_utils::sugg::Sugg;
@@ -17,12 +17,14 @@ pub(crate) fn check<'tcx>(
right: &'tcx Expr<'_>,
) {
if (op == BinOpKind::Eq || op == BinOpKind::Ne) && is_float(cx, left) {
- let left_is_local = match constant_with_source(cx, cx.typeck_results(), left) {
+ let typeck = cx.typeck_results();
+ let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.param_env, typeck);
+ let left_is_local = match ecx.eval_with_source(left) {
Some((c, s)) if !is_allowed(&c) => s.is_local(),
Some(_) => return,
None => true,
};
- let right_is_local = match constant_with_source(cx, cx.typeck_results(), right) {
+ let right_is_local = match ecx.eval_with_source(right) {
Some((c, s)) if !is_allowed(&c) => s.is_local(),
Some(_) => return,
None => true,
diff --git a/src/tools/clippy/clippy_lints/src/operators/identity_op.rs b/src/tools/clippy/clippy_lints/src/operators/identity_op.rs
index 0879dcd9bcdf6..830be50c8ba4f 100644
--- a/src/tools/clippy/clippy_lints/src/operators/identity_op.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/identity_op.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_full_int, constant_simple, Constant, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, Constant, FullInt};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::{clip, peel_hir_expr_refs, unsext};
@@ -184,14 +184,13 @@ fn is_allowed(cx: &LateContext<'_>, cmp: BinOpKind, left: &Expr<'_>, right: &Exp
&& cx.typeck_results().expr_ty(right).peel_refs().is_integral()
// `1 << 0` is a common pattern in bit manipulation code
&& !(cmp == BinOpKind::Shl
- && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
- && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1)))
+ && ConstEvalCtxt::new(cx).eval_simple(right) == Some(Constant::Int(0))
+ && ConstEvalCtxt::new(cx).eval_simple(left) == Some(Constant::Int(1)))
}
fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
- let lhs_const = constant_full_int(cx, cx.typeck_results(), left);
- let rhs_const = constant_full_int(cx, cx.typeck_results(), right);
- if match (lhs_const, rhs_const) {
+ let ecx = ConstEvalCtxt::new(cx);
+ if match (ecx.eval_full_int(left), ecx.eval_full_int(right)) {
(Some(FullInt::S(lv)), Some(FullInt::S(rv))) => lv.abs() < rv.abs(),
(Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
_ => return,
@@ -201,7 +200,7 @@ fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span
}
fn check_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span, parens: Parens, is_erased: bool) -> bool {
- if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e).map(Constant::peel_refs) {
+ if let Some(Constant::Int(v)) = ConstEvalCtxt::new(cx).eval_simple(e).map(Constant::peel_refs) {
let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() {
ty::Int(ity) => unsext(cx.tcx, -1_i128, ity),
ty::Uint(uty) => clip(cx.tcx, !0, uty),
diff --git a/src/tools/clippy/clippy_lints/src/operators/integer_division.rs b/src/tools/clippy/clippy_lints/src/operators/integer_division.rs
index 631d10f4a72e9..76eba7327cff6 100644
--- a/src/tools/clippy/clippy_lints/src/operators/integer_division.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/integer_division.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_hir as hir;
use rustc_lint::LateContext;
@@ -15,13 +15,9 @@ pub(crate) fn check<'tcx>(
&& cx.typeck_results().expr_ty(left).is_integral()
&& cx.typeck_results().expr_ty(right).is_integral()
{
- span_lint_and_help(
- cx,
- INTEGER_DIVISION,
- expr.span,
- "integer division",
- None,
- "division of integers may cause loss of precision. consider using floats",
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, INTEGER_DIVISION, expr.span, "integer division", |diag| {
+ diag.help("division of integers may cause loss of precision. consider using floats");
+ });
}
}
diff --git a/src/tools/clippy/clippy_lints/src/operators/modulo_arithmetic.rs b/src/tools/clippy/clippy_lints/src/operators/modulo_arithmetic.rs
index d65fffac5a828..c83bdda347a66 100644
--- a/src/tools/clippy/clippy_lints/src/operators/modulo_arithmetic.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::sext;
use rustc_hir::{BinOpKind, Expr, ExprKind, Node};
@@ -42,15 +42,11 @@ fn used_in_comparison_with_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
};
if op.node == BinOpKind::Eq || op.node == BinOpKind::Ne {
- if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), rhs) {
- return true;
- }
- if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), lhs) {
- return true;
- }
+ let ecx = ConstEvalCtxt::new(cx);
+ matches!(ecx.eval(lhs), Some(Constant::Int(0))) || matches!(ecx.eval(rhs), Some(Constant::Int(0)))
+ } else {
+ false
}
-
- false
}
struct OperandInfo {
@@ -60,7 +56,7 @@ struct OperandInfo {
}
fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<OperandInfo> {
- match constant(cx, cx.typeck_results(), operand) {
+ match ConstEvalCtxt::new(cx).eval(operand) {
Some(Constant::Int(v)) => match *cx.typeck_results().expr_ty(expr).kind() {
ty::Int(ity) => {
let value = sext(cx.tcx, v, ity);
diff --git a/src/tools/clippy/clippy_lints/src/operators/numeric_arithmetic.rs b/src/tools/clippy/clippy_lints/src/operators/numeric_arithmetic.rs
index ea933168cfd5d..565294bb40a82 100644
--- a/src/tools/clippy/clippy_lints/src/operators/numeric_arithmetic.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -1,5 +1,5 @@
use super::FLOAT_ARITHMETIC;
-use clippy_utils::consts::constant_simple;
+use clippy_utils::consts::ConstEvalCtxt;
use clippy_utils::diagnostics::span_lint;
use rustc_hir as hir;
use rustc_lint::LateContext;
@@ -55,7 +55,7 @@ impl Context {
return;
}
let ty = cx.typeck_results().expr_ty(arg);
- if constant_simple(cx, cx.typeck_results(), expr).is_none() && ty.is_floating_point() {
+ if ConstEvalCtxt::new(cx).eval_simple(expr).is_none() && ty.is_floating_point() {
span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
self.expr_id = Some(expr.hir_id);
}
diff --git a/src/tools/clippy/clippy_lints/src/operators/op_ref.rs b/src/tools/clippy/clippy_lints/src/operators/op_ref.rs
index c2b27c9b2298a..82b9d10fbeb1d 100644
--- a/src/tools/clippy/clippy_lints/src/operators/op_ref.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/op_ref.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::get_enclosing_block;
use clippy_utils::source::snippet;
use clippy_utils::ty::{implements_trait, is_copy};
@@ -64,10 +64,10 @@ pub(crate) fn check<'tcx>(
|diag| {
let lsnip = snippet(cx, l.span, "...").to_string();
let rsnip = snippet(cx, r.span, "...").to_string();
- multispan_sugg(
- diag,
+ diag.multipart_suggestion(
"use the values directly",
vec![(left.span, lsnip), (right.span, rsnip)],
+ Applicability::MachineApplicable,
);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/option_if_let_else.rs b/src/tools/clippy/clippy_lints/src/option_if_let_else.rs
index d4906328ccb93..ae02d22512e31 100644
--- a/src/tools/clippy/clippy_lints/src/option_if_let_else.rs
+++ b/src/tools/clippy/clippy_lints/src/option_if_let_else.rs
@@ -1,8 +1,8 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::sugg::Sugg;
use clippy_utils::{
- can_move_expr_to_closure, eager_or_lazy, higher, in_constant, is_else_clause, is_res_lang_ctor, peel_blocks,
- peel_hir_expr_while, CaptureKind,
+ can_move_expr_to_closure, eager_or_lazy, higher, is_else_clause, is_in_const_context, is_res_lang_ctor,
+ peel_blocks, peel_hir_expr_while, CaptureKind,
};
use rustc_errors::Applicability;
use rustc_hir::def::Res;
@@ -294,7 +294,7 @@ fn is_none_or_err_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
impl<'tcx> LateLintPass<'tcx> for OptionIfLetElse {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
// Don't lint macros and constants
- if expr.span.from_expansion() || in_constant(cx, expr.hir_id) {
+ if expr.span.from_expansion() || is_in_const_context(cx) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/partial_pub_fields.rs b/src/tools/clippy/clippy_lints/src/partial_pub_fields.rs
index 2d20cbea698f2..267e2067e101a 100644
--- a/src/tools/clippy/clippy_lints/src/partial_pub_fields.rs
+++ b/src/tools/clippy/clippy_lints/src/partial_pub_fields.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_ast::ast::{Item, ItemKind};
use rustc_lint::{EarlyContext, EarlyLintPass};
use rustc_session::declare_lint_pass;
@@ -57,24 +57,16 @@ impl EarlyLintPass for PartialPubFields {
for field in fields {
if all_priv && field.vis.kind.is_pub() {
- span_lint_and_help(
- cx,
- PARTIAL_PUB_FIELDS,
- field.vis.span,
- msg,
- None,
- "consider using private field here",
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, PARTIAL_PUB_FIELDS, field.vis.span, msg, |diag| {
+ diag.help("consider using private field here");
+ });
return;
} else if all_pub && !field.vis.kind.is_pub() {
- span_lint_and_help(
- cx,
- PARTIAL_PUB_FIELDS,
- field.vis.span,
- msg,
- None,
- "consider using public field here",
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, PARTIAL_PUB_FIELDS, field.vis.span, msg, |diag| {
+ diag.help("consider using public field here");
+ });
return;
}
}
diff --git a/src/tools/clippy/clippy_lints/src/pathbuf_init_then_push.rs b/src/tools/clippy/clippy_lints/src/pathbuf_init_then_push.rs
index 0008f154ae3a8..18bfb588a1187 100644
--- a/src/tools/clippy/clippy_lints/src/pathbuf_init_then_push.rs
+++ b/src/tools/clippy/clippy_lints/src/pathbuf_init_then_push.rs
@@ -21,8 +21,8 @@ declare_clippy_lint! {
/// `PathBuf::from` instead.
///
/// ### Known problems
- /// `.join()` introduces an implicit `clone()`. `PathBuf::from` can alternativly be
- /// used when the `PathBuf` is newly constructed. This will avoild the implicit clone.
+ /// `.join()` introduces an implicit `clone()`. `PathBuf::from` can alternatively be
+ /// used when the `PathBuf` is newly constructed. This will avoid the implicit clone.
///
/// ### Example
/// ```rust
diff --git a/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs b/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs
index 9661a57b8b95c..c1296b04387a0 100644
--- a/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs
+++ b/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_hir::{
intravisit, Body, Expr, ExprKind, FnDecl, LetExpr, LocalSource, Mutability, Pat, PatKind, Stmt, StmtKind,
};
@@ -133,23 +133,25 @@ enum DerefPossible {
fn apply_lint(cx: &LateContext<'_>, pat: &Pat<'_>, deref_possible: DerefPossible) -> bool {
let maybe_mismatch = find_first_mismatch(cx, pat);
if let Some((span, mutability, level)) = maybe_mismatch {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
PATTERN_TYPE_MISMATCH,
span,
"type of pattern does not match the expression type",
- None,
- format!(
- "{}explicitly match against a `{}` pattern and adjust the enclosed variable bindings",
- match (deref_possible, level) {
- (DerefPossible::Possible, Level::Top) => "use `*` to dereference the match expression or ",
- _ => "",
- },
- match mutability {
- Mutability::Mut => "&mut _",
- Mutability::Not => "&_",
- },
- ),
+ |diag| {
+ diag.help(format!(
+ "{}explicitly match against a `{}` pattern and adjust the enclosed variable bindings",
+ match (deref_possible, level) {
+ (DerefPossible::Possible, Level::Top) => "use `*` to dereference the match expression or ",
+ _ => "",
+ },
+ match mutability {
+ Mutability::Mut => "&mut _",
+ Mutability::Not => "&_",
+ },
+ ));
+ },
);
true
} else {
diff --git a/src/tools/clippy/clippy_lints/src/pub_use.rs b/src/tools/clippy/clippy_lints/src/pub_use.rs
index ab8f8a1689dc3..5b973a79eae36 100644
--- a/src/tools/clippy/clippy_lints/src/pub_use.rs
+++ b/src/tools/clippy/clippy_lints/src/pub_use.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_ast::ast::{Item, ItemKind, VisibilityKind};
use rustc_lint::{EarlyContext, EarlyLintPass};
use rustc_session::declare_lint_pass;
@@ -42,14 +42,10 @@ impl EarlyLintPass for PubUse {
if let ItemKind::Use(_) = item.kind
&& let VisibilityKind::Public = item.vis.kind
{
- span_lint_and_help(
- cx,
- PUB_USE,
- item.span,
- "using `pub use`",
- None,
- "move the exported item to a public module instead",
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, PUB_USE, item.span, "using `pub use`", |diag| {
+ diag.help("move the exported item to a public module instead");
+ });
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/question_mark.rs b/src/tools/clippy/clippy_lints/src/question_mark.rs
index ef6b4d3aeab27..e1e3ded2c795d 100644
--- a/src/tools/clippy/clippy_lints/src/question_mark.rs
+++ b/src/tools/clippy/clippy_lints/src/question_mark.rs
@@ -7,7 +7,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
use clippy_utils::{
- eq_expr_value, higher, in_constant, is_else_clause, is_lint_allowed, is_path_lang_item, is_res_lang_ctor,
+ eq_expr_value, higher, is_else_clause, is_in_const_context, is_lint_allowed, is_path_lang_item, is_res_lang_ctor,
pat_and_expr_can_be_question_mark, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
span_contains_comment,
};
@@ -346,15 +346,13 @@ impl<'tcx> LateLintPass<'tcx> for QuestionMark {
return;
}
- if !self.inside_try_block() && !in_constant(cx, stmt.hir_id) {
+ if !self.inside_try_block() && !is_in_const_context(cx) {
check_let_some_else_return_none(cx, stmt);
}
self.check_manual_let_else(cx, stmt);
}
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
- if !self.inside_try_block()
- && !in_constant(cx, expr.hir_id)
- && is_lint_allowed(cx, QUESTION_MARK_USED, expr.hir_id)
+ if !self.inside_try_block() && !is_in_const_context(cx) && is_lint_allowed(cx, QUESTION_MARK_USED, expr.hir_id)
{
check_is_none_or_err_and_early_return(cx, expr);
check_if_let_some_or_err_and_early_return(cx, expr);
diff --git a/src/tools/clippy/clippy_lints/src/question_mark_used.rs b/src/tools/clippy/clippy_lints/src/question_mark_used.rs
index f5e6cb804da17..0a974bf9d2f71 100644
--- a/src/tools/clippy/clippy_lints/src/question_mark_used.rs
+++ b/src/tools/clippy/clippy_lints/src/question_mark_used.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::macros::span_is_local;
use rustc_hir::{Expr, ExprKind, MatchSource};
@@ -39,13 +39,15 @@ impl<'tcx> LateLintPass<'tcx> for QuestionMarkUsed {
return;
}
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
QUESTION_MARK_USED,
expr.span,
"question mark operator was used",
- None,
- "consider using a custom macro or match expression",
+ |diag| {
+ diag.help("consider using a custom macro or match expression");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/ranges.rs b/src/tools/clippy/clippy_lints/src/ranges.rs
index 829fb58bc652b..81189fe517c00 100644
--- a/src/tools/clippy/clippy_lints/src/ranges.rs
+++ b/src/tools/clippy/clippy_lints/src/ranges.rs
@@ -1,10 +1,10 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
use clippy_utils::source::{snippet, snippet_with_applicability, SpanRangeExt};
use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_expr, higher, in_constant, is_integer_const, path_to_local};
+use clippy_utils::{get_parent_expr, higher, is_in_const_context, is_integer_const, path_to_local};
use rustc_ast::ast::RangeLimits;
use rustc_errors::Applicability;
use rustc_hir::{BinOpKind, Expr, ExprKind, HirId};
@@ -202,7 +202,7 @@ fn check_possible_range_contains(
expr: &Expr<'_>,
span: Span,
) {
- if in_constant(cx, expr.hir_id) {
+ if is_in_const_context(cx) {
return;
}
@@ -319,7 +319,7 @@ fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) ->
_ => return None,
};
if let Some(id) = path_to_local(l) {
- if let Some(c) = constant(cx, cx.typeck_results(), r) {
+ if let Some(c) = ConstEvalCtxt::new(cx).eval(r) {
return Some(RangeBounds {
val: c,
expr: r,
@@ -331,7 +331,7 @@ fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) ->
});
}
} else if let Some(id) = path_to_local(r) {
- if let Some(c) = constant(cx, cx.typeck_results(), l) {
+ if let Some(c) = ConstEvalCtxt::new(cx).eval(l) {
return Some(RangeBounds {
val: c,
expr: l,
@@ -451,8 +451,9 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
}) = higher::Range::hir(expr)
&& let ty = cx.typeck_results().expr_ty(start)
&& let ty::Int(_) | ty::Uint(_) = ty.kind()
- && let Some(start_idx) = constant(cx, cx.typeck_results(), start)
- && let Some(end_idx) = constant(cx, cx.typeck_results(), end)
+ && let ecx = ConstEvalCtxt::new(cx)
+ && let Some(start_idx) = ecx.eval(start)
+ && let Some(end_idx) = ecx.eval(end)
&& let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx)
&& is_empty_range(limits, ordering)
{
diff --git a/src/tools/clippy/clippy_lints/src/redundant_clone.rs b/src/tools/clippy/clippy_lints/src/redundant_clone.rs
index 3416a93e3c4ac..a1231c082e68a 100644
--- a/src/tools/clippy/clippy_lints/src/redundant_clone.rs
+++ b/src/tools/clippy/clippy_lints/src/redundant_clone.rs
@@ -96,7 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
let (fn_def_id, arg, arg_ty, clone_ret) =
unwrap_or_continue!(is_call_with_ref_arg(cx, mir, &terminator.kind));
- let from_borrow = match_def_path(cx, fn_def_id, &paths::CLONE_TRAIT_METHOD)
+ let from_borrow = cx.tcx.lang_items().get(LangItem::CloneFn) == Some(fn_def_id)
|| cx.tcx.is_diagnostic_item(sym::to_owned_method, fn_def_id)
|| (cx.tcx.is_diagnostic_item(sym::to_string_method, fn_def_id)
&& is_type_lang_item(cx, arg_ty, LangItem::String));
diff --git a/src/tools/clippy/clippy_lints/src/redundant_slicing.rs b/src/tools/clippy/clippy_lints/src/redundant_slicing.rs
index 82f22ad693d78..1c10e84d3caf6 100644
--- a/src/tools/clippy/clippy_lints/src/redundant_slicing.rs
+++ b/src/tools/clippy/clippy_lints/src/redundant_slicing.rs
@@ -1,7 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::get_parent_expr;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::{is_type_lang_item, peel_mid_ty_refs};
+use clippy_utils::ty::is_type_lang_item;
+use clippy_utils::{get_parent_expr, peel_middle_ty_refs};
use rustc_ast::util::parser::PREC_PREFIX;
use rustc_errors::Applicability;
use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
@@ -82,13 +82,12 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
&& let ExprKind::Index(indexed, range, _) = addressee.kind
&& is_type_lang_item(cx, cx.typeck_results().expr_ty_adjusted(range), LangItem::RangeFull)
{
- let (expr_ty, expr_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(expr));
- let (indexed_ty, indexed_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(indexed));
+ let (expr_ty, expr_ref_count) = peel_middle_ty_refs(cx.typeck_results().expr_ty(expr));
+ let (indexed_ty, indexed_ref_count) = peel_middle_ty_refs(cx.typeck_results().expr_ty(indexed));
let parent_expr = get_parent_expr(cx, expr);
let needs_parens_for_prefix = parent_expr.map_or(false, |parent| parent.precedence().order() > PREC_PREFIX);
- let mut app = Applicability::MachineApplicable;
- let ((lint, msg), help, sugg) = if expr_ty == indexed_ty {
+ if expr_ty == indexed_ty {
if expr_ref_count > indexed_ref_count {
// Indexing takes self by reference and can't return a reference to that
// reference as it's a local variable. The only way this could happen is if
@@ -99,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
}
let deref_count = indexed_ref_count - expr_ref_count;
- let (lint, reborrow_str, help_str) = if mutability == Mutability::Mut {
+ let ((lint, msg), reborrow_str, help_msg) = if mutability == Mutability::Mut {
// The slice was used to reborrow the mutable reference.
(DEREF_BY_SLICING_LINT, "&mut *", "reborrow the original value instead")
} else if matches!(
@@ -113,8 +112,11 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
a.kind,
Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. }))
)
- }) {
- // The slice was used to make a temporary reference.
+ }) || (matches!(
+ cx.typeck_results().expr_ty(indexed).ref_mutability(),
+ Some(Mutability::Mut)
+ ) && mutability == Mutability::Not)
+ {
(DEREF_BY_SLICING_LINT, "&*", "reborrow the original value instead")
} else if deref_count != 0 {
(DEREF_BY_SLICING_LINT, "", "dereference the original value instead")
@@ -122,38 +124,36 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
(REDUNDANT_SLICING_LINT, "", "use the original value instead")
};
- let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
- let sugg = if (deref_count != 0 || !reborrow_str.is_empty()) && needs_parens_for_prefix {
- format!("({reborrow_str}{}{snip})", "*".repeat(deref_count))
- } else {
- format!("{reborrow_str}{}{snip}", "*".repeat(deref_count))
- };
-
- (lint, help_str, sugg)
+ span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+ let mut app = Applicability::MachineApplicable;
+ let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+ let sugg = if (deref_count != 0 || !reborrow_str.is_empty()) && needs_parens_for_prefix {
+ format!("({reborrow_str}{}{snip})", "*".repeat(deref_count))
+ } else {
+ format!("{reborrow_str}{}{snip}", "*".repeat(deref_count))
+ };
+ diag.span_suggestion(expr.span, help_msg, sugg, app);
+ });
} else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
cx.param_env,
Ty::new_projection_from_args(cx.tcx, target_id, cx.tcx.mk_args(&[GenericArg::from(indexed_ty)])),
) {
if deref_ty == expr_ty {
- let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
- let sugg = if needs_parens_for_prefix {
- format!("(&{}{}*{snip})", mutability.prefix_str(), "*".repeat(indexed_ref_count))
- } else {
- format!("&{}{}*{snip}", mutability.prefix_str(), "*".repeat(indexed_ref_count))
- };
- (DEREF_BY_SLICING_LINT, "dereference the original value instead", sugg)
- } else {
- return;
+ let (lint, msg) = DEREF_BY_SLICING_LINT;
+ span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+ let mut app = Applicability::MachineApplicable;
+ let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+ let sugg = if needs_parens_for_prefix {
+ format!("(&{}{}*{snip})", mutability.prefix_str(), "*".repeat(indexed_ref_count))
+ } else {
+ format!("&{}{}*{snip}", mutability.prefix_str(), "*".repeat(indexed_ref_count))
+ };
+ diag.span_suggestion(expr.span, "dereference the original value instead", sugg, app);
+ });
}
- } else {
- return;
}
- } else {
- return;
- };
-
- span_lint_and_sugg(cx, lint, expr.span, msg, help, sugg, app);
+ }
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/ref_patterns.rs b/src/tools/clippy/clippy_lints/src/ref_patterns.rs
index 467038523b496..002c6c41d52ba 100644
--- a/src/tools/clippy/clippy_lints/src/ref_patterns.rs
+++ b/src/tools/clippy/clippy_lints/src/ref_patterns.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_ast::ast::{BindingMode, Pat, PatKind};
use rustc_lint::{EarlyContext, EarlyLintPass};
use rustc_session::declare_lint_pass;
@@ -33,14 +33,10 @@ impl EarlyLintPass for RefPatterns {
if let PatKind::Ident(BindingMode::REF, _, _) = pat.kind
&& !pat.span.from_expansion()
{
- span_lint_and_help(
- cx,
- REF_PATTERNS,
- pat.span,
- "usage of ref pattern",
- None,
- "consider using `&` for clarity instead",
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, REF_PATTERNS, pat.span, "usage of ref pattern", |diag| {
+ diag.help("consider using `&` for clarity instead");
+ });
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/regex.rs b/src/tools/clippy/clippy_lints/src/regex.rs
index 8cacb646f5148..95014b230431c 100644
--- a/src/tools/clippy/clippy_lints/src/regex.rs
+++ b/src/tools/clippy/clippy_lints/src/regex.rs
@@ -1,6 +1,6 @@
use std::fmt::Display;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
use clippy_utils::source::snippet_opt;
use clippy_utils::{def_path_def_ids, path_def_id, paths};
@@ -148,7 +148,7 @@ fn lint_syntax_error(cx: &LateContext<'_>, error: ®ex_syntax::Error, unescape
}
fn const_str<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<String> {
- constant(cx, cx.typeck_results(), e).and_then(|c| match c {
+ ConstEvalCtxt::new(cx).eval(e).and_then(|c| match c {
Constant::Str(s) => Some(s),
_ => None,
})
diff --git a/src/tools/clippy/clippy_lints/src/renamed_lints.rs b/src/tools/clippy/clippy_lints/src/renamed_lints.rs
deleted file mode 100644
index 8e999f3e89af3..0000000000000
--- a/src/tools/clippy/clippy_lints/src/renamed_lints.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-// This file is managed by `cargo dev rename_lint`. Prefer using that when possible.
-
-#[rustfmt::skip]
-pub static RENAMED_LINTS: &[(&str, &str)] = &[
- ("clippy::almost_complete_letter_range", "clippy::almost_complete_range"),
- ("clippy::blacklisted_name", "clippy::disallowed_names"),
- ("clippy::block_in_if_condition_expr", "clippy::blocks_in_conditions"),
- ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_conditions"),
- ("clippy::blocks_in_if_conditions", "clippy::blocks_in_conditions"),
- ("clippy::box_vec", "clippy::box_collection"),
- ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
- ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
- ("clippy::derive_hash_xor_eq", "clippy::derived_hash_with_manual_eq"),
- ("clippy::disallowed_method", "clippy::disallowed_methods"),
- ("clippy::disallowed_type", "clippy::disallowed_types"),
- ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
- ("clippy::identity_conversion", "clippy::useless_conversion"),
- ("clippy::if_let_some_result", "clippy::match_result_ok"),
- ("clippy::incorrect_clone_impl_on_copy_type", "clippy::non_canonical_clone_impl"),
- ("clippy::incorrect_partial_ord_impl_on_ord_type", "clippy::non_canonical_partial_ord_impl"),
- ("clippy::integer_arithmetic", "clippy::arithmetic_side_effects"),
- ("clippy::logic_bug", "clippy::overly_complex_bool_expr"),
- ("clippy::new_without_default_derive", "clippy::new_without_default"),
- ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
- ("clippy::option_expect_used", "clippy::expect_used"),
- ("clippy::option_map_unwrap_or", "clippy::map_unwrap_or"),
- ("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or"),
- ("clippy::option_unwrap_used", "clippy::unwrap_used"),
- ("clippy::overflow_check_conditional", "clippy::panicking_overflow_checks"),
- ("clippy::ref_in_deref", "clippy::needless_borrow"),
- ("clippy::result_expect_used", "clippy::expect_used"),
- ("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or"),
- ("clippy::result_unwrap_used", "clippy::unwrap_used"),
- ("clippy::single_char_push_str", "clippy::single_char_add_str"),
- ("clippy::stutter", "clippy::module_name_repetitions"),
- ("clippy::thread_local_initializer_can_be_made_const", "clippy::missing_const_for_thread_local"),
- ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
- ("clippy::unwrap_or_else_default", "clippy::unwrap_or_default"),
- ("clippy::zero_width_space", "clippy::invisible_characters"),
- ("clippy::cast_ref_to_mut", "invalid_reference_casting"),
- ("clippy::clone_double_ref", "suspicious_double_ref_op"),
- ("clippy::cmp_nan", "invalid_nan_comparisons"),
- ("clippy::drop_bounds", "drop_bounds"),
- ("clippy::drop_copy", "dropping_copy_types"),
- ("clippy::drop_ref", "dropping_references"),
- ("clippy::fn_null_check", "useless_ptr_null_checks"),
- ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
- ("clippy::for_loop_over_result", "for_loops_over_fallibles"),
- ("clippy::for_loops_over_fallibles", "for_loops_over_fallibles"),
- ("clippy::forget_copy", "forgetting_copy_types"),
- ("clippy::forget_ref", "forgetting_references"),
- ("clippy::into_iter_on_array", "array_into_iter"),
- ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
- ("clippy::invalid_ref", "invalid_value"),
- ("clippy::invalid_utf8_in_unchecked", "invalid_from_utf8_unchecked"),
- ("clippy::let_underscore_drop", "let_underscore_drop"),
- ("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums"),
- ("clippy::panic_params", "non_fmt_panics"),
- ("clippy::positional_named_format_parameters", "named_arguments_used_positionally"),
- ("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr"),
- ("clippy::undropped_manually_drops", "undropped_manually_drops"),
- ("clippy::unknown_clippy_lints", "unknown_lints"),
- ("clippy::unused_label", "unused_labels"),
- ("clippy::vtable_address_comparisons", "ambiguous_wide_pointer_comparisons"),
-];
diff --git a/src/tools/clippy/clippy_lints/src/repeat_vec_with_capacity.rs b/src/tools/clippy/clippy_lints/src/repeat_vec_with_capacity.rs
index 792d8fc88f0bb..678681ea4252d 100644
--- a/src/tools/clippy/clippy_lints/src/repeat_vec_with_capacity.rs
+++ b/src/tools/clippy/clippy_lints/src/repeat_vec_with_capacity.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::higher::VecArgs;
use clippy_utils::macros::matching_root_macro_call;
@@ -69,7 +69,7 @@ fn check_vec_macro(cx: &LateContext<'_>, expr: &Expr<'_>) {
&& let Some(VecArgs::Repeat(repeat_expr, len_expr)) = VecArgs::hir(cx, expr)
&& fn_def_id(cx, repeat_expr).is_some_and(|did| match_def_path(cx, did, &paths::VEC_WITH_CAPACITY))
&& !len_expr.span.from_expansion()
- && let Some(Constant::Int(2..)) = constant(cx, cx.typeck_results(), expr_or_init(cx, len_expr))
+ && let Some(Constant::Int(2..)) = ConstEvalCtxt::new(cx).eval(expr_or_init(cx, len_expr))
{
emit_lint(
cx,
diff --git a/src/tools/clippy/clippy_lints/src/returns.rs b/src/tools/clippy/clippy_lints/src/returns.rs
index 8ced47b48a43d..13016cdadb072 100644
--- a/src/tools/clippy/clippy_lints/src/returns.rs
+++ b/src/tools/clippy/clippy_lints/src/returns.rs
@@ -395,7 +395,7 @@ fn check_final_expr<'tcx>(
// Returns may be used to turn an expression into a statement in rustc's AST.
// This allows the addition of attributes, like `#[allow]` (See: clippy#9361)
// `#[expect(clippy::needless_return)]` needs to be handled separatly to
- // actually fullfil the expectation (clippy::#12998)
+ // actually fulfill the expectation (clippy::#12998)
match cx.tcx.hir().attrs(expr.hir_id) {
[] => {},
[attr] => {
diff --git a/src/tools/clippy/clippy_lints/src/semicolon_block.rs b/src/tools/clippy/clippy_lints/src/semicolon_block.rs
index 7615c21276d69..09f1c11235291 100644
--- a/src/tools/clippy/clippy_lints/src/semicolon_block.rs
+++ b/src/tools/clippy/clippy_lints/src/semicolon_block.rs
@@ -1,5 +1,5 @@
use clippy_config::Conf;
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_errors::Applicability;
use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -92,11 +92,10 @@ impl SemicolonBlock {
semi_span,
"consider moving the `;` inside the block for consistent formatting",
|diag| {
- multispan_sugg_with_applicability(
- diag,
+ diag.multipart_suggestion(
"put the `;` here",
+ vec![(remove_span, String::new()), (insert_span, ";".to_owned())],
Applicability::MachineApplicable,
- [(remove_span, String::new()), (insert_span, ";".to_owned())],
);
},
);
@@ -124,11 +123,10 @@ impl SemicolonBlock {
block.span,
"consider moving the `;` outside the block for consistent formatting",
|diag| {
- multispan_sugg_with_applicability(
- diag,
+ diag.multipart_suggestion(
"put the `;` here",
+ vec![(remove_span, String::new()), (insert_span, ";".to_owned())],
Applicability::MachineApplicable,
- [(remove_span, String::new()), (insert_span, ";".to_owned())],
);
},
);
diff --git a/src/tools/clippy/clippy_lints/src/set_contains_or_insert.rs b/src/tools/clippy/clippy_lints/src/set_contains_or_insert.rs
index 5e65b9fa5171d..e6fe76493974a 100644
--- a/src/tools/clippy/clippy_lints/src/set_contains_or_insert.rs
+++ b/src/tools/clippy/clippy_lints/src/set_contains_or_insert.rs
@@ -12,8 +12,8 @@ use rustc_span::{sym, Span};
declare_clippy_lint! {
/// ### What it does
- /// Checks for usage of `contains` to see if a value is not
- /// present on `HashSet` followed by a `insert`.
+ /// Checks for usage of `contains` to see if a value is not present
+ /// in a set like `HashSet` or `BTreeSet`, followed by an `insert`.
///
/// ### Why is this bad?
/// Using just `insert` and checking the returned `bool` is more efficient.
@@ -45,12 +45,12 @@ declare_clippy_lint! {
#[clippy::version = "1.80.0"]
pub SET_CONTAINS_OR_INSERT,
nursery,
- "call to `HashSet::contains` followed by `HashSet::insert`"
+ "call to `<set>::contains` followed by `<set>::insert`"
}
-declare_lint_pass!(HashsetInsertAfterContains => [SET_CONTAINS_OR_INSERT]);
+declare_lint_pass!(SetContainsOrInsert => [SET_CONTAINS_OR_INSERT]);
-impl<'tcx> LateLintPass<'tcx> for HashsetInsertAfterContains {
+impl<'tcx> LateLintPass<'tcx> for SetContainsOrInsert {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
if !expr.span.from_expansion()
&& let Some(higher::If {
@@ -58,14 +58,14 @@ impl<'tcx> LateLintPass<'tcx> for HashsetInsertAfterContains {
then: then_expr,
..
}) = higher::If::hir(expr)
- && let Some(contains_expr) = try_parse_op_call(cx, cond_expr, sym!(contains))//try_parse_contains(cx, cond_expr)
+ && let Some((contains_expr, sym)) = try_parse_op_call(cx, cond_expr, sym!(contains))//try_parse_contains(cx, cond_expr)
&& let Some(insert_expr) = find_insert_calls(cx, &contains_expr, then_expr)
{
span_lint(
cx,
SET_CONTAINS_OR_INSERT,
vec![contains_expr.span, insert_expr.span],
- "usage of `HashSet::insert` after `HashSet::contains`",
+ format!("usage of `{sym}::insert` after `{sym}::contains`"),
);
}
}
@@ -77,7 +77,11 @@ struct OpExpr<'tcx> {
span: Span,
}
-fn try_parse_op_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, symbol: Symbol) -> Option<OpExpr<'tcx>> {
+fn try_parse_op_call<'tcx>(
+ cx: &LateContext<'tcx>,
+ expr: &'tcx Expr<'_>,
+ symbol: Symbol,
+) -> Option<(OpExpr<'tcx>, Symbol)> {
let expr = peel_hir_expr_while(expr, |e| {
if let ExprKind::Unary(UnOp::Not, e) = e.kind {
Some(e)
@@ -97,11 +101,12 @@ fn try_parse_op_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, symbol:
});
let receiver = receiver.peel_borrows();
let receiver_ty = cx.typeck_results().expr_ty(receiver).peel_refs();
- if value.span.eq_ctxt(expr.span)
- && is_type_diagnostic_item(cx, receiver_ty, sym::HashSet)
- && path.ident.name == symbol
- {
- return Some(OpExpr { receiver, value, span });
+ if value.span.eq_ctxt(expr.span) && path.ident.name == symbol {
+ for sym in &[sym::HashSet, sym::BTreeSet] {
+ if is_type_diagnostic_item(cx, receiver_ty, *sym) {
+ return Some((OpExpr { receiver, value, span }, *sym));
+ }
+ }
}
}
None
@@ -113,7 +118,7 @@ fn find_insert_calls<'tcx>(
expr: &'tcx Expr<'_>,
) -> Option<OpExpr<'tcx>> {
for_each_expr(cx, expr, |e| {
- if let Some(insert_expr) = try_parse_op_call(cx, e, sym!(insert))
+ if let Some((insert_expr, _)) = try_parse_op_call(cx, e, sym!(insert))
&& SpanlessEq::new(cx).eq_expr(contains_expr.receiver, insert_expr.receiver)
&& SpanlessEq::new(cx).eq_expr(contains_expr.value, insert_expr.value)
{
diff --git a/src/tools/clippy/clippy_lints/src/shadow.rs b/src/tools/clippy/clippy_lints/src/shadow.rs
index 80f5fd0b49441..7ae0310b6d996 100644
--- a/src/tools/clippy/clippy_lints/src/shadow.rs
+++ b/src/tools/clippy/clippy_lints/src/shadow.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet;
use clippy_utils::visitors::is_local_used;
use rustc_data_structures::fx::FxHashMap;
@@ -194,14 +194,9 @@ fn lint_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, shadowed: HirId, span: Span)
(SHADOW_UNRELATED, msg)
},
};
- span_lint_and_note(
- cx,
- lint,
- span,
- msg,
- Some(cx.tcx.hir().span(shadowed)),
- "previous binding is here",
- );
+ span_lint_and_then(cx, lint, span, msg, |diag| {
+ diag.span_note(cx.tcx.hir().span(shadowed), "previous binding is here");
+ });
}
/// Returns true if the expression is a simple transformation of a local binding such as `&x`
diff --git a/src/tools/clippy/clippy_lints/src/single_char_lifetime_names.rs b/src/tools/clippy/clippy_lints/src/single_char_lifetime_names.rs
index 72feb977c3104..d92b890950a3f 100644
--- a/src/tools/clippy/clippy_lints/src/single_char_lifetime_names.rs
+++ b/src/tools/clippy/clippy_lints/src/single_char_lifetime_names.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use rustc_ast::ast::{GenericParam, GenericParamKind};
use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
use rustc_middle::lint::in_external_macro;
@@ -48,13 +48,15 @@ impl EarlyLintPass for SingleCharLifetimeNames {
if let GenericParamKind::Lifetime = param.kind {
if !param.is_placeholder && param.ident.as_str().len() <= 2 {
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
ctx,
SINGLE_CHAR_LIFETIME_NAMES,
param.ident.span,
"single-character lifetime names are likely uninformative",
- None,
- "use a more informative name",
+ |diag| {
+ diag.help("use a more informative name");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/size_of_ref.rs b/src/tools/clippy/clippy_lints/src/size_of_ref.rs
index 8d7f12af86e8a..b3d32a6d7d84c 100644
--- a/src/tools/clippy/clippy_lints/src/size_of_ref.rs
+++ b/src/tools/clippy/clippy_lints/src/size_of_ref.rs
@@ -1,6 +1,5 @@
use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::path_def_id;
-use clippy_utils::ty::peel_mid_ty_refs;
+use clippy_utils::{path_def_id, peel_middle_ty_refs};
use rustc_hir::{Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_session::declare_lint_pass;
@@ -60,7 +59,7 @@ impl LateLintPass<'_> for SizeOfRef {
&& let Some(def_id) = path_def_id(cx, path)
&& cx.tcx.is_diagnostic_item(sym::mem_size_of_val, def_id)
&& let arg_ty = cx.typeck_results().expr_ty(arg)
- && peel_mid_ty_refs(arg_ty).1 > 1
+ && peel_middle_ty_refs(arg_ty).1 > 1
{
span_lint_and_help(
cx,
diff --git a/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs b/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
index 12b70075a3d5e..974e21df817a8 100644
--- a/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
+++ b/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
@@ -1,11 +1,15 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_config::msrvs::Msrv;
+use clippy_config::Conf;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::is_from_proc_macro;
+use rustc_attr::{StabilityLevel, StableSince};
use rustc_errors::Applicability;
use rustc_hir::def::Res;
use rustc_hir::def_id::DefId;
use rustc_hir::{HirId, Path, PathSegment};
use rustc_lint::{LateContext, LateLintPass, LintContext};
use rustc_middle::lint::in_external_macro;
+use rustc_semver::RustcVersion;
use rustc_session::impl_lint_pass;
use rustc_span::symbol::kw;
use rustc_span::{sym, Span};
@@ -66,6 +70,10 @@ declare_clippy_lint! {
/// imported from core to ensure disabling `alloc` does not cause the crate to fail to compile. This lint
/// is also useful for crates migrating to become `no_std` compatible.
///
+ /// ### Known problems
+ /// The lint is only partially aware of the required MSRV for items that were originally in `std` but moved
+ /// to `core`.
+ ///
/// ### Example
/// ```no_run
/// # extern crate alloc;
@@ -81,20 +89,30 @@ declare_clippy_lint! {
"type is imported from alloc when available in core"
}
-#[derive(Default)]
pub struct StdReexports {
// Paths which can be either a module or a macro (e.g. `std::env`) will cause this check to happen
// twice. First for the mod, second for the macro. This is used to avoid the lint reporting for the macro
// when the path could be also be used to access the module.
prev_span: Span,
+ msrv: Msrv,
}
+
+impl StdReexports {
+ pub fn new(conf: &'static Conf) -> Self {
+ Self {
+ prev_span: Span::default(),
+ msrv: conf.msrv.clone(),
+ }
+ }
+}
+
impl_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
impl<'tcx> LateLintPass<'tcx> for StdReexports {
fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, _: HirId) {
if let Res::Def(_, def_id) = path.res
&& let Some(first_segment) = get_first_segment(path)
- && is_stable(cx, def_id)
+ && is_stable(cx, def_id, &self.msrv)
&& !in_external_macro(cx.sess(), path.span)
&& !is_from_proc_macro(cx, &first_segment.ident)
{
@@ -118,19 +136,27 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
_ => return,
};
if first_segment.ident.span != self.prev_span {
- span_lint_and_sugg(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
lint,
first_segment.ident.span,
format!("used import from `{used_mod}` instead of `{replace_with}`"),
- format!("consider importing the item from `{replace_with}`"),
- replace_with.to_string(),
- Applicability::MachineApplicable,
+ |diag| {
+ diag.span_suggestion(
+ first_segment.ident.span,
+ format!("consider importing the item from `{replace_with}`"),
+ replace_with.to_string(),
+ Applicability::MachineApplicable,
+ );
+ },
);
self.prev_span = first_segment.ident.span;
}
}
}
+
+ extract_msrv_attr!(LateContext);
}
/// Returns the first named segment of a [`Path`].
@@ -146,16 +172,29 @@ fn get_first_segment<'tcx>(path: &Path<'tcx>) -> Option<&'tcx PathSegment<'tcx>>
}
}
-/// Checks if all ancestors of `def_id` are stable, to avoid linting
-/// [unstable moves](https://github.com/rust-lang/rust/pull/95956)
-fn is_stable(cx: &LateContext<'_>, mut def_id: DefId) -> bool {
+/// Checks if all ancestors of `def_id` meet `msrv` to avoid linting [unstable moves](https://github.com/rust-lang/rust/pull/95956)
+/// or now stable moves that were once unstable.
+///
+/// Does not catch individually moved items
+fn is_stable(cx: &LateContext<'_>, mut def_id: DefId, msrv: &Msrv) -> bool {
loop {
- if cx
- .tcx
- .lookup_stability(def_id)
- .map_or(false, |stability| stability.is_unstable())
+ if let Some(stability) = cx.tcx.lookup_stability(def_id)
+ && let StabilityLevel::Stable {
+ since,
+ allowed_through_unstable_modules: false,
+ } = stability.level
{
- return false;
+ let stable = match since {
+ StableSince::Version(v) => {
+ msrv.meets(RustcVersion::new(v.major.into(), v.minor.into(), v.patch.into()))
+ },
+ StableSince::Current => msrv.current().is_none(),
+ StableSince::Err => false,
+ };
+
+ if !stable {
+ return false;
+ }
}
match cx.tcx.opt_parent(def_id) {
diff --git a/src/tools/clippy/clippy_lints/src/strings.rs b/src/tools/clippy/clippy_lints/src/strings.rs
index 7da661485abfc..cfc387886dc01 100644
--- a/src/tools/clippy/clippy_lints/src/strings.rs
+++ b/src/tools/clippy/clippy_lints/src/strings.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
use clippy_utils::source::{snippet, snippet_with_applicability};
use clippy_utils::ty::is_type_lang_item;
use clippy_utils::{
@@ -399,17 +399,16 @@ impl<'tcx> LateLintPass<'tcx> for StrToString {
&& let ty::Ref(_, ty, ..) = ty.kind()
&& ty.is_str()
{
- let mut applicability = Applicability::MachineApplicable;
- let snippet = snippet_with_applicability(cx, self_arg.span, "..", &mut applicability);
-
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
STR_TO_STRING,
expr.span,
"`to_string()` called on a `&str`",
- "try",
- format!("{snippet}.to_owned()"),
- applicability,
+ |diag| {
+ let mut applicability = Applicability::MachineApplicable;
+ let snippet = snippet_with_applicability(cx, self_arg.span, "..", &mut applicability);
+ diag.span_suggestion(expr.span, "try", format!("{snippet}.to_owned()"), applicability);
+ },
);
}
}
@@ -455,13 +454,15 @@ impl<'tcx> LateLintPass<'tcx> for StringToString {
&& let ty = cx.typeck_results().expr_ty(self_arg)
&& is_type_lang_item(cx, ty, LangItem::String)
{
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
STRING_TO_STRING,
expr.span,
"`to_string()` called on a `String`",
- None,
- "consider using `.clone()`",
+ |diag| {
+ diag.help("consider using `.clone()`");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/suspicious_xor_used_as_pow.rs b/src/tools/clippy/clippy_lints/src/suspicious_xor_used_as_pow.rs
index d150a5f858aa3..d1d822a553260 100644
--- a/src/tools/clippy/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/src/tools/clippy/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::numeric_literal::NumericLiteral;
use clippy_utils::source::snippet;
use rustc_ast::LitKind;
@@ -43,14 +43,19 @@ impl LateLintPass<'_> for ConfusingXorAndPow {
&& NumericLiteral::from_lit_kind(&snippet(cx, lit_right.span, ".."), &lit_right.node)
.is_some_and(|x| x.is_decimal())
{
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
SUSPICIOUS_XOR_USED_AS_POW,
expr.span,
"`^` is not the exponentiation operator",
- "did you mean to write",
- format!("{}.pow({})", lit_left.node, lit_right.node),
- Applicability::MaybeIncorrect,
+ |diag| {
+ diag.span_suggestion_verbose(
+ expr.span,
+ "did you mean to write",
+ format!("{}.pow({})", lit_left.node, lit_right.node),
+ Applicability::MaybeIncorrect,
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/swap.rs b/src/tools/clippy/clippy_lints/src/swap.rs
index 93bad86580975..197011cde3a1a 100644
--- a/src/tools/clippy/clippy_lints/src/swap.rs
+++ b/src/tools/clippy/clippy_lints/src/swap.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::{snippet_indent, snippet_with_context};
use clippy_utils::sugg::Sugg;
use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{can_mut_borrow_both, eq_expr_value, in_constant, std_or_core};
+use clippy_utils::{can_mut_borrow_both, eq_expr_value, is_in_const_context, std_or_core};
use itertools::Itertools;
use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -170,7 +170,7 @@ fn generate_swap_warning<'tcx>(
/// Implementation of the `MANUAL_SWAP` lint.
fn check_manual_swap<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
- if in_constant(cx, block.hir_id) {
+ if is_in_const_context(cx) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/tests_outside_test_module.rs b/src/tools/clippy/clippy_lints/src/tests_outside_test_module.rs
index 58e42892c41de..25d0a16e2ab45 100644
--- a/src/tools/clippy/clippy_lints/src/tests_outside_test_module.rs
+++ b/src/tools/clippy/clippy_lints/src/tests_outside_test_module.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_in_cfg_test, is_in_test_function};
use rustc_hir::intravisit::FnKind;
use rustc_hir::{Body, FnDecl};
@@ -61,13 +61,15 @@ impl LateLintPass<'_> for TestsOutsideTestModule {
&& is_in_test_function(cx.tcx, body.id().hir_id)
&& !is_in_cfg_test(cx.tcx, body.id().hir_id)
{
- span_lint_and_note(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
TESTS_OUTSIDE_TEST_MODULE,
sp,
"this function marked with #[test] is outside a #[cfg(test)] module",
- None,
- "move it to a testing module marked with #[cfg(test)]",
+ |diag| {
+ diag.note("move it to a testing module marked with #[cfg(test)]");
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/transmute/mod.rs b/src/tools/clippy/clippy_lints/src/transmute/mod.rs
index 9c6813a54b943..373bf61d8ff94 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/mod.rs
@@ -21,7 +21,7 @@ mod wrong_transmute;
use clippy_config::msrvs::Msrv;
use clippy_config::Conf;
-use clippy_utils::in_constant;
+use clippy_utils::is_in_const_context;
use rustc_hir::{Expr, ExprKind, QPath};
use rustc_lint::{LateContext, LateLintPass};
use rustc_session::impl_lint_pass;
@@ -595,7 +595,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
// - from/to bits (https://github.com/rust-lang/rust/issues/73736)
// - dereferencing raw pointers (https://github.com/rust-lang/rust/issues/51911)
// - char conversions (https://github.com/rust-lang/rust/issues/89259)
- let const_context = in_constant(cx, e.hir_id);
+ let const_context = is_in_const_context(cx);
let (from_ty, from_ty_adjusted) = match cx.typeck_results().expr_adjustments(arg) {
[] => (cx.typeck_results().expr_ty(arg), false),
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_null_to_fn.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_null_to_fn.rs
index b26365e34ab94..7acf3be51fb7e 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
use rustc_hir::{Expr, ExprKind};
@@ -33,10 +33,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
// Catching:
// transmute over constants that resolve to `null`.
ExprKind::Path(ref _qpath)
- if matches!(
- constant(cx, cx.typeck_results(), casts_peeled),
- Some(Constant::RawPtr(0))
- ) =>
+ if matches!(ConstEvalCtxt::new(cx).eval(casts_peeled), Some(Constant::RawPtr(0))) =>
{
lint_expr(cx, expr);
true
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmuting_null.rs b/src/tools/clippy/clippy_lints/src/transmute/transmuting_null.rs
index 471bd44b5d5ee..544014bd32b30 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmuting_null.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmuting_null.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint;
use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
use rustc_hir::{Expr, ExprKind};
@@ -17,7 +17,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
// Catching transmute over constants that resolve to `null`.
if let ExprKind::Path(ref _qpath) = arg.kind
- && let Some(Constant::RawPtr(0)) = constant(cx, cx.typeck_results(), arg)
+ && let Some(Constant::RawPtr(0)) = ConstEvalCtxt::new(cx).eval(arg)
{
span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
return true;
diff --git a/src/tools/clippy/clippy_lints/src/types/borrowed_box.rs b/src/tools/clippy/clippy_lints/src/types/borrowed_box.rs
index 83cc9f2d8df23..2fcfc71a8c768 100644
--- a/src/tools/clippy/clippy_lints/src/types/borrowed_box.rs
+++ b/src/tools/clippy/clippy_lints/src/types/borrowed_box.rs
@@ -48,15 +48,15 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
let inner_snippet = snippet(cx, inner.span, "..");
let suggestion = match &inner.kind {
TyKind::TraitObject(bounds, lt_bound, _) if bounds.len() > 1 || !lt_bound.is_elided() => {
- format!("&{ltopt}({})", &inner_snippet)
+ format!("&{ltopt}({inner_snippet})")
},
TyKind::Path(qpath)
if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
.map_or(false, |bounds| bounds.len() > 1) =>
{
- format!("&{ltopt}({})", &inner_snippet)
+ format!("&{ltopt}({inner_snippet})")
},
- _ => format!("&{ltopt}{}", &inner_snippet),
+ _ => format!("&{ltopt}{inner_snippet}"),
};
span_lint_and_sugg(
cx,
@@ -82,16 +82,14 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
// Returns true if given type is `Any` trait.
fn is_any_trait(cx: &LateContext<'_>, t: &hir::Ty<'_>) -> bool {
if let TyKind::TraitObject(traits, ..) = t.kind {
- return traits
- .iter()
- .any(|(bound, _)| {
- if let Some(trait_did) = bound.trait_ref.trait_def_id()
- && cx.tcx.is_diagnostic_item(sym::Any, trait_did)
- {
- return true;
- }
- false
- });
+ return traits.iter().any(|(bound, _)| {
+ if let Some(trait_did) = bound.trait_ref.trait_def_id()
+ && cx.tcx.is_diagnostic_item(sym::Any, trait_did)
+ {
+ return true;
+ }
+ false
+ });
}
false
diff --git a/src/tools/clippy/clippy_lints/src/types/rc_buffer.rs b/src/tools/clippy/clippy_lints/src/types/rc_buffer.rs
index f6c2d8d5a5ed9..d691f1878b11b 100644
--- a/src/tools/clippy/clippy_lints/src/types/rc_buffer.rs
+++ b/src/tools/clippy/clippy_lints/src/types/rc_buffer.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::{path_def_id, qpath_generic_tys};
use rustc_errors::Applicability;
@@ -13,14 +13,15 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
let app = Applicability::Unspecified;
if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
if let Some(alternate) = match_buffer_type(cx, qpath) {
- span_lint_and_sugg(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
RC_BUFFER,
hir_ty.span,
"usage of `Rc<T>` when T is a buffer type",
- "try",
- format!("Rc<{alternate}>"),
- app,
+ |diag| {
+ diag.span_suggestion(hir_ty.span, "try", format!("Rc<{alternate}>"), app);
+ },
);
} else {
let Some(ty) = qpath_generic_tys(qpath).next() else {
@@ -35,31 +36,37 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
Some(ty) => ty.span,
None => return false,
};
- let mut applicability = app;
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
RC_BUFFER,
hir_ty.span,
"usage of `Rc<T>` when T is a buffer type",
- "try",
- format!(
- "Rc<[{}]>",
- snippet_with_applicability(cx, inner_span, "..", &mut applicability)
- ),
- app,
+ |diag| {
+ let mut applicability = app;
+ diag.span_suggestion(
+ hir_ty.span,
+ "try",
+ format!(
+ "Rc<[{}]>",
+ snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+ ),
+ app,
+ );
+ },
);
return true;
}
} else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
if let Some(alternate) = match_buffer_type(cx, qpath) {
- span_lint_and_sugg(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
RC_BUFFER,
hir_ty.span,
"usage of `Arc<T>` when T is a buffer type",
- "try",
- format!("Arc<{alternate}>"),
- app,
+ |diag| {
+ diag.span_suggestion(hir_ty.span, "try", format!("Arc<{alternate}>"), app);
+ },
);
} else if let Some(ty) = qpath_generic_tys(qpath).next() {
let Some(id) = path_def_id(cx, ty) else { return false };
@@ -71,18 +78,23 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
Some(ty) => ty.span,
None => return false,
};
- let mut applicability = app;
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
RC_BUFFER,
hir_ty.span,
"usage of `Arc<T>` when T is a buffer type",
- "try",
- format!(
- "Arc<[{}]>",
- snippet_with_applicability(cx, inner_span, "..", &mut applicability)
- ),
- app,
+ |diag| {
+ let mut applicability = app;
+ diag.span_suggestion(
+ hir_ty.span,
+ "try",
+ format!(
+ "Arc<[{}]>",
+ snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+ ),
+ app,
+ );
+ },
);
return true;
}
diff --git a/src/tools/clippy/clippy_lints/src/types/rc_mutex.rs b/src/tools/clippy/clippy_lints/src/types/rc_mutex.rs
index afc319217042f..7b13debc01ef8 100644
--- a/src/tools/clippy/clippy_lints/src/types/rc_mutex.rs
+++ b/src/tools/clippy/clippy_lints/src/types/rc_mutex.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::{path_def_id, qpath_generic_tys};
use rustc_hir::def_id::DefId;
use rustc_hir::{self as hir, QPath};
@@ -13,14 +13,10 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
&& let Some(id) = path_def_id(cx, arg)
&& cx.tcx.is_diagnostic_item(sym::Mutex, id)
{
- span_lint_and_help(
- cx,
- RC_MUTEX,
- hir_ty.span,
- "usage of `Rc<Mutex<_>>`",
- None,
- "consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead",
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, RC_MUTEX, hir_ty.span, "usage of `Rc<Mutex<_>>`", |diag| {
+ diag.help("consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead");
+ });
return true;
}
diff --git a/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs b/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
index 3ab30bf5dba7d..f51c5f74d9930 100644
--- a/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -1,7 +1,7 @@
use std::ops::ControlFlow;
use clippy_config::Conf;
-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::source::walk_span_to_context;
use clippy_utils::visitors::{for_each_expr, Descend};
@@ -129,13 +129,15 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
block.span
};
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
UNDOCUMENTED_UNSAFE_BLOCKS,
span,
"unsafe block missing a safety comment",
- None,
- "consider adding a safety comment on the preceding line",
+ |diag| {
+ diag.help("consider adding a safety comment on the preceding line");
+ },
);
}
@@ -145,13 +147,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
&& let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, tail.span, tail.hir_id)
&& let Some(help_span) = expr_has_unnecessary_safety_comment(cx, tail, pos)
{
- span_lint_and_help(
+ span_lint_and_then(
cx,
UNNECESSARY_SAFETY_COMMENT,
tail.span,
"expression has unnecessary safety comment",
- Some(help_span),
- "consider removing the safety comment",
+ |diag| {
+ diag.span_help(help_span, "consider removing the safety comment");
+ },
);
}
}
@@ -168,13 +171,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
&& let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, stmt.span, stmt.hir_id)
&& let Some(help_span) = expr_has_unnecessary_safety_comment(cx, expr, pos)
{
- span_lint_and_help(
+ span_lint_and_then(
cx,
UNNECESSARY_SAFETY_COMMENT,
stmt.span,
"statement has unnecessary safety comment",
- Some(help_span),
- "consider removing the safety comment",
+ |diag| {
+ diag.span_help(help_span, "consider removing the safety comment");
+ },
);
}
}
@@ -210,13 +214,15 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
item.span
};
- span_lint_and_help(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
UNDOCUMENTED_UNSAFE_BLOCKS,
span,
"unsafe impl missing a safety comment",
- None,
- "consider adding a safety comment on the preceding line",
+ |diag| {
+ diag.help("consider adding a safety comment on the preceding line");
+ },
);
}
},
@@ -225,13 +231,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
let (span, help_span) = mk_spans(pos);
- span_lint_and_help(
+ span_lint_and_then(
cx,
UNNECESSARY_SAFETY_COMMENT,
span,
"impl has unnecessary safety comment",
- Some(help_span),
- "consider removing the safety comment",
+ |diag| {
+ diag.span_help(help_span, "consider removing the safety comment");
+ },
);
}
},
@@ -246,13 +253,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
) {
let (span, help_span) = mk_spans(pos);
- span_lint_and_help(
+ span_lint_and_then(
cx,
UNNECESSARY_SAFETY_COMMENT,
span,
format!("{} has unnecessary safety comment", item.kind.descr()),
- Some(help_span),
- "consider removing the safety comment",
+ |diag| {
+ diag.span_help(help_span, "consider removing the safety comment");
+ },
);
}
}
@@ -263,13 +271,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
let (span, help_span) = mk_spans(pos);
- span_lint_and_help(
+ span_lint_and_then(
cx,
UNNECESSARY_SAFETY_COMMENT,
span,
format!("{} has unnecessary safety comment", item.kind.descr()),
- Some(help_span),
- "consider removing the safety comment",
+ |diag| {
+ diag.span_help(help_span, "consider removing the safety comment");
+ },
);
}
},
diff --git a/src/tools/clippy/clippy_lints/src/unicode.rs b/src/tools/clippy/clippy_lints/src/unicode.rs
index d42697b31d1f2..e1fc644e4ceeb 100644
--- a/src/tools/clippy/clippy_lints/src/unicode.rs
+++ b/src/tools/clippy/clippy_lints/src/unicode.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::is_lint_allowed;
use clippy_utils::macros::span_is_local;
use clippy_utils::source::snippet;
@@ -105,45 +105,51 @@ fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
let string = snippet(cx, span, "");
if string.chars().any(|c| ['\u{200B}', '\u{ad}', '\u{2060}'].contains(&c)) {
- span_lint_and_sugg(
- cx,
- INVISIBLE_CHARACTERS,
- span,
- "invisible character detected",
- "consider replacing the string with",
- string
- .replace('\u{200B}', "\\u{200B}")
- .replace('\u{ad}', "\\u{AD}")
- .replace('\u{2060}', "\\u{2060}"),
- Applicability::MachineApplicable,
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, INVISIBLE_CHARACTERS, span, "invisible character detected", |diag| {
+ diag.span_suggestion(
+ span,
+ "consider replacing the string with",
+ string
+ .replace('\u{200B}', "\\u{200B}")
+ .replace('\u{ad}', "\\u{AD}")
+ .replace('\u{2060}', "\\u{2060}"),
+ Applicability::MachineApplicable,
+ );
+ });
}
if string.chars().any(|c| c as u32 > 0x7F) {
- span_lint_and_sugg(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
NON_ASCII_LITERAL,
span,
"literal non-ASCII character detected",
- "consider replacing the string with",
- if is_lint_allowed(cx, UNICODE_NOT_NFC, id) {
- escape(string.chars())
- } else {
- escape(string.nfc())
+ |diag| {
+ diag.span_suggestion(
+ span,
+ "consider replacing the string with",
+ if is_lint_allowed(cx, UNICODE_NOT_NFC, id) {
+ escape(string.chars())
+ } else {
+ escape(string.nfc())
+ },
+ Applicability::MachineApplicable,
+ );
},
- Applicability::MachineApplicable,
);
}
if is_lint_allowed(cx, NON_ASCII_LITERAL, id) && string.chars().zip(string.nfc()).any(|(a, b)| a != b) {
- span_lint_and_sugg(
- cx,
- UNICODE_NOT_NFC,
- span,
- "non-NFC Unicode sequence detected",
- "consider replacing the string with",
- string.nfc().collect::<String>(),
- Applicability::MachineApplicable,
- );
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(cx, UNICODE_NOT_NFC, span, "non-NFC Unicode sequence detected", |diag| {
+ diag.span_suggestion(
+ span,
+ "consider replacing the string with",
+ string.nfc().collect::<String>(),
+ Applicability::MachineApplicable,
+ );
+ });
}
}
diff --git a/src/tools/clippy/clippy_lints/src/unused_result_ok.rs b/src/tools/clippy/clippy_lints/src/unused_result_ok.rs
new file mode 100644
index 0000000000000..297288db0a56b
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/unused_result_ok.rs
@@ -0,0 +1,59 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir::{ExprKind, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::declare_lint_pass;
+use rustc_span::sym;
+
+declare_clippy_lint! {
+ /// ### What it does
+ /// Checks for calls to `Result::ok()` without using the returned `Option`.
+ ///
+ /// ### Why is this bad?
+ /// Using `Result::ok()` may look like the result is checked like `unwrap` or `expect` would do
+ /// but it only silences the warning caused by `#[must_use]` on the `Result`.
+ ///
+ /// ### Example
+ /// ```no_run
+ /// # fn some_function() -> Result<(), ()> { Ok(()) }
+ /// some_function().ok();
+ /// ```
+ /// Use instead:
+ /// ```no_run
+ /// # fn some_function() -> Result<(), ()> { Ok(()) }
+ /// let _ = some_function();
+ /// ```
+ #[clippy::version = "1.70.0"]
+ pub UNUSED_RESULT_OK,
+ restriction,
+ "Use of `.ok()` to silence `Result`'s `#[must_use]` is misleading. Use `let _ =` instead."
+}
+declare_lint_pass!(UnusedResultOk => [UNUSED_RESULT_OK]);
+
+impl LateLintPass<'_> for UnusedResultOk {
+ fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+ if let StmtKind::Semi(expr) = stmt.kind
+ && let ExprKind::MethodCall(ok_path, recv, [], ..) = expr.kind //check is expr.ok() has type Result<T,E>.ok(, _)
+ && ok_path.ident.as_str() == "ok"
+ && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
+ && !in_external_macro(cx.sess(), stmt.span)
+ {
+ let ctxt = expr.span.ctxt();
+ let mut applicability = Applicability::MaybeIncorrect;
+ let snippet = snippet_with_context(cx, recv.span, ctxt, "", &mut applicability).0;
+ let sugg = format!("let _ = {snippet}");
+ span_lint_and_sugg(
+ cx,
+ UNUSED_RESULT_OK,
+ expr.span,
+ "ignoring a result with `.ok()` is misleading",
+ "consider using `let _ =` and removing the call to `.ok()` instead",
+ sugg,
+ applicability,
+ );
+ }
+ }
+}
diff --git a/src/tools/clippy/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs b/src/tools/clippy/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
index b017a6bf665c5..7c2e23995c1d3 100644
--- a/src/tools/clippy/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet;
use clippy_utils::ty::match_type;
@@ -93,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
if let ExprKind::Call(func, [arg]) = &expr.kind
&& let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind()
&& match_def_path(cx, *def_id, &paths::SYMBOL_INTERN)
- && let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg)
+ && let Some(Constant::Str(arg)) = ConstEvalCtxt::new(cx).eval_simple(arg)
&& let value = Symbol::intern(&arg).as_u32()
&& let Some(&def_id) = self.symbol_map.get(&value)
{
@@ -199,7 +199,7 @@ impl InterningDefinedSymbol {
});
}
// is a string constant
- if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
+ if let Some(Constant::Str(s)) = ConstEvalCtxt::new(cx).eval_simple(expr) {
let value = Symbol::intern(&s).as_u32();
// ...which matches a symbol constant
if let Some(&def_id) = self.symbol_map.get(&value) {
diff --git a/src/tools/clippy/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/src/tools/clippy/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 980437259c3e9..0ffcb433481e4 100644
--- a/src/tools/clippy/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::def_path_res;
use clippy_utils::diagnostics::span_lint;
use rustc_hir as hir;
@@ -32,9 +32,9 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
if mod_name.as_str() == "paths"
&& let hir::ItemKind::Const(.., body_id) = item.kind
- && let body = cx.tcx.hir().body(body_id)
- && let typeck_results = cx.tcx.typeck_body(body_id)
- && let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value)
+ && let Some(Constant::Vec(path)) =
+ ConstEvalCtxt::with_env(cx.tcx, cx.tcx.param_env(item.owner_id), cx.tcx.typeck(item.owner_id))
+ .eval_simple(cx.tcx.hir().body(body_id).value)
&& let Some(path) = path
.iter()
.map(|x| {
diff --git a/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index 84f84781e7126..df342e48d637f 100644
--- a/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -1,4 +1,3 @@
-use crate::utils::internal_lints::metadata_collector::is_deprecated_lint;
use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
use clippy_utils::macros::root_macro_call_first_node;
use clippy_utils::{is_lint_allowed, match_def_path, paths};
@@ -87,82 +86,32 @@ declare_clippy_lint! {
"found clippy lint without `clippy::version` attribute"
}
-declare_clippy_lint! {
- /// ### What it does
- /// Checks for cases of an auto-generated deprecated lint without an updated reason,
- /// i.e. `"default deprecation note"`.
- ///
- /// ### Why is this bad?
- /// Indicates that the documentation is incomplete.
- ///
- /// ### Example
- /// ```rust,ignore
- /// declare_deprecated_lint! {
- /// /// ### What it does
- /// /// Nothing. This lint has been deprecated.
- /// ///
- /// /// ### Deprecation reason
- /// /// TODO
- /// #[clippy::version = "1.63.0"]
- /// pub COOL_LINT,
- /// "default deprecation note"
- /// }
- /// ```
- ///
- /// Use instead:
- /// ```rust,ignore
- /// declare_deprecated_lint! {
- /// /// ### What it does
- /// /// Nothing. This lint has been deprecated.
- /// ///
- /// /// ### Deprecation reason
- /// /// This lint has been replaced by `cooler_lint`
- /// #[clippy::version = "1.63.0"]
- /// pub COOL_LINT,
- /// "this lint has been replaced by `cooler_lint`"
- /// }
- /// ```
- pub DEFAULT_DEPRECATION_REASON,
- internal,
- "found 'default deprecation note' in a deprecated lint declaration"
-}
-
#[derive(Clone, Debug, Default)]
pub struct LintWithoutLintPass {
declared_lints: FxHashMap<Symbol, Span>,
registered_lints: FxHashSet<Symbol>,
}
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE, DEFAULT_DEPRECATION_REASON]);
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE]);
impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
- if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id())
- || is_lint_allowed(cx, DEFAULT_DEPRECATION_REASON, item.hir_id())
- {
+ if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id()) {
return;
}
if let hir::ItemKind::Static(ty, Mutability::Not, body_id) = item.kind {
- let is_lint_ref_ty = is_lint_ref_type(cx, ty);
- if is_deprecated_lint(cx, ty) || is_lint_ref_ty {
+ if is_lint_ref_type(cx, ty) {
check_invalid_clippy_version_attribute(cx, item);
let expr = &cx.tcx.hir().body(body_id).value;
- let fields;
- if is_lint_ref_ty {
- if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind
- && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind
- {
- fields = struct_fields;
- } else {
- return;
- }
- } else if let ExprKind::Struct(_, struct_fields, _) = expr.kind {
- fields = struct_fields;
+ let fields = if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind
+ && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind
+ {
+ struct_fields
} else {
return;
- }
+ };
let field = fields
.iter()
@@ -175,25 +124,15 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
}) = field.expr.kind
{
let sym_str = sym.as_str();
- if is_lint_ref_ty {
- if sym_str == "default lint description" {
- span_lint(
- cx,
- DEFAULT_LINT,
- item.span,
- format!("the lint `{}` has the default lint description", item.ident.name),
- );
- }
-
- self.declared_lints.insert(item.ident.name, item.span);
- } else if sym_str == "default deprecation note" {
+ if sym_str == "default lint description" {
span_lint(
cx,
- DEFAULT_DEPRECATION_REASON,
+ DEFAULT_LINT,
item.span,
- format!("the lint `{}` has the default deprecation reason", item.ident.name),
+ format!("the lint `{}` has the default lint description", item.ident.name),
);
}
+ self.declared_lints.insert(item.ident.name, item.span);
}
}
} else if let Some(macro_call) = root_macro_call_first_node(cx, item) {
diff --git a/src/tools/clippy/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/src/tools/clippy/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 1c149f2045629..57f45aa3e4851 100644
--- a/src/tools/clippy/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -7,13 +7,12 @@
//! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
//! a simple mistake)
-use crate::renamed_lints::RENAMED_LINTS;
use crate::utils::internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type};
use clippy_config::{get_configuration_metadata, ClippyConfiguration};
use clippy_utils::diagnostics::span_lint;
use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
-use clippy_utils::{last_path_segment, match_def_path, match_function_call, match_path, paths};
+use clippy_utils::{last_path_segment, match_function_call, match_path, paths};
use itertools::Itertools;
use rustc_ast as ast;
use rustc_data_structures::fx::FxHashMap;
@@ -85,11 +84,6 @@ const SUGGESTION_DIAG_METHODS: [(&str, bool); 9] = [
("tool_only_multipart_suggestion", true),
("span_suggestions", true),
];
-const SUGGESTION_FUNCTIONS: [&[&str]; 2] = [
- &["clippy_utils", "diagnostics", "multispan_sugg"],
- &["clippy_utils", "diagnostics", "multispan_sugg_with_applicability"],
-];
-const DEPRECATED_LINT_TYPE: [&str; 3] = ["clippy_lints", "deprecated_lints", "ClippyDeprecatedLint"];
/// The index of the applicability name of `paths::APPLICABILITY_VALUES`
const APPLICABILITY_NAME_INDEX: usize = 2;
@@ -165,9 +159,9 @@ impl MetadataCollector {
fn get_lint_configs(&self, lint_name: &str) -> Option<String> {
self.config
.iter()
- .filter(|config| config.lints.iter().any(|lint| lint == lint_name))
+ .filter(|config| config.lints.iter().any(|&lint| lint == lint_name))
.map(ToString::to_string)
- .reduce(|acc, x| acc + &x)
+ .reduce(|acc, x| acc + "\n\n" + &x)
.map(|configurations| {
format!(
r#"
@@ -216,6 +210,13 @@ impl Drop for MetadataCollector {
let mut applicability_info = std::mem::take(&mut self.applicability_info);
+ // Add deprecated lints
+ self.lints.extend(
+ crate::deprecated_lints::DEPRECATED
+ .iter()
+ .zip(crate::deprecated_lints::DEPRECATED_VERSION)
+ .filter_map(|((lint, reason), version)| LintMetadata::new_deprecated(lint, reason, version)),
+ );
// Mapping the final data
let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
for x in &mut lints {
@@ -261,7 +262,7 @@ Please use that command to update the file and do not edit it by hand.
#[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
struct LintMetadata {
id: String,
- id_span: SerializableSpan,
+ id_span: Option<SerializableSpan>,
group: String,
level: String,
docs: String,
@@ -285,7 +286,7 @@ impl LintMetadata {
) -> Self {
Self {
id,
- id_span,
+ id_span: Some(id_span),
group,
level: level.to_string(),
version,
@@ -294,6 +295,29 @@ impl LintMetadata {
former_ids: BTreeSet::new(),
}
}
+
+ fn new_deprecated(name: &str, reason: &str, version: &str) -> Option<Self> {
+ // The reason starts with a lowercase letter and end without a period.
+ // This needs to be fixed for the website.
+ let mut reason = reason.to_owned();
+ if let Some(reason) = reason.get_mut(0..1) {
+ reason.make_ascii_uppercase();
+ }
+ name.strip_prefix("clippy::").map(|name| Self {
+ id: name.into(),
+ id_span: None,
+ group: DEPRECATED_LINT_GROUP_STR.into(),
+ level: DEPRECATED_LINT_LEVEL.into(),
+ version: version.into(),
+ docs: format!(
+ "### What it does\n\n\
+ Nothing. This lint has been deprecated\n\n\
+ ### Deprecation reason\n\n{reason}.\n",
+ ),
+ applicability: None,
+ former_ids: BTreeSet::new(),
+ })
+ }
}
fn replace_produces(lint_name: &str, docs: &mut String, clippy_project_root: &Path) {
@@ -564,24 +588,6 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
raw_docs,
));
}
-
- if is_deprecated_lint(cx, ty)
- // disallow check
- && let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase()
- // Metadata the little we can get from a deprecated lint
- && let Some(raw_docs) = extract_attr_docs_or_lint(cx, item)
- {
- let version = get_lint_version(cx, item);
-
- self.lints.push(LintMetadata::new(
- lint_name,
- SerializableSpan::from_item(cx, item),
- DEPRECATED_LINT_GROUP_STR.to_string(),
- DEPRECATED_LINT_LEVEL,
- version,
- raw_docs,
- ));
- }
}
}
@@ -684,6 +690,11 @@ fn cleanup_docs(docs_collection: &Vec<String>) -> String {
.find(|&s| !matches!(s, "" | "ignore" | "no_run" | "should_panic"))
// if no language is present, fill in "rust"
.unwrap_or("rust");
+ let len_diff = line.len() - line.trim_start().len();
+ if len_diff != 0 {
+ // We put back the indentation.
+ docs.push_str(&line[..len_diff]);
+ }
docs.push_str("```");
docs.push_str(lang);
@@ -766,16 +777,6 @@ fn get_lint_level_from_group(lint_group: &str) -> Option<&'static str> {
.find_map(|(group_name, group_level)| (*group_name == lint_group).then_some(*group_level))
}
-pub(super) fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
- if let hir::TyKind::Path(ref path) = ty.kind {
- if let hir::def::Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, ty.hir_id) {
- return match_def_path(cx, def_id, &DEPRECATED_LINT_TYPE);
- }
- }
-
- false
-}
-
fn collect_renames(lints: &mut Vec<LintMetadata>) {
for lint in lints {
let mut collected = String::new();
@@ -783,7 +784,7 @@ fn collect_renames(lints: &mut Vec<LintMetadata>) {
loop {
if let Some(lint_name) = names.pop() {
- for (k, v) in RENAMED_LINTS {
+ for (k, v) in crate::deprecated_lints::RENAMED {
if let Some(name) = v.strip_prefix(CLIPPY_LINT_GROUP_PREFIX)
&& name == lint_name
&& let Some(past_name) = k.strip_prefix(CLIPPY_LINT_GROUP_PREFIX)
@@ -1055,33 +1056,21 @@ impl<'a, 'hir> Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
return;
}
- match &expr.kind {
- ExprKind::Call(fn_expr, _args) => {
- let found_function = SUGGESTION_FUNCTIONS
- .iter()
- .any(|func_path| match_function_call(self.cx, fn_expr, func_path).is_some());
- if found_function {
- // These functions are all multi part suggestions
- self.add_single_span_suggestion();
- }
- },
- ExprKind::MethodCall(path, recv, _, _arg_span) => {
- let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(recv));
- if match_type(self.cx, self_ty, &paths::DIAG) {
- let called_method = path.ident.name.as_str().to_string();
- for (method_name, is_multi_part) in &SUGGESTION_DIAG_METHODS {
- if *method_name == called_method {
- if *is_multi_part {
- self.add_multi_part_suggestion();
- } else {
- self.add_single_span_suggestion();
- }
- break;
+ if let ExprKind::MethodCall(path, recv, _, _arg_span) = &expr.kind {
+ let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(recv));
+ if match_type(self.cx, self_ty, &paths::DIAG) {
+ let called_method = path.ident.name.as_str().to_string();
+ for (method_name, is_multi_part) in &SUGGESTION_DIAG_METHODS {
+ if *method_name == called_method {
+ if *is_multi_part {
+ self.add_multi_part_suggestion();
+ } else {
+ self.add_single_span_suggestion();
}
+ break;
}
}
- },
- _ => {},
+ }
}
intravisit::walk_expr(self, expr);
diff --git a/src/tools/clippy/clippy_lints/src/vec.rs b/src/tools/clippy/clippy_lints/src/vec.rs
index a831234906bfc..228db14d1b7c3 100644
--- a/src/tools/clippy/clippy_lints/src/vec.rs
+++ b/src/tools/clippy/clippy_lints/src/vec.rs
@@ -3,7 +3,7 @@ use std::ops::ControlFlow;
use clippy_config::msrvs::{self, Msrv};
use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_hir_and_then;
use clippy_utils::source::snippet_opt;
use clippy_utils::ty::is_copy;
@@ -159,7 +159,7 @@ impl UselessVec {
let snippet = match *vec_args {
higher::VecArgs::Repeat(elem, len) => {
- if let Some(Constant::Int(len_constant)) = constant(cx, cx.typeck_results(), len) {
+ if let Some(Constant::Int(len_constant)) = ConstEvalCtxt::new(cx).eval(len) {
// vec![ty; N] works when ty is Clone, [ty; N] requires it to be Copy also
if !is_copy(cx, cx.typeck_results().expr_ty(elem)) {
return;
diff --git a/src/tools/clippy/clippy_lints/src/visibility.rs b/src/tools/clippy/clippy_lints/src/visibility.rs
index 11dcceca7abb1..63f3a5d7f8305 100644
--- a/src/tools/clippy/clippy_lints/src/visibility.rs
+++ b/src/tools/clippy/clippy_lints/src/visibility.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet_opt;
use rustc_ast::ast::{Item, VisibilityKind};
use rustc_errors::Applicability;
@@ -85,14 +85,19 @@ impl EarlyLintPass for Visibility {
if **path == kw::SelfLower
&& let Some(false) = is_from_proc_macro(cx, item.vis.span)
{
- span_lint_and_sugg(
+ span_lint_and_then(
cx,
NEEDLESS_PUB_SELF,
item.vis.span,
format!("unnecessary `pub({}self)`", if *shorthand { "" } else { "in " }),
- "remove it",
- String::new(),
- Applicability::MachineApplicable,
+ |diag| {
+ diag.span_suggestion_hidden(
+ item.vis.span,
+ "remove it",
+ String::new(),
+ Applicability::MachineApplicable,
+ );
+ },
);
}
@@ -101,14 +106,20 @@ impl EarlyLintPass for Visibility {
&& let [.., last] = &*path.segments
&& let Some(false) = is_from_proc_macro(cx, item.vis.span)
{
- span_lint_and_sugg(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
PUB_WITHOUT_SHORTHAND,
item.vis.span,
"usage of `pub` with `in`",
- "remove it",
- format!("pub({})", last.ident),
- Applicability::MachineApplicable,
+ |diag| {
+ diag.span_suggestion(
+ item.vis.span,
+ "remove it",
+ format!("pub({})", last.ident),
+ Applicability::MachineApplicable,
+ );
+ },
);
}
@@ -116,14 +127,20 @@ impl EarlyLintPass for Visibility {
&& let [.., last] = &*path.segments
&& let Some(false) = is_from_proc_macro(cx, item.vis.span)
{
- span_lint_and_sugg(
+ #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+ span_lint_and_then(
cx,
PUB_WITH_SHORTHAND,
item.vis.span,
"usage of `pub` without `in`",
- "add it",
- format!("pub(in {})", last.ident),
- Applicability::MachineApplicable,
+ |diag| {
+ diag.span_suggestion(
+ item.vis.span,
+ "add it",
+ format!("pub(in {})", last.ident),
+ Applicability::MachineApplicable,
+ );
+ },
);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/zero_div_zero.rs b/src/tools/clippy/clippy_lints/src/zero_div_zero.rs
index 60d8a13d3599d..5eb207a0aedb0 100644
--- a/src/tools/clippy/clippy_lints/src/zero_div_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/zero_div_zero.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
use clippy_utils::diagnostics::span_lint_and_help;
use rustc_hir::{BinOpKind, Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
@@ -36,8 +36,9 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
// TODO - constant_simple does not fold many operations involving floats.
// That's probably fine for this lint - it's pretty unlikely that someone would
// do something like 0.0/(2.0 - 2.0), but it would be nice to warn on that case too.
- && let Some(lhs_value) = constant_simple(cx, cx.typeck_results(), left)
- && let Some(rhs_value) = constant_simple(cx, cx.typeck_results(), right)
+ && let ecx = ConstEvalCtxt::new(cx)
+ && let Some(lhs_value) = ecx.eval_simple(left)
+ && let Some(rhs_value) = ecx.eval_simple(right)
// FIXME(f16_f128): add these types when eq is available on all platforms
&& (Constant::F32(0.0) == lhs_value || Constant::F64(0.0) == lhs_value)
&& (Constant::F32(0.0) == rhs_value || Constant::F64(0.0) == rhs_value)
diff --git a/src/tools/clippy/clippy_utils/Cargo.toml b/src/tools/clippy/clippy_utils/Cargo.toml
index f0c64fdd573ca..9fefd94d339be 100644
--- a/src/tools/clippy/clippy_utils/Cargo.toml
+++ b/src/tools/clippy/clippy_utils/Cargo.toml
@@ -12,9 +12,6 @@ rustc-semver = "1.1"
# FIXME(f16_f128): remove when no longer needed for parsing
rustc_apfloat = "0.2.0"
-[features]
-deny-warnings = ["clippy_config/deny-warnings"]
-
[package.metadata.rust-analyzer]
# This crate uses #[feature(rustc_private)]
rustc_private = true
diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs
index de6ccfe476fb0..e907e4058e5a2 100644
--- a/src/tools/clippy/clippy_utils/src/consts.rs
+++ b/src/tools/clippy/clippy_utils/src/consts.rs
@@ -14,12 +14,13 @@ use rustc_lexer::tokenize;
use rustc_lint::LateContext;
use rustc_middle::mir::interpret::{alloc_range, Scalar};
use rustc_middle::mir::ConstValue;
-use rustc_middle::ty::{self, EarlyBinder, FloatTy, GenericArgsRef, IntTy, List, ScalarInt, Ty, TyCtxt, UintTy};
+use rustc_middle::ty::{self, FloatTy, IntTy, ParamEnv, ScalarInt, Ty, TyCtxt, TypeckResults, UintTy};
use rustc_middle::{bug, mir, span_bug};
use rustc_span::def_id::DefId;
-use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::symbol::Ident;
use rustc_span::{sym, SyntaxContext};
use rustc_target::abi::Size;
+use std::cell::Cell;
use std::cmp::Ordering;
use std::hash::{Hash, Hasher};
use std::iter;
@@ -263,10 +264,10 @@ impl<'tcx> Constant<'tcx> {
}
/// Returns the integer value or `None` if `self` or `val_type` is not integer type.
- pub fn int_value(&self, cx: &LateContext<'_>, val_type: Ty<'_>) -> Option<FullInt> {
+ pub fn int_value(&self, tcx: TyCtxt<'_>, val_type: Ty<'_>) -> Option<FullInt> {
if let Constant::Int(const_int) = *self {
match *val_type.kind() {
- ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
+ ty::Int(ity) => Some(FullInt::S(sext(tcx, const_int, ity))),
ty::Uint(_) => Some(FullInt::U(const_int)),
_ => None,
}
@@ -322,6 +323,7 @@ pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constan
}
/// The source of a constant value.
+#[derive(Clone, Copy)]
pub enum ConstantSource {
/// The value is determined solely from the expression.
Local,
@@ -331,54 +333,11 @@ pub enum ConstantSource {
CoreConstant,
}
impl ConstantSource {
- pub fn is_local(&self) -> bool {
+ pub fn is_local(self) -> bool {
matches!(self, Self::Local)
}
}
-/// Attempts to check whether the expression is a constant representing an empty slice, str, array,
-/// etc…
-pub fn constant_is_empty(lcx: &LateContext<'_>, e: &Expr<'_>) -> Option<bool> {
- ConstEvalLateContext::new(lcx, lcx.typeck_results()).expr_is_empty(e)
-}
-
-/// Attempts to evaluate the expression as a constant.
-pub fn constant<'tcx>(
- lcx: &LateContext<'tcx>,
- typeck_results: &ty::TypeckResults<'tcx>,
- e: &Expr<'_>,
-) -> Option<Constant<'tcx>> {
- ConstEvalLateContext::new(lcx, typeck_results).expr(e)
-}
-
-/// Attempts to evaluate the expression as a constant.
-pub fn constant_with_source<'tcx>(
- lcx: &LateContext<'tcx>,
- typeck_results: &ty::TypeckResults<'tcx>,
- e: &Expr<'_>,
-) -> Option<(Constant<'tcx>, ConstantSource)> {
- let mut ctxt = ConstEvalLateContext::new(lcx, typeck_results);
- let res = ctxt.expr(e);
- res.map(|x| (x, ctxt.source))
-}
-
-/// Attempts to evaluate an expression only if its value is not dependent on other items.
-pub fn constant_simple<'tcx>(
- lcx: &LateContext<'tcx>,
- typeck_results: &ty::TypeckResults<'tcx>,
- e: &Expr<'_>,
-) -> Option<Constant<'tcx>> {
- constant_with_source(lcx, typeck_results, e).and_then(|(c, s)| s.is_local().then_some(c))
-}
-
-pub fn constant_full_int<'tcx>(
- lcx: &LateContext<'tcx>,
- typeck_results: &ty::TypeckResults<'tcx>,
- e: &Expr<'_>,
-) -> Option<FullInt> {
- constant_simple(lcx, typeck_results, e)?.int_value(lcx, typeck_results.expr_ty(e))
-}
-
#[derive(Copy, Clone, Debug, Eq)]
pub enum FullInt {
S(i128),
@@ -417,44 +376,87 @@ impl Ord for FullInt {
}
}
-pub struct ConstEvalLateContext<'a, 'tcx> {
- lcx: &'a LateContext<'tcx>,
- typeck_results: &'a ty::TypeckResults<'tcx>,
- param_env: ty::ParamEnv<'tcx>,
- source: ConstantSource,
- args: GenericArgsRef<'tcx>,
+/// The context required to evaluate a constant expression.
+///
+/// This is currently limited to constant folding and reading the value of named constants.
+pub struct ConstEvalCtxt<'tcx> {
+ tcx: TyCtxt<'tcx>,
+ param_env: ParamEnv<'tcx>,
+ typeck: &'tcx TypeckResults<'tcx>,
+ source: Cell<ConstantSource>,
}
-impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
- pub fn new(lcx: &'a LateContext<'tcx>, typeck_results: &'a ty::TypeckResults<'tcx>) -> Self {
+impl<'tcx> ConstEvalCtxt<'tcx> {
+ /// Creates the evaluation context from the lint context. This requires the lint context to be
+ /// in a body (i.e. `cx.enclosing_body.is_some()`).
+ pub fn new(cx: &LateContext<'tcx>) -> Self {
+ Self {
+ tcx: cx.tcx,
+ param_env: cx.param_env,
+ typeck: cx.typeck_results(),
+ source: Cell::new(ConstantSource::Local),
+ }
+ }
+
+ /// Creates an evaluation context.
+ pub fn with_env(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, typeck: &'tcx TypeckResults<'tcx>) -> Self {
Self {
- lcx,
- typeck_results,
- param_env: lcx.param_env,
- source: ConstantSource::Local,
- args: List::empty(),
+ tcx,
+ param_env,
+ typeck,
+ source: Cell::new(ConstantSource::Local),
+ }
+ }
+
+ /// Attempts to evaluate the expression and returns both the value and whether it's dependant on
+ /// other items.
+ pub fn eval_with_source(&self, e: &Expr<'_>) -> Option<(Constant<'tcx>, ConstantSource)> {
+ self.source.set(ConstantSource::Local);
+ self.expr(e).map(|c| (c, self.source.get()))
+ }
+
+ /// Attempts to evaluate the expression.
+ pub fn eval(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+ self.expr(e)
+ }
+
+ /// Attempts to evaluate the expression without accessing other items.
+ pub fn eval_simple(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+ match self.eval_with_source(e) {
+ Some((x, ConstantSource::Local)) => Some(x),
+ _ => None,
+ }
+ }
+
+ /// Attempts to evaluate the expression as an integer without accessing other items.
+ pub fn eval_full_int(&self, e: &Expr<'_>) -> Option<FullInt> {
+ match self.eval_with_source(e) {
+ Some((x, ConstantSource::Local)) => x.int_value(self.tcx, self.typeck.expr_ty(e)),
+ _ => None,
}
}
/// Simple constant folding: Insert an expression, get a constant or none.
- pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+ fn expr(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
match e.kind {
- ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr(self.lcx.tcx.hir().body(body).value),
+ ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr(self.tcx.hir().body(body).value),
ExprKind::DropTemps(e) => self.expr(e),
ExprKind::Path(ref qpath) => {
- let is_core_crate = if let Some(def_id) = self.lcx.qpath_res(qpath, e.hir_id()).opt_def_id() {
- self.lcx.tcx.crate_name(def_id.krate) == sym::core
+ let is_core_crate = if let Some(def_id) = self.typeck.qpath_res(qpath, e.hir_id()).opt_def_id() {
+ self.tcx.crate_name(def_id.krate) == sym::core
} else {
false
};
- self.fetch_path_and_apply(qpath, e.hir_id, self.typeck_results.expr_ty(e), |this, result| {
- let result = mir_to_const(this.lcx, result)?;
+ self.fetch_path_and_apply(qpath, e.hir_id, self.typeck.expr_ty(e), |self_, result| {
+ let result = mir_to_const(self_.tcx, result)?;
// If source is already Constant we wouldn't want to override it with CoreConstant
- this.source = if is_core_crate && !matches!(this.source, ConstantSource::Constant) {
- ConstantSource::CoreConstant
- } else {
- ConstantSource::Constant
- };
+ self_.source.set(
+ if is_core_crate && !matches!(self_.source.get(), ConstantSource::Constant) {
+ ConstantSource::CoreConstant
+ } else {
+ ConstantSource::Constant
+ },
+ );
Some(result)
})
},
@@ -463,21 +465,21 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
if is_direct_expn_of(e.span, "cfg").is_some() {
None
} else {
- Some(lit_to_mir_constant(&lit.node, self.typeck_results.expr_ty_opt(e)))
+ Some(lit_to_mir_constant(&lit.node, self.typeck.expr_ty_opt(e)))
}
},
ExprKind::Array(vec) => self.multi(vec).map(Constant::Vec),
ExprKind::Tup(tup) => self.multi(tup).map(Constant::Tuple),
ExprKind::Repeat(value, _) => {
- let n = match self.typeck_results.expr_ty(e).kind() {
- ty::Array(_, n) => n.try_eval_target_usize(self.lcx.tcx, self.lcx.param_env)?,
+ let n = match self.typeck.expr_ty(e).kind() {
+ ty::Array(_, n) => n.try_eval_target_usize(self.tcx, self.param_env)?,
_ => span_bug!(e.span, "typeck error"),
};
self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))
},
ExprKind::Unary(op, operand) => self.expr(operand).and_then(|o| match op {
- UnOp::Not => self.constant_not(&o, self.typeck_results.expr_ty(e)),
- UnOp::Neg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
+ UnOp::Not => self.constant_not(&o, self.typeck.expr_ty(e)),
+ UnOp::Neg => self.constant_negate(&o, self.typeck.expr_ty(e)),
UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
}),
ExprKind::If(cond, then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
@@ -486,21 +488,16 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
// We only handle a few const functions for now.
if args.is_empty()
&& let ExprKind::Path(qpath) = &callee.kind
- && let res = self.typeck_results.qpath_res(qpath, callee.hir_id)
- && let Some(def_id) = res.opt_def_id()
- && let def_path = self.lcx.get_def_path(def_id)
- && let def_path = def_path.iter().take(4).map(Symbol::as_str).collect::<Vec<_>>()
- && let ["core", "num", int_impl, "max_value"] = *def_path
+ && let Some(did) = self.typeck.qpath_res(qpath, callee.hir_id).opt_def_id()
{
- let value = match int_impl {
- "<impl i8>" => i8::MAX as u128,
- "<impl i16>" => i16::MAX as u128,
- "<impl i32>" => i32::MAX as u128,
- "<impl i64>" => i64::MAX as u128,
- "<impl i128>" => i128::MAX as u128,
- _ => return None,
- };
- Some(Constant::Int(value))
+ match self.tcx.get_diagnostic_name(did) {
+ Some(sym::i8_legacy_fn_max_value) => Some(Constant::Int(i8::MAX as u128)),
+ Some(sym::i16_legacy_fn_max_value) => Some(Constant::Int(i16::MAX as u128)),
+ Some(sym::i32_legacy_fn_max_value) => Some(Constant::Int(i32::MAX as u128)),
+ Some(sym::i64_legacy_fn_max_value) => Some(Constant::Int(i64::MAX as u128)),
+ Some(sym::i128_legacy_fn_max_value) => Some(Constant::Int(i128::MAX as u128)),
+ _ => None,
+ }
} else {
None
}
@@ -512,9 +509,9 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
if let Some(Constant::Adt(constant)) = &self.expr(local_expr)
&& let ty::Adt(adt_def, _) = constant.ty().kind()
&& adt_def.is_struct()
- && let Some(desired_field) = field_of_struct(*adt_def, self.lcx, *constant, field)
+ && let Some(desired_field) = field_of_struct(*adt_def, self.tcx, *constant, field)
{
- mir_to_const(self.lcx, desired_field)
+ mir_to_const(self.tcx, desired_field)
} else {
result
}
@@ -526,21 +523,21 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
/// Simple constant folding to determine if an expression is an empty slice, str, array, …
/// `None` will be returned if the constness cannot be determined, or if the resolution
/// leaves the local crate.
- pub fn expr_is_empty(&mut self, e: &Expr<'_>) -> Option<bool> {
+ pub fn eval_is_empty(&self, e: &Expr<'_>) -> Option<bool> {
match e.kind {
- ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr_is_empty(self.lcx.tcx.hir().body(body).value),
- ExprKind::DropTemps(e) => self.expr_is_empty(e),
+ ExprKind::ConstBlock(ConstBlock { body, .. }) => self.eval_is_empty(self.tcx.hir().body(body).value),
+ ExprKind::DropTemps(e) => self.eval_is_empty(e),
ExprKind::Path(ref qpath) => {
if !self
- .typeck_results
+ .typeck
.qpath_res(qpath, e.hir_id)
.opt_def_id()
.is_some_and(DefId::is_local)
{
return None;
}
- self.fetch_path_and_apply(qpath, e.hir_id, self.typeck_results.expr_ty(e), |this, result| {
- mir_is_empty(this.lcx, result)
+ self.fetch_path_and_apply(qpath, e.hir_id, self.typeck.expr_ty(e), |self_, result| {
+ mir_is_empty(self_.tcx, result)
})
},
ExprKind::Lit(lit) => {
@@ -556,8 +553,8 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
},
ExprKind::Array(vec) => self.multi(vec).map(|v| v.is_empty()),
ExprKind::Repeat(..) => {
- if let ty::Array(_, n) = self.typeck_results.expr_ty(e).kind() {
- Some(n.try_eval_target_usize(self.lcx.tcx, self.lcx.param_env)? == 0)
+ if let ty::Array(_, n) = self.typeck.expr_ty(e).kind() {
+ Some(n.try_eval_target_usize(self.tcx, self.param_env)? == 0)
} else {
span_bug!(e.span, "typeck error");
}
@@ -574,8 +571,8 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
Int(value) => {
let value = !value;
match *ty.kind() {
- ty::Int(ity) => Some(Int(unsext(self.lcx.tcx, value as i128, ity))),
- ty::Uint(ity) => Some(Int(clip(self.lcx.tcx, value, ity))),
+ ty::Int(ity) => Some(Int(unsext(self.tcx, value as i128, ity))),
+ ty::Uint(ity) => Some(Int(clip(self.tcx, value, ity))),
_ => None,
}
},
@@ -590,7 +587,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
let ty::Int(ity) = *ty.kind() else { return None };
let (min, _) = ity.min_max()?;
// sign extend
- let value = sext(self.lcx.tcx, value, ity);
+ let value = sext(self.tcx, value, ity);
// Applying unary - to the most negative value of any signed integer type panics.
if value == min {
@@ -599,7 +596,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
let value = value.checked_neg()?;
// clear unused bits
- Some(Int(unsext(self.lcx.tcx, value, ity)))
+ Some(Int(unsext(self.tcx, value, ity)))
},
F32(f) => Some(F32(-f)),
F64(f) => Some(F64(-f)),
@@ -609,21 +606,21 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
/// Create `Some(Vec![..])` of all constants, unless there is any
/// non-constant part.
- fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant<'tcx>>> {
+ fn multi(&self, vec: &[Expr<'_>]) -> Option<Vec<Constant<'tcx>>> {
vec.iter().map(|elem| self.expr(elem)).collect::<Option<_>>()
}
/// Lookup a possibly constant expression from an `ExprKind::Path` and apply a function on it.
- fn fetch_path_and_apply<T, F>(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>, f: F) -> Option<T>
+ fn fetch_path_and_apply<T, F>(&self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>, f: F) -> Option<T>
where
- F: FnOnce(&mut Self, mir::Const<'tcx>) -> Option<T>,
+ F: FnOnce(&Self, mir::Const<'tcx>) -> Option<T>,
{
- let res = self.typeck_results.qpath_res(qpath, id);
+ let res = self.typeck.qpath_res(qpath, id);
match res {
Res::Def(DefKind::Const | DefKind::AssocConst, def_id) => {
// Check if this constant is based on `cfg!(..)`,
// which is NOT constant for our purposes.
- if let Some(node) = self.lcx.tcx.hir().get_if_local(def_id)
+ if let Some(node) = self.tcx.hir().get_if_local(def_id)
&& let Node::Item(Item {
kind: ItemKind::Const(.., body_id),
..
@@ -632,20 +629,14 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
kind: ExprKind::Lit(_),
span,
..
- }) = self.lcx.tcx.hir_node(body_id.hir_id)
+ }) = self.tcx.hir_node(body_id.hir_id)
&& is_direct_expn_of(*span, "cfg").is_some()
{
return None;
}
- let args = self.typeck_results.node_args(id);
- let args = if self.args.is_empty() {
- args
- } else {
- EarlyBinder::bind(args).instantiate(self.lcx.tcx, self.args)
- };
+ let args = self.typeck.node_args(id);
let result = self
- .lcx
.tcx
.const_eval_resolve(self.param_env, mir::UnevaluatedConst::new(def_id, args), qpath.span())
.ok()
@@ -656,7 +647,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
}
}
- fn index(&mut self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant<'tcx>> {
+ fn index(&self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant<'tcx>> {
let lhs = self.expr(lhs);
let index = self.expr(index);
@@ -685,8 +676,8 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
}
}
- /// A block can only yield a constant if it only has one constant expression.
- fn block(&mut self, block: &Block<'_>) -> Option<Constant<'tcx>> {
+ /// A block can only yield a constant if it has exactly one constant expression.
+ fn block(&self, block: &Block<'_>) -> Option<Constant<'tcx>> {
if block.stmts.is_empty()
&& let Some(expr) = block.expr
{
@@ -696,7 +687,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
if let Some(expr_span) = walk_span_to_context(expr.span, span.ctxt)
&& let expr_lo = expr_span.lo()
&& expr_lo >= span.lo
- && let Some(src) = (span.lo..expr_lo).get_source_text(self.lcx)
+ && let Some(src) = (span.lo..expr_lo).get_source_text(&self.tcx)
&& let Some(src) = src.as_str()
{
use rustc_lexer::TokenKind::{BlockComment, LineComment, OpenBrace, Semi, Whitespace};
@@ -705,11 +696,11 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
.filter(|t| !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi))
.eq([OpenBrace])
{
- self.source = ConstantSource::Constant;
+ self.source.set(ConstantSource::Constant);
}
} else {
// Unable to access the source. Assume a non-local dependency.
- self.source = ConstantSource::Constant;
+ self.source.set(ConstantSource::Constant);
}
}
@@ -719,7 +710,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
}
}
- fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant<'tcx>> {
+ fn ifthenelse(&self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant<'tcx>> {
if let Some(Constant::Bool(b)) = self.expr(cond) {
if b {
self.expr(then)
@@ -731,16 +722,16 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
}
}
- fn binop(&mut self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant<'tcx>> {
+ fn binop(&self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant<'tcx>> {
let l = self.expr(left)?;
let r = self.expr(right);
match (l, r) {
- (Constant::Int(l), Some(Constant::Int(r))) => match *self.typeck_results.expr_ty_opt(left)?.kind() {
+ (Constant::Int(l), Some(Constant::Int(r))) => match *self.typeck.expr_ty_opt(left)?.kind() {
ty::Int(ity) => {
let (ty_min_value, _) = ity.min_max()?;
let bits = ity.bits();
- let l = sext(self.lcx.tcx, l, ity);
- let r = sext(self.lcx.tcx, r, ity);
+ let l = sext(self.tcx, l, ity);
+ let r = sext(self.tcx, r, ity);
// Using / or %, where the left-hand argument is the smallest integer of a signed integer type and
// the right-hand argument is -1 always panics, even with overflow-checks disabled
@@ -751,7 +742,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
return None;
}
- let zext = |n: i128| Constant::Int(unsext(self.lcx.tcx, n, ity));
+ let zext = |n: i128| Constant::Int(unsext(self.tcx, n, ity));
match op.node {
// When +, * or binary - create a value greater than the maximum value, or less than
// the minimum value that can be stored, it panics.
@@ -845,7 +836,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
}
}
-pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Option<Constant<'tcx>> {
+pub fn mir_to_const<'tcx>(tcx: TyCtxt<'tcx>, result: mir::Const<'tcx>) -> Option<Constant<'tcx>> {
let mir::Const::Val(val, _) = result else {
// We only work on evaluated consts.
return None;
@@ -863,13 +854,13 @@ pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) ->
_ => None,
},
(_, ty::Ref(_, inner_ty, _)) if matches!(inner_ty.kind(), ty::Str) => {
- let data = val.try_get_slice_bytes_for_diagnostics(lcx.tcx)?;
+ let data = val.try_get_slice_bytes_for_diagnostics(tcx)?;
String::from_utf8(data.to_owned()).ok().map(Constant::Str)
},
(_, ty::Adt(adt_def, _)) if adt_def.is_struct() => Some(Constant::Adt(result)),
(ConstValue::Indirect { alloc_id, offset }, ty::Array(sub_type, len)) => {
- let alloc = lcx.tcx.global_alloc(alloc_id).unwrap_memory().inner();
- let len = len.try_to_target_usize(lcx.tcx)?;
+ let alloc = tcx.global_alloc(alloc_id).unwrap_memory().inner();
+ let len = len.try_to_target_usize(tcx)?;
let ty::Float(flt) = sub_type.kind() else {
return None;
};
@@ -877,7 +868,7 @@ pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) ->
let mut res = Vec::new();
for idx in 0..len {
let range = alloc_range(offset + size * idx, size);
- let val = alloc.read_scalar(&lcx.tcx, range, /* read_provenance */ false).ok()?;
+ let val = alloc.read_scalar(&tcx, range, /* read_provenance */ false).ok()?;
res.push(match flt {
FloatTy::F16 => Constant::F16(f16::from_bits(val.to_u16().ok()?)),
FloatTy::F32 => Constant::F32(f32::from_bits(val.to_u32().ok()?)),
@@ -891,7 +882,7 @@ pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) ->
}
}
-fn mir_is_empty<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Option<bool> {
+fn mir_is_empty<'tcx>(tcx: TyCtxt<'tcx>, result: mir::Const<'tcx>) -> Option<bool> {
let mir::Const::Val(val, _) = result else {
// We only work on evaluated consts.
return None;
@@ -902,26 +893,26 @@ fn mir_is_empty<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Opti
if let ConstValue::Indirect { alloc_id, offset } = val {
// Get the length from the slice, using the same formula as
// [`ConstValue::try_get_slice_bytes_for_diagnostics`].
- let a = lcx.tcx.global_alloc(alloc_id).unwrap_memory().inner();
- let ptr_size = lcx.tcx.data_layout.pointer_size;
+ let a = tcx.global_alloc(alloc_id).unwrap_memory().inner();
+ let ptr_size = tcx.data_layout.pointer_size;
if a.size() < offset + 2 * ptr_size {
// (partially) dangling reference
return None;
}
let len = a
- .read_scalar(&lcx.tcx, alloc_range(offset + ptr_size, ptr_size), false)
+ .read_scalar(&tcx, alloc_range(offset + ptr_size, ptr_size), false)
.ok()?
- .to_target_usize(&lcx.tcx)
+ .to_target_usize(&tcx)
.ok()?;
Some(len == 0)
} else {
None
}
},
- ty::Array(_, len) => Some(len.try_to_target_usize(lcx.tcx)? == 0),
+ ty::Array(_, len) => Some(len.try_to_target_usize(tcx)? == 0),
_ => None,
},
- (ConstValue::Indirect { .. }, ty::Array(_, len)) => Some(len.try_to_target_usize(lcx.tcx)? == 0),
+ (ConstValue::Indirect { .. }, ty::Array(_, len)) => Some(len.try_to_target_usize(tcx)? == 0),
(ConstValue::ZeroSized, _) => Some(true),
_ => None,
}
@@ -929,12 +920,12 @@ fn mir_is_empty<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Opti
fn field_of_struct<'tcx>(
adt_def: ty::AdtDef<'tcx>,
- lcx: &LateContext<'tcx>,
+ tcx: TyCtxt<'tcx>,
result: mir::Const<'tcx>,
field: &Ident,
) -> Option<mir::Const<'tcx>> {
if let mir::Const::Val(result, ty) = result
- && let Some(dc) = lcx.tcx.try_destructure_mir_constant_for_user_output(result, ty)
+ && let Some(dc) = tcx.try_destructure_mir_constant_for_user_output(result, ty)
&& let Some(dc_variant) = dc.variant
&& let Some(variant) = adt_def.variants().get(dc_variant)
&& let Some(field_idx) = variant.fields.iter().position(|el| el.name == field.name)
diff --git a/src/tools/clippy/clippy_utils/src/diagnostics.rs b/src/tools/clippy/clippy_utils/src/diagnostics.rs
index 0641d37cd9a67..4877fb65d37d7 100644
--- a/src/tools/clippy/clippy_utils/src/diagnostics.rs
+++ b/src/tools/clippy/clippy_utils/src/diagnostics.rs
@@ -330,32 +330,3 @@ pub fn span_lint_and_sugg<T: LintContext>(
diag.span_suggestion(sp, help.into(), sugg, applicability);
});
}
-
-/// Create a suggestion made from several `span → replacement`.
-///
-/// Note: in the JSON format (used by `compiletest_rs`), the help message will
-/// appear once per
-/// replacement. In human-readable format though, it only appears once before
-/// the whole suggestion.
-pub fn multispan_sugg<I>(diag: &mut Diag<'_, ()>, help_msg: impl Into<SubdiagMessage>, sugg: I)
-where
- I: IntoIterator<Item = (Span, String)>,
-{
- multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg);
-}
-
-/// Create a suggestion made from several `span → replacement`.
-///
-/// rustfix currently doesn't support the automatic application of suggestions with
-/// multiple spans. This is tracked in issue [rustfix#141](https://github.com/rust-lang/rustfix/issues/141).
-/// Suggestions with multiple spans will be silently ignored.
-pub fn multispan_sugg_with_applicability<I>(
- diag: &mut Diag<'_, ()>,
- help_msg: impl Into<SubdiagMessage>,
- applicability: Applicability,
- sugg: I,
-) where
- I: IntoIterator<Item = (Span, String)>,
-{
- diag.multipart_suggestion(help_msg.into(), sugg.into_iter().collect(), applicability);
-}
diff --git a/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs b/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
index 6c40029a9de70..a6dd12a28c5bc 100644
--- a/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
+++ b/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
@@ -9,7 +9,7 @@
//! - or-fun-call
//! - option-if-let-else
-use crate::consts::{constant, FullInt};
+use crate::consts::{ConstEvalCtxt, FullInt};
use crate::ty::{all_predicates_of, is_copy};
use crate::visitors::is_const_evaluatable;
use rustc_hir::def::{DefKind, Res};
@@ -206,7 +206,7 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
},
// `-i32::MIN` panics with overflow checks
- ExprKind::Unary(UnOp::Neg, right) if constant(self.cx, self.cx.typeck_results(), right).is_none() => {
+ ExprKind::Unary(UnOp::Neg, right) if ConstEvalCtxt::new(self.cx).eval(right).is_none() => {
self.eagerness |= NoChange;
},
@@ -232,7 +232,7 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
// Thus, we would realistically only delay the lint.
ExprKind::Binary(op, _, right)
if matches!(op.node, BinOpKind::Shl | BinOpKind::Shr)
- && constant(self.cx, self.cx.typeck_results(), right).is_none() =>
+ && ConstEvalCtxt::new(self.cx).eval(right).is_none() =>
{
self.eagerness |= NoChange;
},
@@ -240,9 +240,9 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
ExprKind::Binary(op, left, right)
if matches!(op.node, BinOpKind::Div | BinOpKind::Rem)
&& let right_ty = self.cx.typeck_results().expr_ty(right)
- && let left = constant(self.cx, self.cx.typeck_results(), left)
- && let right = constant(self.cx, self.cx.typeck_results(), right)
- .and_then(|c| c.int_value(self.cx, right_ty))
+ && let ecx = ConstEvalCtxt::new(self.cx)
+ && let left = ecx.eval(left)
+ && let right = ecx.eval(right).and_then(|c| c.int_value(self.cx.tcx, right_ty))
&& matches!(
(left, right),
// `1 / x`: x might be zero
@@ -261,8 +261,8 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
ExprKind::Binary(op, left, right)
if matches!(op.node, BinOpKind::Add | BinOpKind::Sub | BinOpKind::Mul)
&& !self.cx.typeck_results().expr_ty(e).is_floating_point()
- && (constant(self.cx, self.cx.typeck_results(), left).is_none()
- || constant(self.cx, self.cx.typeck_results(), right).is_none()) =>
+ && let ecx = ConstEvalCtxt::new(self.cx)
+ && (ecx.eval(left).is_none() || ecx.eval(right).is_none()) =>
{
self.eagerness |= NoChange;
},
diff --git a/src/tools/clippy/clippy_utils/src/higher.rs b/src/tools/clippy/clippy_utils/src/higher.rs
index 277ba8427e054..8970b4d122984 100644
--- a/src/tools/clippy/clippy_utils/src/higher.rs
+++ b/src/tools/clippy/clippy_utils/src/higher.rs
@@ -2,7 +2,7 @@
#![deny(clippy::missing_docs_in_private_items)]
-use crate::consts::{constant_simple, Constant};
+use crate::consts::{ConstEvalCtxt, Constant};
use crate::ty::is_type_diagnostic_item;
use crate::{is_expn_of, match_def_path, paths};
@@ -25,6 +25,8 @@ pub struct ForLoop<'tcx> {
pub loop_id: HirId,
/// entire `for` loop span
pub span: Span,
+ /// label
+ pub label: Option<ast::Label>,
}
impl<'tcx> ForLoop<'tcx> {
@@ -33,7 +35,7 @@ impl<'tcx> ForLoop<'tcx> {
if let ExprKind::DropTemps(e) = expr.kind
&& let ExprKind::Match(iterexpr, [arm], MatchSource::ForLoopDesugar) = e.kind
&& let ExprKind::Call(_, [arg]) = iterexpr.kind
- && let ExprKind::Loop(block, ..) = arm.body.kind
+ && let ExprKind::Loop(block, label, ..) = arm.body.kind
&& let [stmt] = block.stmts
&& let hir::StmtKind::Expr(e) = stmt.kind
&& let ExprKind::Match(_, [_, some_arm], _) = e.kind
@@ -45,6 +47,7 @@ impl<'tcx> ForLoop<'tcx> {
body: some_arm.body,
loop_id: arm.body.hir_id,
span: expr.span.ctxt().outer_expn_data().call_site,
+ label,
});
}
None
@@ -367,6 +370,7 @@ pub struct WhileLet<'hir> {
pub let_expr: &'hir Expr<'hir>,
/// `while let` loop body
pub if_then: &'hir Expr<'hir>,
+ pub label: Option<ast::Label>,
/// `while let PAT = EXPR`
/// ^^^^^^^^^^^^^^
pub let_span: Span,
@@ -399,7 +403,7 @@ impl<'hir> WhileLet<'hir> {
}),
..
},
- _,
+ label,
LoopSource::While,
_,
) = expr.kind
@@ -408,6 +412,7 @@ impl<'hir> WhileLet<'hir> {
let_pat,
let_expr,
if_then,
+ label,
let_span,
});
}
@@ -466,7 +471,7 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -
return Some(VecInitKind::Default);
} else if name.ident.name.as_str() == "with_capacity" {
let arg = args.first()?;
- return match constant_simple(cx, cx.typeck_results(), arg) {
+ return match ConstEvalCtxt::new(cx).eval_simple(arg) {
Some(Constant::Int(num)) => Some(VecInitKind::WithConstCapacity(num)),
_ => Some(VecInitKind::WithExprCapacity(arg.hir_id)),
};
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index 28178a61a9323..f325e4eaf1544 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -1,4 +1,4 @@
-use crate::consts::constant_simple;
+use crate::consts::ConstEvalCtxt;
use crate::macros::macro_backtrace;
use crate::source::{snippet_opt, walk_span_to_context, SpanRange, SpanRangeExt};
use crate::tokenize_with_text;
@@ -255,8 +255,8 @@ impl HirEqInterExpr<'_, '_, '_> {
if let Some((typeck_lhs, typeck_rhs)) = self.inner.maybe_typeck_results
&& typeck_lhs.expr_ty(left) == typeck_rhs.expr_ty(right)
&& let (Some(l), Some(r)) = (
- constant_simple(self.inner.cx, typeck_lhs, left),
- constant_simple(self.inner.cx, typeck_rhs, right),
+ ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.param_env, typeck_lhs).eval_simple(left),
+ ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.param_env, typeck_rhs).eval_simple(right),
)
&& l == r
{
@@ -714,9 +714,9 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
#[expect(clippy::too_many_lines)]
pub fn hash_expr(&mut self, e: &Expr<'_>) {
- let simple_const = self
- .maybe_typeck_results
- .and_then(|typeck_results| constant_simple(self.cx, typeck_results, e));
+ let simple_const = self.maybe_typeck_results.and_then(|typeck_results| {
+ ConstEvalCtxt::with_env(self.cx.tcx, self.cx.param_env, typeck_results).eval_simple(e)
+ });
// const hashing may result in the same hash as some unrelated node, so add a sort of
// discriminant depending on which path we're choosing next
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 1d5f1a2a2bb13..af74e4b67c162 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -10,7 +10,6 @@
#![feature(assert_matches)]
#![feature(unwrap_infallible)]
#![recursion_limit = "512"]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![allow(
clippy::missing_errors_doc,
clippy::missing_panics_doc,
@@ -126,7 +125,7 @@ use rustc_span::{sym, Span};
use rustc_target::abi::Integer;
use visitors::Visitable;
-use crate::consts::{constant, mir_to_const, Constant};
+use crate::consts::{mir_to_const, ConstEvalCtxt, Constant};
use crate::higher::Range;
use crate::ty::{adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type};
use crate::visitors::for_each_expr_without_closures;
@@ -211,20 +210,24 @@ pub fn local_is_initialized(cx: &LateContext<'_>, local: HirId) -> bool {
false
}
-/// Returns `true` if the given `HirId` is inside a constant context.
+/// Checks if we are currently in a const context (e.g. `const fn`, `static`/`const` initializer).
///
-/// This is the same as `is_inside_always_const_context`, but also includes
-/// `const fn`.
+/// The current context is determined based on the current body which is set before calling a lint's
+/// entry point (any function on `LateLintPass`). If you need to check in a different context use
+/// `tcx.hir().is_inside_const_context(_)`.
///
-/// # Example
-///
-/// ```rust,ignore
-/// if in_constant(cx, expr.hir_id) {
-/// // Do something
-/// }
-/// ```
-pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
- cx.tcx.hir().is_inside_const_context(id)
+/// Do not call this unless the `LateContext` has an enclosing body. For release build this case
+/// will safely return `false`, but debug builds will ICE. Note that `check_expr`, `check_block`,
+/// `check_pat` and a few other entry points will always have an enclosing body. Some entry points
+/// like `check_path` or `check_ty` may or may not have one.
+pub fn is_in_const_context(cx: &LateContext<'_>) -> bool {
+ debug_assert!(cx.enclosing_body.is_some(), "`LateContext` has no enclosing body");
+ cx.enclosing_body.is_some_and(|id| {
+ cx.tcx
+ .hir()
+ .body_const_context(cx.tcx.hir().body_owner_def_id(id))
+ .is_some()
+ })
}
/// Returns `true` if the given `HirId` is inside an always constant context.
@@ -589,9 +592,8 @@ fn find_primitive_impls<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<It
"u128" => SimplifiedType::Uint(UintTy::U128),
"f32" => SimplifiedType::Float(FloatTy::F32),
"f64" => SimplifiedType::Float(FloatTy::F64),
- #[allow(trivial_casts)]
_ => {
- return Result::<_, rustc_errors::ErrorGuaranteed>::Ok(&[] as &[_])
+ return Result::<&[_], rustc_errors::ErrorGuaranteed>::Ok(&[])
.into_iter()
.flatten()
.copied();
@@ -1579,8 +1581,8 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
if let rustc_ty::Adt(_, subst) = ty.kind()
&& let bnd_ty = subst.type_at(0)
&& let Some(min_val) = bnd_ty.numeric_min_val(cx.tcx)
- && let Some(min_const) = mir_to_const(cx, Const::from_ty_const(min_val, bnd_ty, cx.tcx))
- && let Some(start_const) = constant(cx, cx.typeck_results(), start)
+ && let Some(min_const) = mir_to_const(cx.tcx, Const::from_ty_const(min_val, bnd_ty, cx.tcx))
+ && let Some(start_const) = ConstEvalCtxt::new(cx).eval(start)
{
start_const == min_const
} else {
@@ -1592,8 +1594,8 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
if let rustc_ty::Adt(_, subst) = ty.kind()
&& let bnd_ty = subst.type_at(0)
&& let Some(max_val) = bnd_ty.numeric_max_val(cx.tcx)
- && let Some(max_const) = mir_to_const(cx, Const::from_ty_const(max_val, bnd_ty, cx.tcx))
- && let Some(end_const) = constant(cx, cx.typeck_results(), end)
+ && let Some(max_const) = mir_to_const(cx.tcx, Const::from_ty_const(max_val, bnd_ty, cx.tcx))
+ && let Some(end_const) = ConstEvalCtxt::new(cx).eval(end)
{
end_const == max_const
} else {
@@ -1624,7 +1626,9 @@ pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool
return true;
}
let enclosing_body = cx.tcx.hir().enclosing_body_owner(e.hir_id);
- if let Some(Constant::Int(v)) = constant(cx, cx.tcx.typeck(enclosing_body), e) {
+ if let Some(Constant::Int(v)) =
+ ConstEvalCtxt::with_env(cx.tcx, cx.tcx.param_env(enclosing_body), cx.tcx.typeck(enclosing_body)).eval(e)
+ {
return value == v;
}
false
diff --git a/src/tools/clippy/clippy_utils/src/paths.rs b/src/tools/clippy/clippy_utils/src/paths.rs
index d5a3d8b9e5a2e..684c645c19964 100644
--- a/src/tools/clippy/clippy_utils/src/paths.rs
+++ b/src/tools/clippy/clippy_utils/src/paths.rs
@@ -16,7 +16,6 @@ pub const BINARYHEAP_ITER: [&str; 5] = ["alloc", "collections", "binary_heap", "
pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
pub const BTREESET_ITER: [&str; 6] = ["alloc", "collections", "btree", "set", "BTreeSet", "iter"];
-pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
pub const CORE_ITER_CLONED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "cloned"];
pub const CORE_ITER_COPIED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "copied"];
pub const CORE_ITER_FILTER: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "filter"];
diff --git a/src/tools/clippy/clippy_utils/src/source.rs b/src/tools/clippy/clippy_utils/src/source.rs
index 496c8f5b55373..96dd3c55d37ae 100644
--- a/src/tools/clippy/clippy_utils/src/source.rs
+++ b/src/tools/clippy/clippy_utils/src/source.rs
@@ -6,7 +6,8 @@ use rustc_ast::{LitKind, StrStyle};
use rustc_data_structures::sync::Lrc;
use rustc_errors::Applicability;
use rustc_hir::{BlockCheckMode, Expr, ExprKind, UnsafeSource};
-use rustc_lint::{LateContext, LintContext};
+use rustc_lint::{EarlyContext, LateContext};
+use rustc_middle::ty::TyCtxt;
use rustc_session::Session;
use rustc_span::source_map::{original_sp, SourceMap};
use rustc_span::{
@@ -17,6 +18,30 @@ use std::borrow::Cow;
use std::fmt;
use std::ops::Range;
+pub trait HasSession {
+ fn sess(&self) -> &Session;
+}
+impl HasSession for Session {
+ fn sess(&self) -> &Session {
+ self
+ }
+}
+impl HasSession for TyCtxt<'_> {
+ fn sess(&self) -> &Session {
+ self.sess
+ }
+}
+impl HasSession for EarlyContext<'_> {
+ fn sess(&self) -> &Session {
+ ::rustc_lint::LintContext::sess(self)
+ }
+}
+impl HasSession for LateContext<'_> {
+ fn sess(&self) -> &Session {
+ self.tcx.sess()
+ }
+}
+
/// Conversion of a value into the range portion of a `Span`.
pub trait SpanRange: Sized {
fn into_range(self) -> Range<BytePos>;
@@ -71,19 +96,19 @@ impl IntoSpan for Range<BytePos> {
pub trait SpanRangeExt: SpanRange {
/// Gets the source file, and range in the file, of the given span. Returns `None` if the span
/// extends through multiple files, or is malformed.
- fn get_source_text(self, cx: &impl LintContext) -> Option<SourceFileRange> {
+ fn get_source_text(self, cx: &impl HasSession) -> Option<SourceFileRange> {
get_source_text(cx.sess().source_map(), self.into_range())
}
/// Calls the given function with the source text referenced and returns the value. Returns
/// `None` if the source text cannot be retrieved.
- fn with_source_text<T>(self, cx: &impl LintContext, f: impl for<'a> FnOnce(&'a str) -> T) -> Option<T> {
+ fn with_source_text<T>(self, cx: &impl HasSession, f: impl for<'a> FnOnce(&'a str) -> T) -> Option<T> {
with_source_text(cx.sess().source_map(), self.into_range(), f)
}
/// Checks if the referenced source text satisfies the given predicate. Returns `false` if the
/// source text cannot be retrieved.
- fn check_source_text(self, cx: &impl LintContext, pred: impl for<'a> FnOnce(&'a str) -> bool) -> bool {
+ fn check_source_text(self, cx: &impl HasSession, pred: impl for<'a> FnOnce(&'a str) -> bool) -> bool {
self.with_source_text(cx, pred).unwrap_or(false)
}
@@ -91,7 +116,7 @@ pub trait SpanRangeExt: SpanRange {
/// and returns the value. Returns `None` if the source text cannot be retrieved.
fn with_source_text_and_range<T>(
self,
- cx: &impl LintContext,
+ cx: &impl HasSession,
f: impl for<'a> FnOnce(&'a str, Range<usize>) -> T,
) -> Option<T> {
with_source_text_and_range(cx.sess().source_map(), self.into_range(), f)
@@ -104,30 +129,30 @@ pub trait SpanRangeExt: SpanRange {
/// The new range must reside within the same source file.
fn map_range(
self,
- cx: &impl LintContext,
+ cx: &impl HasSession,
f: impl for<'a> FnOnce(&'a str, Range<usize>) -> Option<Range<usize>>,
) -> Option<Range<BytePos>> {
map_range(cx.sess().source_map(), self.into_range(), f)
}
/// Extends the range to include all preceding whitespace characters.
- fn with_leading_whitespace(self, cx: &impl LintContext) -> Range<BytePos> {
+ fn with_leading_whitespace(self, cx: &impl HasSession) -> Range<BytePos> {
with_leading_whitespace(cx.sess().source_map(), self.into_range())
}
/// Trims the leading whitespace from the range.
- fn trim_start(self, cx: &impl LintContext) -> Range<BytePos> {
+ fn trim_start(self, cx: &impl HasSession) -> Range<BytePos> {
trim_start(cx.sess().source_map(), self.into_range())
}
/// Writes the referenced source text to the given writer. Will return `Err` if the source text
/// could not be retrieved.
- fn write_source_text_to(self, cx: &impl LintContext, dst: &mut impl fmt::Write) -> fmt::Result {
+ fn write_source_text_to(self, cx: &impl HasSession, dst: &mut impl fmt::Write) -> fmt::Result {
write_source_text_to(cx.sess().source_map(), self.into_range(), dst)
}
/// Extracts the referenced source text as an owned string.
- fn source_text_to_string(self, cx: &impl LintContext) -> Option<String> {
+ fn source_text_to_string(self, cx: &impl HasSession) -> Option<String> {
self.with_source_text(cx, ToOwned::to_owned)
}
}
@@ -227,15 +252,15 @@ impl SourceFileRange {
}
/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
-pub fn expr_block<T: LintContext>(
- cx: &T,
+pub fn expr_block(
+ sess: &impl HasSession,
expr: &Expr<'_>,
outer: SyntaxContext,
default: &str,
indent_relative_to: Option<Span>,
app: &mut Applicability,
) -> String {
- let (code, from_macro) = snippet_block_with_context(cx, expr.span, outer, default, indent_relative_to, app);
+ let (code, from_macro) = snippet_block_with_context(sess, expr.span, outer, default, indent_relative_to, app);
if !from_macro
&& let ExprKind::Block(block, _) = expr.kind
&& block.rules != BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
@@ -260,13 +285,13 @@ pub fn expr_block<T: LintContext>(
/// let x = ();
/// // ^^^^^^^^^^
/// ```
-pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
- first_char_in_first_line(cx, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
+pub fn first_line_of_span(sess: &impl HasSession, span: Span) -> Span {
+ first_char_in_first_line(sess, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
}
-fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
- let line_span = line_span(cx, span);
- snippet_opt(cx, line_span).and_then(|snip| {
+fn first_char_in_first_line(sess: &impl HasSession, span: Span) -> Option<BytePos> {
+ let line_span = line_span(sess, span);
+ snippet_opt(sess, line_span).and_then(|snip| {
snip.find(|c: char| !c.is_whitespace())
.map(|pos| line_span.lo() + BytePos::from_usize(pos))
})
@@ -281,9 +306,9 @@ fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePo
/// let x = ();
/// // ^^^^^^^^^^^^^^
/// ```
-fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
+fn line_span(sess: &impl HasSession, span: Span) -> Span {
let span = original_sp(span, DUMMY_SP);
- let SourceFileAndLine { sf, line } = cx.sess().source_map().lookup_line(span.lo()).unwrap();
+ let SourceFileAndLine { sf, line } = sess.sess().source_map().lookup_line(span.lo()).unwrap();
let line_start = sf.lines()[line];
let line_start = sf.absolute_position(line_start);
span.with_lo(line_start)
@@ -297,13 +322,13 @@ fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
/// let x = ();
/// // ^^ -- will return 4
/// ```
-pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
- snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
+pub fn indent_of(sess: &impl HasSession, span: Span) -> Option<usize> {
+ snippet_opt(sess, line_span(sess, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
}
/// Gets a snippet of the indentation of the line of a span
-pub fn snippet_indent<T: LintContext>(cx: &T, span: Span) -> Option<String> {
- snippet_opt(cx, line_span(cx, span)).map(|mut s| {
+pub fn snippet_indent(sess: &impl HasSession, span: Span) -> Option<String> {
+ snippet_opt(sess, line_span(sess, span)).map(|mut s| {
let len = s.len() - s.trim_start().len();
s.truncate(len);
s
@@ -315,8 +340,8 @@ pub fn snippet_indent<T: LintContext>(cx: &T, span: Span) -> Option<String> {
// sources that the user has no control over.
// For some reason these attributes don't have any expansion info on them, so
// we have to check it this way until there is a better way.
-pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
- if let Some(snippet) = snippet_opt(cx, span) {
+pub fn is_present_in_source(sess: &impl HasSession, span: Span) -> bool {
+ if let Some(snippet) = snippet_opt(sess, span) {
if snippet.is_empty() {
return false;
}
@@ -407,8 +432,8 @@ fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>,
/// snippet(cx, span1, "..") // -> "value"
/// snippet(cx, span2, "..") // -> "Vec::new()"
/// ```
-pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
- snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
+pub fn snippet<'a>(sess: &impl HasSession, span: Span, default: &'a str) -> Cow<'a, str> {
+ snippet_opt(sess, span).map_or_else(|| Cow::Borrowed(default), From::from)
}
/// Same as [`snippet`], but it adapts the applicability level by following rules:
@@ -417,13 +442,13 @@ pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<
/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
/// - If the default value is used and the applicability level is `MachineApplicable`, change it to
/// `HasPlaceholders`
-pub fn snippet_with_applicability<'a, T: LintContext>(
- cx: &T,
+pub fn snippet_with_applicability<'a>(
+ sess: &impl HasSession,
span: Span,
default: &'a str,
applicability: &mut Applicability,
) -> Cow<'a, str> {
- snippet_with_applicability_sess(cx.sess(), span, default, applicability)
+ snippet_with_applicability_sess(sess.sess(), span, default, applicability)
}
fn snippet_with_applicability_sess<'a>(
@@ -435,7 +460,7 @@ fn snippet_with_applicability_sess<'a>(
if *applicability != Applicability::Unspecified && span.from_expansion() {
*applicability = Applicability::MaybeIncorrect;
}
- snippet_opt_sess(sess, span).map_or_else(
+ snippet_opt(sess, span).map_or_else(
|| {
if *applicability == Applicability::MachineApplicable {
*applicability = Applicability::HasPlaceholders;
@@ -447,12 +472,8 @@ fn snippet_with_applicability_sess<'a>(
}
/// Converts a span to a code snippet. Returns `None` if not available.
-pub fn snippet_opt(cx: &impl LintContext, span: Span) -> Option<String> {
- snippet_opt_sess(cx.sess(), span)
-}
-
-fn snippet_opt_sess(sess: &Session, span: Span) -> Option<String> {
- sess.source_map().span_to_snippet(span).ok()
+pub fn snippet_opt(sess: &impl HasSession, span: Span) -> Option<String> {
+ sess.sess().source_map().span_to_snippet(span).ok()
}
/// Converts a span (from a block) to a code snippet if available, otherwise use default.
@@ -489,41 +510,41 @@ fn snippet_opt_sess(sess: &Session, span: Span) -> Option<String> {
/// } // aligned with `if`
/// ```
/// Note that the first line of the snippet always has 0 indentation.
-pub fn snippet_block<'a, T: LintContext>(
- cx: &T,
+pub fn snippet_block<'a>(
+ sess: &impl HasSession,
span: Span,
default: &'a str,
indent_relative_to: Option<Span>,
) -> Cow<'a, str> {
- let snip = snippet(cx, span, default);
- let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+ let snip = snippet(sess, span, default);
+ let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
reindent_multiline(snip, true, indent)
}
/// Same as `snippet_block`, but adapts the applicability level by the rules of
/// `snippet_with_applicability`.
pub fn snippet_block_with_applicability<'a>(
- cx: &impl LintContext,
+ sess: &impl HasSession,
span: Span,
default: &'a str,
indent_relative_to: Option<Span>,
applicability: &mut Applicability,
) -> Cow<'a, str> {
- let snip = snippet_with_applicability(cx, span, default, applicability);
- let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+ let snip = snippet_with_applicability(sess, span, default, applicability);
+ let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
reindent_multiline(snip, true, indent)
}
pub fn snippet_block_with_context<'a>(
- cx: &impl LintContext,
+ sess: &impl HasSession,
span: Span,
outer: SyntaxContext,
default: &'a str,
indent_relative_to: Option<Span>,
app: &mut Applicability,
) -> (Cow<'a, str>, bool) {
- let (snip, from_macro) = snippet_with_context(cx, span, outer, default, app);
- let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+ let (snip, from_macro) = snippet_with_context(sess, span, outer, default, app);
+ let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
(reindent_multiline(snip, true, indent), from_macro)
}
@@ -537,13 +558,13 @@ pub fn snippet_block_with_context<'a>(
///
/// This will also return whether or not the snippet is a macro call.
pub fn snippet_with_context<'a>(
- cx: &impl LintContext,
+ sess: &impl HasSession,
span: Span,
outer: SyntaxContext,
default: &'a str,
applicability: &mut Applicability,
) -> (Cow<'a, str>, bool) {
- snippet_with_context_sess(cx.sess(), span, outer, default, applicability)
+ snippet_with_context_sess(sess.sess(), span, outer, default, applicability)
}
fn snippet_with_context_sess<'a>(
@@ -661,15 +682,15 @@ pub fn trim_span(sm: &SourceMap, span: Span) -> Span {
/// writeln!(o, "") -> writeln!(o, "")
/// ^^ ^^^^
/// ```
-pub fn expand_past_previous_comma(cx: &LateContext<'_>, span: Span) -> Span {
- let extended = cx.sess().source_map().span_extend_to_prev_char(span, ',', true);
+pub fn expand_past_previous_comma(sess: &impl HasSession, span: Span) -> Span {
+ let extended = sess.sess().source_map().span_extend_to_prev_char(span, ',', true);
extended.with_lo(extended.lo() - BytePos(1))
}
/// Converts `expr` to a `char` literal if it's a `str` literal containing a single
/// character (or a single byte with `ascii_only`)
pub fn str_literal_to_char_literal(
- cx: &LateContext<'_>,
+ sess: &impl HasSession,
expr: &Expr<'_>,
applicability: &mut Applicability,
ascii_only: bool,
@@ -684,7 +705,7 @@ pub fn str_literal_to_char_literal(
}
&& len == 1
{
- let snip = snippet_with_applicability(cx, expr.span, string, applicability);
+ let snip = snippet_with_applicability(sess, expr.span, string, applicability);
let ch = if let StrStyle::Raw(nhash) = style {
let nhash = nhash as usize;
// for raw string: r##"a"##
diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs
index 812fb647fdab6..bd48990aea95f 100644
--- a/src/tools/clippy/clippy_utils/src/ty.rs
+++ b/src/tools/clippy/clippy_utils/src/ty.rs
@@ -525,19 +525,6 @@ pub fn needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
}
-/// Peels off all references on the type. Returns the underlying type and the number of references
-/// removed.
-pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
- fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
- if let ty::Ref(_, ty, _) = ty.kind() {
- peel(*ty, count + 1)
- } else {
- (ty, count)
- }
- }
- peel(ty, 0)
-}
-
/// Peels off all references on the type. Returns the underlying type, the number of references
/// removed, and whether the pointer is ultimately mutable or not.
pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
diff --git a/src/tools/clippy/clippy_utils/src/visitors.rs b/src/tools/clippy/clippy_utils/src/visitors.rs
index 7066c9ad2b96b..2a5d3536ff6b7 100644
--- a/src/tools/clippy/clippy_utils/src/visitors.rs
+++ b/src/tools/clippy/clippy_utils/src/visitors.rs
@@ -1,6 +1,7 @@
use crate::ty::needs_ordered_drop;
use crate::{get_enclosing_block, path_to_local_id};
use core::ops::ControlFlow;
+use rustc_ast::visit::{try_visit, VisitorResult};
use rustc_hir as hir;
use rustc_hir::def::{CtorKind, DefKind, Res};
use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor};
@@ -50,16 +51,17 @@ impl Continue for Descend {
/// A type which can be visited.
pub trait Visitable<'tcx> {
/// Calls the corresponding `visit_*` function on the visitor.
- fn visit<V: Visitor<'tcx>>(self, visitor: &mut V);
+ fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result;
}
impl<'tcx, T> Visitable<'tcx> for &'tcx [T]
where
&'tcx T: Visitable<'tcx>,
{
- fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+ fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result {
for x in self {
- x.visit(visitor);
+ try_visit!(x.visit(visitor));
}
+ V::Result::output()
}
}
impl<'tcx, A, B> Visitable<'tcx> for (A, B)
@@ -67,27 +69,28 @@ where
A: Visitable<'tcx>,
B: Visitable<'tcx>,
{
- fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+ fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result {
let (a, b) = self;
- a.visit(visitor);
- b.visit(visitor);
+ try_visit!(a.visit(visitor));
+ b.visit(visitor)
}
}
impl<'tcx, T> Visitable<'tcx> for Option<T>
where
T: Visitable<'tcx>,
{
- fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+ fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result {
if let Some(x) = self {
- x.visit(visitor);
+ try_visit!(x.visit(visitor));
}
+ V::Result::output()
}
}
macro_rules! visitable_ref {
($t:ident, $f:ident) => {
impl<'tcx> Visitable<'tcx> for &'tcx $t<'tcx> {
- fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
- visitor.$f(self);
+ fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result {
+ visitor.$f(self)
}
}
};
@@ -104,45 +107,37 @@ pub fn for_each_expr_without_closures<'tcx, B, C: Continue>(
node: impl Visitable<'tcx>,
f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>,
) -> Option<B> {
- struct V<B, F> {
+ struct V<F> {
f: F,
- res: Option<B>,
}
- impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<B, F> {
- type Result = ControlFlow<()>;
+ impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<F> {
+ type Result = ControlFlow<B>;
- fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) -> ControlFlow<()> {
- if self.res.is_some() {
- return ControlFlow::Break(());
- }
+ fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) -> Self::Result {
match (self.f)(e) {
ControlFlow::Continue(c) if c.descend() => walk_expr(self, e),
- ControlFlow::Break(b) => {
- self.res = Some(b);
- ControlFlow::Break(())
- },
+ ControlFlow::Break(b) => ControlFlow::Break(b),
ControlFlow::Continue(_) => ControlFlow::Continue(()),
}
}
// Avoid unnecessary `walk_*` calls.
- fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) -> ControlFlow<()> {
+ fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) -> Self::Result {
ControlFlow::Continue(())
}
- fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) -> ControlFlow<()> {
+ fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) -> Self::Result {
ControlFlow::Continue(())
}
- fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) -> ControlFlow<()> {
+ fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) -> Self::Result {
ControlFlow::Continue(())
}
// Avoid monomorphising all `visit_*` functions.
- fn visit_nested_item(&mut self, _: ItemId) -> ControlFlow<()> {
+ fn visit_nested_item(&mut self, _: ItemId) -> Self::Result {
ControlFlow::Continue(())
}
}
- let mut v = V { f, res: None };
- node.visit(&mut v);
- v.res
+ let mut v = V { f };
+ node.visit(&mut v).break_value()
}
/// Calls the given function once for each expression contained. This will enter bodies, but not
@@ -152,44 +147,47 @@ pub fn for_each_expr<'tcx, B, C: Continue>(
node: impl Visitable<'tcx>,
f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>,
) -> Option<B> {
- struct V<'tcx, B, F> {
+ struct V<'tcx, F> {
tcx: TyCtxt<'tcx>,
f: F,
- res: Option<B>,
}
- impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<'tcx, B, F> {
+ impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<'tcx, F> {
type NestedFilter = nested_filter::OnlyBodies;
+ type Result = ControlFlow<B>;
+
fn nested_visit_map(&mut self) -> Self::Map {
self.tcx.hir()
}
- fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
- if self.res.is_some() {
- return;
- }
+ fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) -> Self::Result {
match (self.f)(e) {
ControlFlow::Continue(c) if c.descend() => walk_expr(self, e),
- ControlFlow::Break(b) => self.res = Some(b),
- ControlFlow::Continue(_) => (),
+ ControlFlow::Break(b) => ControlFlow::Break(b),
+ ControlFlow::Continue(_) => ControlFlow::Continue(()),
}
}
// Only walk closures
- fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
+ fn visit_anon_const(&mut self, _: &'tcx AnonConst) -> Self::Result {
+ ControlFlow::Continue(())
+ }
// Avoid unnecessary `walk_*` calls.
- fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) {}
- fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
- fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
+ fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) -> Self::Result {
+ ControlFlow::Continue(())
+ }
+ fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) -> Self::Result {
+ ControlFlow::Continue(())
+ }
+ fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) -> Self::Result {
+ ControlFlow::Continue(())
+ }
// Avoid monomorphising all `visit_*` functions.
- fn visit_nested_item(&mut self, _: ItemId) {}
+ fn visit_nested_item(&mut self, _: ItemId) -> Self::Result {
+ ControlFlow::Continue(())
+ }
}
- let mut v = V {
- tcx: cx.tcx,
- f,
- res: None,
- };
- node.visit(&mut v);
- v.res
+ let mut v = V { tcx: cx.tcx, f };
+ node.visit(&mut v).break_value()
}
/// returns `true` if expr contains match expr desugared from try
diff --git a/src/tools/clippy/declare_clippy_lint/Cargo.toml b/src/tools/clippy/declare_clippy_lint/Cargo.toml
index 80106f683c2ae..31270241b0b2e 100644
--- a/src/tools/clippy/declare_clippy_lint/Cargo.toml
+++ b/src/tools/clippy/declare_clippy_lint/Cargo.toml
@@ -11,6 +11,3 @@ proc-macro = true
itertools = "0.12"
quote = "1.0.21"
syn = "2.0"
-
-[features]
-deny-warnings = []
diff --git a/src/tools/clippy/declare_clippy_lint/src/lib.rs b/src/tools/clippy/declare_clippy_lint/src/lib.rs
index 25b2fc9395cd9..ca070f6c250bf 100644
--- a/src/tools/clippy/declare_clippy_lint/src/lib.rs
+++ b/src/tools/clippy/declare_clippy_lint/src/lib.rs
@@ -1,5 +1,4 @@
#![feature(let_chains)]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
// warn on lints, that are included in `rust-lang/rust`s bootstrap
#![warn(rust_2018_idioms, unused_lifetimes)]
diff --git a/src/tools/clippy/lintcheck/Cargo.toml b/src/tools/clippy/lintcheck/Cargo.toml
index 350418eeeb871..b0e4e3e3e573b 100644
--- a/src/tools/clippy/lintcheck/Cargo.toml
+++ b/src/tools/clippy/lintcheck/Cargo.toml
@@ -25,6 +25,3 @@ tar = "0.4"
toml = "0.7.3"
ureq = { version = "2.2", features = ["json"] }
walkdir = "2.3"
-
-[features]
-deny-warnings = []
diff --git a/src/tools/clippy/lintcheck/src/config.rs b/src/tools/clippy/lintcheck/src/config.rs
index 6bec1753fc7b8..bd4fcc5e337e9 100644
--- a/src/tools/clippy/lintcheck/src/config.rs
+++ b/src/tools/clippy/lintcheck/src/config.rs
@@ -33,13 +33,13 @@ pub(crate) struct LintcheckConfig {
/// Runs cargo clippy --fix and checks if all suggestions apply
#[clap(long, conflicts_with("max_jobs"))]
pub fix: bool,
- /// Apply a filter to only collect specified lints, this also overrides `allow` attributes
+ /// Apply a filter to only collect specified lints
#[clap(long = "filter", value_name = "clippy_lint_name", use_value_delimiter = true)]
pub lint_filter: Vec<String>,
- /// Set all lints to the "warn" lint level, even resitriction ones. Usually,
- /// it's better to use `--filter` instead
+ /// Check all Clippy lints, by default only `clippy::all` and `clippy::pedantic` are checked.
+ /// Usually, it's better to use `--filter` instead
#[clap(long, conflicts_with("lint_filter"))]
- pub warn_all: bool,
+ pub all_lints: bool,
/// Set the output format of the log file
#[clap(long, short, default_value = "text")]
pub format: OutputFormat,
diff --git a/src/tools/clippy/lintcheck/src/input.rs b/src/tools/clippy/lintcheck/src/input.rs
index 3b263674aa87a..3383d50fa02c7 100644
--- a/src/tools/clippy/lintcheck/src/input.rs
+++ b/src/tools/clippy/lintcheck/src/input.rs
@@ -98,12 +98,12 @@ pub fn read_crates(toml_path: &Path) -> (Vec<CrateWithSource>, RecursiveOptions)
let crate_list: SourceList =
toml::from_str(&toml_content).unwrap_or_else(|e| panic!("Failed to parse {}: \n{e}", toml_path.display()));
// parse the hashmap of the toml file into a list of crates
- let tomlcrates: Vec<TomlCrate> = crate_list.crates.into_values().collect();
+ let toml_crates: Vec<TomlCrate> = crate_list.crates.into_values().collect();
// flatten TomlCrates into CrateSources (one TomlCrates may represent several versions of a crate =>
- // multiple Cratesources)
+ // multiple CrateSources)
let mut crate_sources = Vec::new();
- for tk in tomlcrates {
+ for tk in toml_crates {
if let Some(ref path) = tk.path {
crate_sources.push(CrateWithSource {
name: tk.name.clone(),
diff --git a/src/tools/clippy/lintcheck/src/main.rs b/src/tools/clippy/lintcheck/src/main.rs
index 0dd62ded293c8..acb6eaa5278aa 100644
--- a/src/tools/clippy/lintcheck/src/main.rs
+++ b/src/tools/clippy/lintcheck/src/main.rs
@@ -119,7 +119,8 @@ impl Crate {
cmd.arg(if config.fix { "fix" } else { "check" })
.arg("--quiet")
.current_dir(&self.path)
- .env("CLIPPY_ARGS", clippy_args.join("__CLIPPY_HACKERY__"));
+ .env("CLIPPY_ARGS", clippy_args.join("__CLIPPY_HACKERY__"))
+ .env("CLIPPY_DISABLE_DOCS_LINKS", "1");
if let Some(server) = server {
// `cargo clippy` is a wrapper around `cargo check` that mainly sets `RUSTC_WORKSPACE_WRAPPER` to
@@ -284,29 +285,24 @@ fn lintcheck(config: LintcheckConfig) {
let (crates, recursive_options) = read_crates(&config.sources_toml_path);
let counter = AtomicUsize::new(1);
- let mut lint_level_args: Vec<String> = vec![];
+ let mut lint_level_args: Vec<String> = vec!["--cap-lints=allow".into()];
if config.lint_filter.is_empty() {
- lint_level_args.push("--cap-lints=warn".to_string());
-
- // Set allow-by-default to warn
- if config.warn_all {
- [
+ let groups = if config.all_lints {
+ &[
+ "clippy::all",
"clippy::cargo",
"clippy::nursery",
"clippy::pedantic",
"clippy::restriction",
- ]
+ ][..]
+ } else {
+ &["clippy::all", "clippy::pedantic"]
+ };
+ groups
.iter()
- .map(|group| format!("--warn={group}"))
+ .map(|group| format!("--force-warn={group}"))
.collect_into(&mut lint_level_args);
- } else {
- ["clippy::cargo", "clippy::pedantic"]
- .iter()
- .map(|group| format!("--warn={group}"))
- .collect_into(&mut lint_level_args);
- }
} else {
- lint_level_args.push("--cap-lints=allow".to_string());
config
.lint_filter
.iter()
diff --git a/src/tools/clippy/rust-toolchain b/src/tools/clippy/rust-toolchain
index 69fb11a4824af..5fbe4e544a9e4 100644
--- a/src/tools/clippy/rust-toolchain
+++ b/src/tools/clippy/rust-toolchain
@@ -1,4 +1,4 @@
[toolchain]
-channel = "nightly-2024-07-25"
+channel = "nightly-2024-08-08"
components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
profile = "minimal"
diff --git a/src/tools/clippy/rustc_tools_util/Cargo.toml b/src/tools/clippy/rustc_tools_util/Cargo.toml
index 877049ae7d0eb..37b592da132f4 100644
--- a/src/tools/clippy/rustc_tools_util/Cargo.toml
+++ b/src/tools/clippy/rustc_tools_util/Cargo.toml
@@ -10,6 +10,3 @@ categories = ["development-tools"]
edition = "2018"
[dependencies]
-
-[features]
-deny-warnings = []
diff --git a/src/tools/clippy/rustc_tools_util/src/lib.rs b/src/tools/clippy/rustc_tools_util/src/lib.rs
index 4c1d8c3733df6..2cc38130472f8 100644
--- a/src/tools/clippy/rustc_tools_util/src/lib.rs
+++ b/src/tools/clippy/rustc_tools_util/src/lib.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+use std::str;
/// This macro creates the version string during compilation from the
/// current environment
@@ -101,49 +101,46 @@ impl std::fmt::Debug for VersionInfo {
#[must_use]
pub fn get_commit_hash() -> Option<String> {
- std::process::Command::new("git")
- .args(["rev-parse", "--short", "HEAD"])
+ let output = std::process::Command::new("git")
+ .args(["rev-parse", "HEAD"])
.output()
- .ok()
- .and_then(|r| String::from_utf8(r.stdout).ok())
+ .ok()?;
+ let mut stdout = output.status.success().then_some(output.stdout)?;
+ stdout.truncate(10);
+ String::from_utf8(stdout).ok()
}
#[must_use]
pub fn get_commit_date() -> Option<String> {
- std::process::Command::new("git")
+ let output = std::process::Command::new("git")
.args(["log", "-1", "--date=short", "--pretty=format:%cd"])
.output()
- .ok()
- .and_then(|r| String::from_utf8(r.stdout).ok())
+ .ok()?;
+ let stdout = output.status.success().then_some(output.stdout)?;
+ String::from_utf8(stdout).ok()
}
#[must_use]
pub fn get_channel() -> String {
- match std::env::var("CFG_RELEASE_CHANNEL") {
- Ok(channel) => channel,
- Err(_) => {
- // if that failed, try to ask rustc -V, do some parsing and find out
- match std::process::Command::new("rustc")
- .arg("-V")
- .output()
- .ok()
- .and_then(|r| String::from_utf8(r.stdout).ok())
- {
- Some(rustc_output) => {
- if rustc_output.contains("beta") {
- String::from("beta")
- } else if rustc_output.contains("stable") {
- String::from("stable")
- } else {
- // default to nightly if we fail to parse
- String::from("nightly")
- }
- },
- // default to nightly
- None => String::from("nightly"),
+ if let Ok(channel) = std::env::var("CFG_RELEASE_CHANNEL") {
+ return channel;
+ }
+
+ // if that failed, try to ask rustc -V, do some parsing and find out
+ if let Ok(output) = std::process::Command::new("rustc").arg("-V").output() {
+ if output.status.success() {
+ if let Ok(rustc_output) = str::from_utf8(&output.stdout) {
+ if rustc_output.contains("beta") {
+ return String::from("beta");
+ } else if rustc_output.contains("stable") {
+ return String::from("stable");
+ }
}
- },
+ }
}
+
+ // default to nightly
+ String::from("nightly")
}
#[cfg(test)]
diff --git a/src/tools/clippy/src/driver.rs b/src/tools/clippy/src/driver.rs
index 3fafe2427a256..0ac3f35b4465a 100644
--- a/src/tools/clippy/src/driver.rs
+++ b/src/tools/clippy/src/driver.rs
@@ -2,7 +2,6 @@
#![allow(rustc::untranslatable_diagnostic)]
#![feature(rustc_private)]
#![feature(let_chains)]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
// warn on lints, that are included in `rust-lang/rust`s bootstrap
#![warn(rust_2018_idioms, unused_lifetimes)]
// warn on rustc internal lints
@@ -151,7 +150,6 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
let conf = clippy_config::Conf::read(sess, &conf_path);
clippy_lints::register_lints(lint_store, conf);
clippy_lints::register_pre_expansion_lints(lint_store, conf);
- clippy_lints::register_renamed(lint_store);
}));
// FIXME: #4825; This is required, because Clippy lints that are based on MIR have to be
diff --git a/src/tools/clippy/src/main.rs b/src/tools/clippy/src/main.rs
index 30beaae34d2fe..c9af2138a7233 100644
--- a/src/tools/clippy/src/main.rs
+++ b/src/tools/clippy/src/main.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
// warn on lints, that are included in `rust-lang/rust`s bootstrap
#![warn(rust_2018_idioms, unused_lifetimes)]
diff --git a/src/tools/clippy/tests/check-fmt.rs b/src/tools/clippy/tests/check-fmt.rs
index e106583de4a2e..cd3fed896c2de 100644
--- a/src/tools/clippy/tests/check-fmt.rs
+++ b/src/tools/clippy/tests/check-fmt.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)]
use std::path::PathBuf;
diff --git a/src/tools/clippy/tests/compile-test.rs b/src/tools/clippy/tests/compile-test.rs
index 4e5120406b0d8..c7080e5dcdc9e 100644
--- a/src/tools/clippy/tests/compile-test.rs
+++ b/src/tools/clippy/tests/compile-test.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)]
#![allow(unused_extern_crates)]
@@ -208,7 +207,8 @@ fn run_ui_toml() {
ui_test::run_tests_generic(
vec![config],
ui_test::default_file_filter,
- |config, path, _file_contents| {
+ |config, file_contents| {
+ let path = file_contents.span().file;
config
.program
.envs
@@ -260,7 +260,7 @@ fn run_ui_cargo() {
path.ends_with("Cargo.toml")
.then(|| ui_test::default_any_file_filter(path, config) && !ignored_32bit(path))
},
- |_config, _path, _file_contents| {},
+ |_config, _file_contents| {},
status_emitter::Text::from(args.format),
)
.unwrap();
diff --git a/src/tools/clippy/tests/dogfood.rs b/src/tools/clippy/tests/dogfood.rs
index c8a761bf509ec..8d10d5e7161a6 100644
--- a/src/tools/clippy/tests/dogfood.rs
+++ b/src/tools/clippy/tests/dogfood.rs
@@ -3,7 +3,6 @@
//!
//! See [Eating your own dog food](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) for context
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)]
use itertools::Itertools;
diff --git a/src/tools/clippy/tests/integration.rs b/src/tools/clippy/tests/integration.rs
index 77b7bb6a7bf69..13cf36823c5e4 100644
--- a/src/tools/clippy/tests/integration.rs
+++ b/src/tools/clippy/tests/integration.rs
@@ -8,7 +8,6 @@
//! Clippy doesn't produce an ICE. Lint warnings are ignored by this test.
#![cfg(feature = "integration")]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)]
use std::env;
diff --git a/src/tools/clippy/tests/lint_message_convention.rs b/src/tools/clippy/tests/lint_message_convention.rs
index 6ce7e44474d81..7ed1f485c1cfd 100644
--- a/src/tools/clippy/tests/lint_message_convention.rs
+++ b/src/tools/clippy/tests/lint_message_convention.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)]
use std::ffi::OsStr;
diff --git a/src/tools/clippy/tests/missing-test-files.rs b/src/tools/clippy/tests/missing-test-files.rs
index 141c11ddb47f9..a8225d037e828 100644
--- a/src/tools/clippy/tests/missing-test-files.rs
+++ b/src/tools/clippy/tests/missing-test-files.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)]
#![allow(clippy::assertions_on_constants)]
#![feature(path_file_prefix)]
diff --git a/src/tools/clippy/tests/ui-internal/default_deprecation_reason.rs b/src/tools/clippy/tests/ui-internal/default_deprecation_reason.rs
deleted file mode 100644
index c8961d5e1f0bd..0000000000000
--- a/src/tools/clippy/tests/ui-internal/default_deprecation_reason.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-#[macro_use]
-extern crate clippy_lints;
-use clippy_lints::deprecated_lints::ClippyDeprecatedLint;
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// TODO
- #[clippy::version = "1.63.0"]
- pub COOL_LINT_DEFAULT,
- "default deprecation note"
-}
-
-declare_deprecated_lint! {
- /// ### What it does
- /// Nothing. This lint has been deprecated.
- ///
- /// ### Deprecation reason
- /// This lint has been replaced by `cooler_lint`
- #[clippy::version = "1.63.0"]
- pub COOL_LINT,
- "this lint has been replaced by `cooler_lint`"
-}
-
-fn main() {}
diff --git a/src/tools/clippy/tests/ui-internal/default_deprecation_reason.stderr b/src/tools/clippy/tests/ui-internal/default_deprecation_reason.stderr
deleted file mode 100644
index 3b7c747c23f41..0000000000000
--- a/src/tools/clippy/tests/ui-internal/default_deprecation_reason.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: the lint `COOL_LINT_DEFAULT` has the default deprecation reason
- --> tests/ui-internal/default_deprecation_reason.rs:8:1
- |
-LL | / declare_deprecated_lint! {
-LL | | /// ### What it does
-LL | | /// Nothing. This lint has been deprecated.
-LL | | ///
-... |
-LL | | "default deprecation note"
-LL | | }
- | |_^
- |
-note: the lint level is defined here
- --> tests/ui-internal/default_deprecation_reason.rs:1:9
- |
-LL | #![deny(clippy::internal)]
- | ^^^^^^^^^^^^^^^^
- = note: `#[deny(clippy::default_deprecation_reason)]` implied by `#[deny(clippy::internal)]`
- = note: this error originates in the macro `declare_deprecated_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 4375f324acaa6..858aab528a91a 100644
--- a/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -1,15 +1,19 @@
//@aux-build:../../ui/auxiliary/proc_macros.rs
#![rustfmt::skip]
#![feature(custom_inner_attributes)]
-#![allow(unused)]
-#![allow(clippy::let_and_return)]
-#![allow(clippy::redundant_closure_call)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(clippy::never_loop)]
-#![allow(clippy::needless_if)]
#![warn(clippy::excessive_nesting)]
-#![allow(clippy::collapsible_if, clippy::blocks_in_conditions)]
+#![allow(
+ unused,
+ clippy::let_and_return,
+ clippy::redundant_closure_call,
+ clippy::no_effect,
+ clippy::unnecessary_operation,
+ clippy::never_loop,
+ clippy::needless_if,
+ clippy::collapsible_if,
+ clippy::blocks_in_conditions,
+ clippy::single_match,
+)]
#[macro_use]
extern crate proc_macros;
diff --git a/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.stderr b/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
index dafcd4420554b..ccdaecdd48170 100644
--- a/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
+++ b/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
@@ -1,5 +1,5 @@
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:21:25
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:25:25
|
LL | let w = { 3 };
| ^^^^^
@@ -9,7 +9,7 @@ LL | let w = { 3 };
= help: to override `-D warnings` add `#[allow(clippy::excessive_nesting)]`
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:67:17
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:71:17
|
LL | / impl C {
LL | | pub fn c() {}
@@ -19,7 +19,7 @@ LL | | }
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:81:25
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:85:25
|
LL | let x = { 1 }; // not a warning, but cc is
| ^^^^^
@@ -27,7 +27,7 @@ LL | let x = { 1 }; // not a warning, but cc is
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:98:17
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:102:17
|
LL | / pub mod e {
LL | | pub mod f {}
@@ -37,7 +37,7 @@ LL | | } // not here
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:111:18
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:115:18
|
LL | a_but_not({{{{{{{{0}}}}}}}});
| ^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL | a_but_not({{{{{{{{0}}}}}}}});
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:112:12
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:116:12
|
LL | a.a({{{{{{{{{0}}}}}}}}});
| ^^^^^^^^^^^^^
@@ -53,7 +53,7 @@ LL | a.a({{{{{{{{{0}}}}}}}}});
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:113:12
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:117:12
|
LL | (0, {{{{{{{1}}}}}}});
| ^^^^^^^^^
@@ -61,7 +61,7 @@ LL | (0, {{{{{{{1}}}}}}});
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:118:25
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:122:25
|
LL | if true {
| _________________________^
@@ -74,7 +74,7 @@ LL | | }
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:130:29
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:134:29
|
LL | let z = (|| {
| _____________________________^
@@ -86,7 +86,7 @@ LL | | })();
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:149:13
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:153:13
|
LL | y += {{{{{5}}}}};
| ^^^^^
@@ -94,7 +94,7 @@ LL | y += {{{{{5}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:150:20
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:154:20
|
LL | let z = y + {{{{{{{{{5}}}}}}}}};
| ^^^^^^^^^^^^^
@@ -102,7 +102,7 @@ LL | let z = y + {{{{{{{{{5}}}}}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:151:12
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:155:12
|
LL | [0, {{{{{{{{{{0}}}}}}}}}}];
| ^^^^^^^^^^^^^^^
@@ -110,7 +110,7 @@ LL | [0, {{{{{{{{{{0}}}}}}}}}}];
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:152:25
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:156:25
|
LL | let mut xx = [0; {{{{{{{{100}}}}}}}}];
| ^^^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL | let mut xx = [0; {{{{{{{{100}}}}}}}}];
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:153:11
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:157:11
|
LL | xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -126,7 +126,7 @@ LL | xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:154:13
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:158:13
|
LL | &mut {{{{{{{{{{y}}}}}}}}}};
| ^^^^^^^^^^^^^^^
@@ -134,7 +134,7 @@ LL | &mut {{{{{{{{{{y}}}}}}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:156:17
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:17
|
LL | for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
| ^^^^
@@ -142,7 +142,7 @@ LL | for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:156:28
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:28
|
LL | for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
| ^^^^^^^^^^
@@ -150,7 +150,7 @@ LL | for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:158:28
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:28
|
LL | while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
| ^^^^^^^^^^^^^
@@ -158,7 +158,7 @@ LL | while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:158:48
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:48
|
LL | while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
| ^^^^^^^^
@@ -166,7 +166,7 @@ LL | while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:14
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:14
|
LL | while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
| ^^^^^^^^^^^^^^
@@ -174,7 +174,7 @@ LL | while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:35
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:35
|
LL | while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
| ^^^^^^^^^^^^
@@ -182,7 +182,7 @@ LL | while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:23
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:166:23
|
LL | let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -190,7 +190,7 @@ LL | let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:8
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:8
|
LL | {{{{1;}}}}..{{{{{{3}}}}}};
| ^^^^
@@ -198,7 +198,7 @@ LL | {{{{1;}}}}..{{{{{{3}}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:20
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:20
|
LL | {{{{1;}}}}..{{{{{{3}}}}}};
| ^^^^^^^
@@ -206,7 +206,7 @@ LL | {{{{1;}}}}..{{{{{{3}}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:165:8
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:169:8
|
LL | {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
| ^^^^
@@ -214,7 +214,7 @@ LL | {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:165:21
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:169:21
|
LL | {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -222,7 +222,7 @@ LL | {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:166:10
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:170:10
|
LL | ..{{{{{{{5}}}}}}};
| ^^^^^^^^^
@@ -230,7 +230,7 @@ LL | ..{{{{{{{5}}}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:167:11
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:171:11
|
LL | ..={{{{{3}}}}};
| ^^^^^
@@ -238,7 +238,7 @@ LL | ..={{{{{3}}}}};
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:8
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:172:8
|
LL | {{{{{1;}}}}}..;
| ^^^^^^
@@ -246,7 +246,7 @@ LL | {{{{{1;}}}}}..;
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:170:20
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:174:20
|
LL | loop { break {{{{1}}}} };
| ^^^^^
@@ -254,7 +254,7 @@ LL | loop { break {{{{1}}}} };
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:171:13
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:175:13
|
LL | loop {{{{{{}}}}}}
| ^^^^^^
@@ -262,7 +262,7 @@ LL | loop {{{{{{}}}}}}
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:173:14
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:177:14
|
LL | match {{{{{{true}}}}}} {
| ^^^^^^^^^^
@@ -270,7 +270,7 @@ LL | match {{{{{{true}}}}}} {
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:174:20
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:178:20
|
LL | true => {{{{}}}},
| ^^
@@ -278,7 +278,7 @@ LL | true => {{{{}}}},
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:175:21
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:179:21
|
LL | false => {{{{}}}},
| ^^
@@ -286,7 +286,7 @@ LL | false => {{{{}}}},
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:181:17
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:185:17
|
LL | / {
LL | | println!("warning! :)");
@@ -296,7 +296,7 @@ LL | | }
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:190:28
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:194:28
|
LL | async fn c() -> u32 {{{{{{{0}}}}}}}
| ^^^^^^^^^
@@ -304,7 +304,7 @@ LL | async fn c() -> u32 {{{{{{{0}}}}}}}
= help: try refactoring your code to minimize nesting
error: this block is too nested
- --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:196:8
+ --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:200:8
|
LL | {{{{b().await}}}};
| ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.stderr b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.stderr
index 41d5afd3efeca..320578bfabce0 100644
--- a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -1,11 +1,15 @@
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui-toml/unwrap_used/unwrap_used.rs:38:17
|
LL | let _ = boxed_slice.get(1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `-D clippy::get-unwrap` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::get_unwrap)]`
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &boxed_slice[1];
+ | ~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:38:17
@@ -18,11 +22,16 @@ LL | let _ = boxed_slice.get(1).unwrap();
= note: `-D clippy::unwrap-used` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::unwrap_used)]`
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui-toml/unwrap_used/unwrap_used.rs:39:17
|
LL | let _ = some_slice.get(0).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_slice[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_slice[0];
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:39:17
@@ -33,11 +42,16 @@ LL | let _ = some_slice.get(0).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a Vec
--> tests/ui-toml/unwrap_used/unwrap_used.rs:40:17
|
LL | let _ = some_vec.get(0).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vec[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_vec[0];
+ | ~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:40:17
@@ -48,11 +62,16 @@ LL | let _ = some_vec.get(0).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a VecDeque
--> tests/ui-toml/unwrap_used/unwrap_used.rs:41:17
|
LL | let _ = some_vecdeque.get(0).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vecdeque[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_vecdeque[0];
+ | ~~~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:41:17
@@ -63,11 +82,16 @@ LL | let _ = some_vecdeque.get(0).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a HashMap
--> tests/ui-toml/unwrap_used/unwrap_used.rs:42:17
|
LL | let _ = some_hashmap.get(&1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_hashmap[&1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_hashmap[&1];
+ | ~~~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:42:17
@@ -78,11 +102,16 @@ LL | let _ = some_hashmap.get(&1).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a BTreeMap
--> tests/ui-toml/unwrap_used/unwrap_used.rs:43:17
|
LL | let _ = some_btreemap.get(&1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_btreemap[&1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_btreemap[&1];
+ | ~~~~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:43:17
@@ -93,11 +122,16 @@ LL | let _ = some_btreemap.get(&1).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui-toml/unwrap_used/unwrap_used.rs:47:21
|
LL | let _: u8 = *boxed_slice.get(1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _: u8 = boxed_slice[1];
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:47:22
@@ -108,11 +142,16 @@ LL | let _: u8 = *boxed_slice.get(1).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
--> tests/ui-toml/unwrap_used/unwrap_used.rs:52:9
|
LL | *boxed_slice.get_mut(0).unwrap() = 1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | boxed_slice[0] = 1;
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:52:10
@@ -123,11 +162,16 @@ LL | *boxed_slice.get_mut(0).unwrap() = 1;
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
--> tests/ui-toml/unwrap_used/unwrap_used.rs:53:9
|
LL | *some_slice.get_mut(0).unwrap() = 1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_slice[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | some_slice[0] = 1;
+ | ~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:53:10
@@ -138,11 +182,16 @@ LL | *some_slice.get_mut(0).unwrap() = 1;
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a Vec
--> tests/ui-toml/unwrap_used/unwrap_used.rs:54:9
|
LL | *some_vec.get_mut(0).unwrap() = 1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | some_vec[0] = 1;
+ | ~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:54:10
@@ -153,11 +202,16 @@ LL | *some_vec.get_mut(0).unwrap() = 1;
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a VecDeque
--> tests/ui-toml/unwrap_used/unwrap_used.rs:55:9
|
LL | *some_vecdeque.get_mut(0).unwrap() = 1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vecdeque[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | some_vecdeque[0] = 1;
+ | ~~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:55:10
@@ -168,11 +222,16 @@ LL | *some_vecdeque.get_mut(0).unwrap() = 1;
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a Vec
--> tests/ui-toml/unwrap_used/unwrap_used.rs:67:17
|
LL | let _ = some_vec.get(0..1).unwrap().to_vec();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = some_vec[0..1].to_vec();
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:67:17
@@ -183,11 +242,16 @@ LL | let _ = some_vec.get(0..1).unwrap().to_vec();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a Vec
--> tests/ui-toml/unwrap_used/unwrap_used.rs:68:17
|
LL | let _ = some_vec.get_mut(0..1).unwrap().to_vec();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = some_vec[0..1].to_vec();
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui-toml/unwrap_used/unwrap_used.rs:68:17
@@ -198,17 +262,27 @@ LL | let _ = some_vec.get_mut(0..1).unwrap().to_vec();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui-toml/unwrap_used/unwrap_used.rs:75:13
|
LL | let _ = boxed_slice.get(1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &boxed_slice[1];
+ | ~~~~~~~~~~~~~~~
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui-toml/unwrap_used/unwrap_used.rs:93:17
|
LL | let _ = Box::new([0]).get(1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&Box::new([0])[1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &Box::new([0])[1];
+ | ~~~~~~~~~~~~~~~~~
error: aborting due to 28 previous errors
diff --git a/src/tools/clippy/tests/ui/assigning_clones.fixed b/src/tools/clippy/tests/ui/assigning_clones.fixed
index 60f6a385fc506..b376d55a40250 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.fixed
+++ b/src/tools/clippy/tests/ui/assigning_clones.fixed
@@ -3,6 +3,7 @@
#![allow(clippy::ptr_arg)] // https://github.com/rust-lang/rust-clippy/issues/10612
#![allow(clippy::needless_late_init)]
#![allow(clippy::box_collection)]
+#![allow(clippy::boxed_local)]
#![warn(clippy::assigning_clones)]
use std::borrow::ToOwned;
@@ -182,6 +183,31 @@ impl Clone for AvoidRecursiveCloneFrom {
}
}
+// Deref handling
+fn clone_into_deref_method(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
+ (*a).clone_from(&b);
+}
+
+fn clone_into_deref_with_clone_method(mut a: DerefWrapperWithClone<HasCloneFrom>, b: HasCloneFrom) {
+ (*a).clone_from(&b);
+}
+
+fn clone_into_box_method(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
+ (*a).clone_from(&b);
+}
+
+fn clone_into_self_deref_method(a: &mut DerefWrapperWithClone<HasCloneFrom>, b: DerefWrapperWithClone<HasCloneFrom>) {
+ a.clone_from(&b);
+}
+
+fn clone_into_deref_function(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
+ Clone::clone_from(&mut *a, &b);
+}
+
+fn clone_into_box_function(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
+ Clone::clone_from(&mut *a, &b);
+}
+
// ToOwned
fn owned_method_mut_ref(mut_string: &mut String, ref_str: &str) {
ref_str.clone_into(mut_string);
@@ -328,3 +354,45 @@ mod borrowck_conflicts {
path = path.components().as_path().to_owned();
}
}
+
+struct DerefWrapper<T>(T);
+
+impl<T> Deref for DerefWrapper<T> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl<T> DerefMut for DerefWrapper<T> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+struct DerefWrapperWithClone<T>(T);
+
+impl<T> Deref for DerefWrapperWithClone<T> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl<T> DerefMut for DerefWrapperWithClone<T> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+impl<T: Clone> Clone for DerefWrapperWithClone<T> {
+ fn clone(&self) -> Self {
+ Self(self.0.clone())
+ }
+
+ fn clone_from(&mut self, source: &Self) {
+ *self = Self(source.0.clone());
+ }
+}
diff --git a/src/tools/clippy/tests/ui/assigning_clones.rs b/src/tools/clippy/tests/ui/assigning_clones.rs
index 6eb85be511a89..11a5d4459c350 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.rs
+++ b/src/tools/clippy/tests/ui/assigning_clones.rs
@@ -3,6 +3,7 @@
#![allow(clippy::ptr_arg)] // https://github.com/rust-lang/rust-clippy/issues/10612
#![allow(clippy::needless_late_init)]
#![allow(clippy::box_collection)]
+#![allow(clippy::boxed_local)]
#![warn(clippy::assigning_clones)]
use std::borrow::ToOwned;
@@ -182,6 +183,31 @@ impl Clone for AvoidRecursiveCloneFrom {
}
}
+// Deref handling
+fn clone_into_deref_method(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
+ *a = b.clone();
+}
+
+fn clone_into_deref_with_clone_method(mut a: DerefWrapperWithClone<HasCloneFrom>, b: HasCloneFrom) {
+ *a = b.clone();
+}
+
+fn clone_into_box_method(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
+ *a = b.clone();
+}
+
+fn clone_into_self_deref_method(a: &mut DerefWrapperWithClone<HasCloneFrom>, b: DerefWrapperWithClone<HasCloneFrom>) {
+ *a = b.clone();
+}
+
+fn clone_into_deref_function(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
+ *a = Clone::clone(&b);
+}
+
+fn clone_into_box_function(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
+ *a = Clone::clone(&b);
+}
+
// ToOwned
fn owned_method_mut_ref(mut_string: &mut String, ref_str: &str) {
*mut_string = ref_str.to_owned();
@@ -328,3 +354,45 @@ mod borrowck_conflicts {
path = path.components().as_path().to_owned();
}
}
+
+struct DerefWrapper<T>(T);
+
+impl<T> Deref for DerefWrapper<T> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl<T> DerefMut for DerefWrapper<T> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+struct DerefWrapperWithClone<T>(T);
+
+impl<T> Deref for DerefWrapperWithClone<T> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl<T> DerefMut for DerefWrapperWithClone<T> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+impl<T: Clone> Clone for DerefWrapperWithClone<T> {
+ fn clone(&self) -> Self {
+ Self(self.0.clone())
+ }
+
+ fn clone_from(&mut self, source: &Self) {
+ *self = Self(source.0.clone());
+ }
+}
diff --git a/src/tools/clippy/tests/ui/assigning_clones.stderr b/src/tools/clippy/tests/ui/assigning_clones.stderr
index a68516376abb5..19724a6d4ec2f 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.stderr
+++ b/src/tools/clippy/tests/ui/assigning_clones.stderr
@@ -1,5 +1,5 @@
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:24:5
+ --> tests/ui/assigning_clones.rs:25:5
|
LL | *mut_thing = value_thing.clone();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(&value_thing)`
@@ -8,142 +8,178 @@ LL | *mut_thing = value_thing.clone();
= help: to override `-D warnings` add `#[allow(clippy::assigning_clones)]`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:28:5
+ --> tests/ui/assigning_clones.rs:29:5
|
LL | *mut_thing = ref_thing.clone();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:32:5
+ --> tests/ui/assigning_clones.rs:33:5
|
LL | mut_thing = ref_thing.clone();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:36:5
+ --> tests/ui/assigning_clones.rs:37:5
|
LL | *mut_thing = Clone::clone(ref_thing);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:40:5
+ --> tests/ui/assigning_clones.rs:41:5
|
LL | mut_thing = Clone::clone(ref_thing);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut mut_thing, ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:44:5
+ --> tests/ui/assigning_clones.rs:45:5
|
LL | *mut_thing = Clone::clone(ref_thing);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:48:5
+ --> tests/ui/assigning_clones.rs:49:5
|
LL | *mut_thing = HasCloneFrom::clone(ref_thing);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:52:5
+ --> tests/ui/assigning_clones.rs:53:5
|
LL | *mut_thing = <HasCloneFrom as Clone>::clone(ref_thing);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:57:5
+ --> tests/ui/assigning_clones.rs:58:5
|
LL | *(mut_thing + &mut HasCloneFrom) = ref_thing.clone();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `(mut_thing + &mut HasCloneFrom).clone_from(ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:62:5
+ --> tests/ui/assigning_clones.rs:63:5
|
LL | *mut_thing = (ref_thing + ref_thing).clone();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing + ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:67:5
+ --> tests/ui/assigning_clones.rs:68:5
|
LL | s = format!("{} {}", "hello", "world").clone();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `s.clone_from(&format!("{} {}", "hello", "world"))`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:72:5
+ --> tests/ui/assigning_clones.rs:73:5
|
LL | s = Clone::clone(&format!("{} {}", "hello", "world"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut s, &format!("{} {}", "hello", "world"))`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:78:9
+ --> tests/ui/assigning_clones.rs:79:9
|
LL | a = b.clone();
| ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:149:5
+ --> tests/ui/assigning_clones.rs:150:5
|
LL | a = b.clone();
| ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:156:5
+ --> tests/ui/assigning_clones.rs:157:5
|
LL | a = b.clone();
| ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:157:5
+ --> tests/ui/assigning_clones.rs:158:5
|
LL | a = c.to_owned();
| ^^^^^^^^^^^^^^^^ help: use `clone_into()`: `c.clone_into(&mut a)`
+error: assigning the result of `Clone::clone()` may be inefficient
+ --> tests/ui/assigning_clones.rs:188:5
+ |
+LL | *a = b.clone();
+ | ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+ --> tests/ui/assigning_clones.rs:192:5
+ |
+LL | *a = b.clone();
+ | ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+ --> tests/ui/assigning_clones.rs:196:5
+ |
+LL | *a = b.clone();
+ | ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+ --> tests/ui/assigning_clones.rs:200:5
+ |
+LL | *a = b.clone();
+ | ^^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+ --> tests/ui/assigning_clones.rs:204:5
+ |
+LL | *a = Clone::clone(&b);
+ | ^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut *a, &b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+ --> tests/ui/assigning_clones.rs:208:5
+ |
+LL | *a = Clone::clone(&b);
+ | ^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut *a, &b)`
+
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:187:5
+ --> tests/ui/assigning_clones.rs:213:5
|
LL | *mut_string = ref_str.to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(mut_string)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:191:5
+ --> tests/ui/assigning_clones.rs:217:5
|
LL | mut_string = ref_str.to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut mut_string)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:212:5
+ --> tests/ui/assigning_clones.rs:238:5
|
LL | **mut_box_string = ref_str.to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut (*mut_box_string))`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:216:5
+ --> tests/ui/assigning_clones.rs:242:5
|
LL | **mut_box_string = ref_str.to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut (*mut_box_string))`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:220:5
+ --> tests/ui/assigning_clones.rs:246:5
|
LL | *mut_thing = ToOwned::to_owned(ref_str);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(ref_str, mut_thing)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:224:5
+ --> tests/ui/assigning_clones.rs:250:5
|
LL | mut_thing = ToOwned::to_owned(ref_str);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(ref_str, &mut mut_thing)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:229:5
+ --> tests/ui/assigning_clones.rs:255:5
|
LL | s = format!("{} {}", "hello", "world").to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `format!("{} {}", "hello", "world").clone_into(&mut s)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:234:5
+ --> tests/ui/assigning_clones.rs:260:5
|
LL | s = ToOwned::to_owned(&format!("{} {}", "hello", "world"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(&format!("{} {}", "hello", "world"), &mut s)`
-error: aborting due to 24 previous errors
+error: aborting due to 30 previous errors
diff --git a/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.stderr b/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.stderr
index b15857c325ae5..2adaecc96d6a9 100644
--- a/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.stderr
+++ b/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.stderr
@@ -9,7 +9,7 @@ note: the lint level is defined here
|
LL | #![deny(clippy::bind_instead_of_map)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: try
+help: use `map` instead
|
LL | let _ = Some("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
| ~~~ ~ ~~~~~~~
@@ -20,7 +20,7 @@ error: using `Result.and_then(|x| Ok(y))`, which is more succinctly expressed as
LL | let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Ok(0) } else { Ok(s.len()) });
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
-help: try
+help: use `map` instead
|
LL | let _ = Ok::<_, ()>("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
| ~~~ ~ ~~~~~~~
@@ -31,7 +31,7 @@ error: using `Result.or_else(|x| Err(y))`, which is more succinctly expressed as
LL | let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Err(s.len() + 20) } else { Err(s.len()) });
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
-help: try
+help: use `map_err` instead
|
LL | let _ = Err::<(), _>("42").map_err(|s| if s.len() < 42 { s.len() + 20 } else { s.len() });
| ~~~~~~~ ~~~~~~~~~~~~ ~~~~~~~
@@ -48,7 +48,7 @@ LL | | }
LL | | });
| |______^
|
-help: try
+help: use `map` instead
|
LL ~ Some("42").map(|s| {
LL | if {
@@ -82,7 +82,7 @@ error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed
LL | let _ = Some("").and_then(|s| if s.len() == 20 { Some(m!()) } else { Some(Some(20)) });
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
-help: try
+help: use `map` instead
|
LL | let _ = Some("").map(|s| if s.len() == 20 { m!() } else { Some(20) });
| ~~~ ~~~~ ~~~~~~~~
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3717.stderr b/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
index 01627ff5b94b9..4b4618ee1bbd0 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
@@ -9,14 +9,13 @@ note: the lint level is defined here
|
LL | #![deny(clippy::implicit_hasher)]
| ^^^^^^^^^^^^^^^^^^^^^^^
-help: consider adding a type parameter
+help: add a type parameter for `BuildHasher`
|
-LL | pub fn ice_3717<S: ::std::hash::BuildHasher + Default>(_: &HashSet<usize, S>) {
- | +++++++++++++++++++++++++++++++++++++++ ~~~~~~~~~~~~~~~~~
-help: ...and use generic constructor
+LL ~ pub fn ice_3717<S: ::std::hash::BuildHasher + Default>(_: &HashSet<usize, S>) {
+LL |
+LL | let _ = [0u8; 0];
+LL ~ let _: HashSet<usize> = HashSet::default();
|
-LL | let _: HashSet<usize> = HashSet::default();
- | ~~~~~~~~~~~~~~~~~~
error: aborting due to 1 previous error
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6254.rs b/src/tools/clippy/tests/ui/crashes/ice-6254.rs
index 8af60890390e7..aaca32ab2d93e 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6254.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6254.rs
@@ -2,7 +2,8 @@
// panicked at 'assertion failed: rows.iter().all(|r| r.len() == v.len())',
// compiler/rustc_mir_build/src/thir/pattern/_match.rs:2030:5
-#[allow(clippy::derive_partial_eq_without_eq)]
+#![allow(clippy::derive_partial_eq_without_eq, clippy::single_match)]
+
#[derive(PartialEq)]
struct Foo(i32);
const FOO_REF_REF: &&Foo = &&Foo(42);
diff --git a/src/tools/clippy/tests/ui/create_dir.stderr b/src/tools/clippy/tests/ui/create_dir.stderr
index 9c6e640ca784c..ab51705bb55a5 100644
--- a/src/tools/clippy/tests/ui/create_dir.stderr
+++ b/src/tools/clippy/tests/ui/create_dir.stderr
@@ -2,16 +2,25 @@ error: calling `std::fs::create_dir` where there may be a better way
--> tests/ui/create_dir.rs:10:5
|
LL | std::fs::create_dir("foo");
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `create_dir_all("foo")`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `-D clippy::create-dir` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::create_dir)]`
+help: consider calling `std::fs::create_dir_all` instead
+ |
+LL | create_dir_all("foo");
+ | ~~~~~~~~~~~~~~~~~~~~~
error: calling `std::fs::create_dir` where there may be a better way
--> tests/ui/create_dir.rs:11:5
|
LL | std::fs::create_dir("bar").unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `create_dir_all("bar")`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider calling `std::fs::create_dir_all` instead
+ |
+LL | create_dir_all("bar").unwrap();
+ | ~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
diff --git a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.stderr b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.stderr
index 7d3c3f7c918e8..b3d74b9ff6173 100644
--- a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.stderr
+++ b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.stderr
@@ -81,7 +81,7 @@ error: the `dbg!` macro is intended as a debugging tool
--> tests/ui/dbg_macro/dbg_macro.rs:48:5
|
LL | dbg!();
- | ^^^^^^^
+ | ^^^^^^
|
help: remove the invocation before committing it to a version control system
|
@@ -136,7 +136,7 @@ error: the `dbg!` macro is intended as a debugging tool
--> tests/ui/dbg_macro/dbg_macro.rs:43:13
|
LL | dbg!();
- | ^^^^^^^
+ | ^^^^^^
...
LL | expand_to_dbg!();
| ---------------- in this macro invocation
diff --git a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.stderr b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
index 16e51f4742e34..b8e91906b9317 100644
--- a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
@@ -2,7 +2,7 @@ error: the `dbg!` macro is intended as a debugging tool
--> tests/ui/dbg_macro/auxiliary/submodule.rs:2:5
|
LL | dbg!();
- | ^^^^^^^
+ | ^^^^^^
|
= note: `-D clippy::dbg-macro` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::dbg_macro)]`
diff --git a/src/tools/clippy/tests/ui/deprecated.rs b/src/tools/clippy/tests/ui/deprecated.rs
index d3c34fb371674..5617db90a470a 100644
--- a/src/tools/clippy/tests/ui/deprecated.rs
+++ b/src/tools/clippy/tests/ui/deprecated.rs
@@ -2,23 +2,18 @@
// Use that command to update this file and do not edit by hand.
// Manual edits will be overwritten.
-#![warn(clippy::should_assert_eq)]
-#![warn(clippy::extend_from_slice)]
-#![warn(clippy::range_step_by_zero)]
-#![warn(clippy::unstable_as_slice)]
-#![warn(clippy::unstable_as_mut_slice)]
-#![warn(clippy::misaligned_transmute)]
-#![warn(clippy::assign_ops)]
-#![warn(clippy::if_let_redundant_pattern_matching)]
-#![warn(clippy::unsafe_vector_initialization)]
-#![warn(clippy::unused_collect)]
-#![warn(clippy::replace_consts)]
-#![warn(clippy::regex_macro)]
-#![warn(clippy::find_map)]
-#![warn(clippy::filter_map)]
-#![warn(clippy::pub_enum_variant_names)]
-#![warn(clippy::wrong_pub_self_convention)]
-#![warn(clippy::maybe_misused_cfg)]
-#![warn(clippy::mismatched_target_os)]
+#![warn(clippy::should_assert_eq)] //~ ERROR: lint `clippy::should_assert_eq`
+#![warn(clippy::extend_from_slice)] //~ ERROR: lint `clippy::extend_from_slice`
+#![warn(clippy::range_step_by_zero)] //~ ERROR: lint `clippy::range_step_by_zero`
+#![warn(clippy::unstable_as_slice)] //~ ERROR: lint `clippy::unstable_as_slice`
+#![warn(clippy::unstable_as_mut_slice)] //~ ERROR: lint `clippy::unstable_as_mut_slice`
+#![warn(clippy::misaligned_transmute)] //~ ERROR: lint `clippy::misaligned_transmute`
+#![warn(clippy::assign_ops)] //~ ERROR: lint `clippy::assign_ops`
+#![warn(clippy::unsafe_vector_initialization)] //~ ERROR: lint `clippy::unsafe_vector_initialization`
+#![warn(clippy::unused_collect)] //~ ERROR: lint `clippy::unused_collect`
+#![warn(clippy::replace_consts)] //~ ERROR: lint `clippy::replace_consts`
+#![warn(clippy::regex_macro)] //~ ERROR: lint `clippy::regex_macro`
+#![warn(clippy::pub_enum_variant_names)] //~ ERROR: lint `clippy::pub_enum_variant_names`
+#![warn(clippy::wrong_pub_self_convention)] //~ ERROR: lint `clippy::wrong_pub_self_convention`
fn main() {}
diff --git a/src/tools/clippy/tests/ui/deprecated.stderr b/src/tools/clippy/tests/ui/deprecated.stderr
index 49b90c70c06ef..b3e1646c8045b 100644
--- a/src/tools/clippy/tests/ui/deprecated.stderr
+++ b/src/tools/clippy/tests/ui/deprecated.stderr
@@ -1,4 +1,4 @@
-error: lint `clippy::should_assert_eq` has been removed: `assert!()` will be more flexible with RFC 2011
+error: lint `clippy::should_assert_eq` has been removed: `assert!(a == b)` can now print the values the same way `assert_eq!(a, b) can
--> tests/ui/deprecated.rs:5:9
|
LL | #![warn(clippy::should_assert_eq)]
@@ -7,107 +7,77 @@ LL | #![warn(clippy::should_assert_eq)]
= note: `-D renamed-and-removed-lints` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(renamed_and_removed_lints)]`
-error: lint `clippy::extend_from_slice` has been removed: `.extend_from_slice(_)` is a faster way to extend a Vec by a slice
+error: lint `clippy::extend_from_slice` has been removed: `Vec::extend_from_slice` is no longer faster than `Vec::extend` due to specialization
--> tests/ui/deprecated.rs:6:9
|
LL | #![warn(clippy::extend_from_slice)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::range_step_by_zero` has been removed: `iterator.step_by(0)` panics nowadays
+error: lint `clippy::range_step_by_zero` has been removed: `Iterator::step_by(0)` now panics and is no longer an infinite iterator
--> tests/ui/deprecated.rs:7:9
|
LL | #![warn(clippy::range_step_by_zero)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
+error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` is now stable
--> tests/ui/deprecated.rs:8:9
|
LL | #![warn(clippy::unstable_as_slice)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been stabilized in 1.7
+error: lint `clippy::unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` is now stable
--> tests/ui/deprecated.rs:9:9
|
LL | #![warn(clippy::unstable_as_mut_slice)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::misaligned_transmute` has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr
+error: lint `clippy::misaligned_transmute` has been removed: split into `clippy::cast_ptr_alignment` and `clippy::transmute_ptr_to_ptr`
--> tests/ui/deprecated.rs:10:9
|
LL | #![warn(clippy::misaligned_transmute)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::assign_ops` has been removed: using compound assignment operators (e.g., `+=`) is harmless
+error: lint `clippy::assign_ops` has been removed: compound operators are harmless and linting on them is not in scope for clippy
--> tests/ui/deprecated.rs:11:9
|
LL | #![warn(clippy::assign_ops)]
| ^^^^^^^^^^^^^^^^^^
-error: lint `clippy::if_let_redundant_pattern_matching` has been removed: this lint has been changed to redundant_pattern_matching
+error: lint `clippy::unsafe_vector_initialization` has been removed: the suggested alternative could be substantially slower
--> tests/ui/deprecated.rs:12:9
|
-LL | #![warn(clippy::if_let_redundant_pattern_matching)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: lint `clippy::unsafe_vector_initialization` has been removed: the replacement suggested by this lint had substantially different behavior
- --> tests/ui/deprecated.rs:13:9
- |
LL | #![warn(clippy::unsafe_vector_initialization)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::unused_collect` has been removed: `collect` has been marked as #[must_use] in rustc and that covers all cases of this lint
- --> tests/ui/deprecated.rs:14:9
+error: lint `clippy::unused_collect` has been removed: `Iterator::collect` is now marked as `#[must_use]`
+ --> tests/ui/deprecated.rs:13:9
|
LL | #![warn(clippy::unused_collect)]
| ^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::replace_consts` has been removed: associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants
- --> tests/ui/deprecated.rs:15:9
+error: lint `clippy::replace_consts` has been removed: `min_value` and `max_value` are now deprecated
+ --> tests/ui/deprecated.rs:14:9
|
LL | #![warn(clippy::replace_consts)]
| ^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::regex_macro` has been removed: the regex! macro has been removed from the regex crate in 2018
- --> tests/ui/deprecated.rs:16:9
+error: lint `clippy::regex_macro` has been removed: the `regex!` macro was removed from the regex crate in 2018
+ --> tests/ui/deprecated.rs:15:9
|
LL | #![warn(clippy::regex_macro)]
| ^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::find_map` has been removed: this lint has been replaced by `manual_find_map`, a more specific lint
- --> tests/ui/deprecated.rs:17:9
- |
-LL | #![warn(clippy::find_map)]
- | ^^^^^^^^^^^^^^^^
-
-error: lint `clippy::filter_map` has been removed: this lint has been replaced by `manual_filter_map`, a more specific lint
- --> tests/ui/deprecated.rs:18:9
- |
-LL | #![warn(clippy::filter_map)]
- | ^^^^^^^^^^^^^^^^^^
-
-error: lint `clippy::pub_enum_variant_names` has been removed: set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items
- --> tests/ui/deprecated.rs:19:9
+error: lint `clippy::pub_enum_variant_names` has been removed: `clippy::enum_variant_names` now covers this case via the `avoid-breaking-exported-api` config
+ --> tests/ui/deprecated.rs:16:9
|
LL | #![warn(clippy::pub_enum_variant_names)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::wrong_pub_self_convention` has been removed: set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items
- --> tests/ui/deprecated.rs:20:9
+error: lint `clippy::wrong_pub_self_convention` has been removed: `clippy::wrong_self_convention` now covers this case via the `avoid-breaking-exported-api` config
+ --> tests/ui/deprecated.rs:17:9
|
LL | #![warn(clippy::wrong_pub_self_convention)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: lint `clippy::maybe_misused_cfg` has been removed: this lint has been replaced by `unexpected_cfgs`
- --> tests/ui/deprecated.rs:21:9
- |
-LL | #![warn(clippy::maybe_misused_cfg)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: lint `clippy::mismatched_target_os` has been removed: this lint has been replaced by `unexpected_cfgs`
- --> tests/ui/deprecated.rs:22:9
- |
-LL | #![warn(clippy::mismatched_target_os)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 18 previous errors
+error: aborting due to 13 previous errors
diff --git a/src/tools/clippy/tests/ui/deprecated_old.rs b/src/tools/clippy/tests/ui/deprecated_old.rs
deleted file mode 100644
index 356ad5f060b6c..0000000000000
--- a/src/tools/clippy/tests/ui/deprecated_old.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#[warn(unstable_as_slice)]
-//~^ ERROR: lint `unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized
-//~| NOTE: `-D renamed-and-removed-lints` implied by `-D warnings`
-#[warn(unstable_as_mut_slice)]
-//~^ ERROR: lint `unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been st
-#[warn(misaligned_transmute)]
-//~^ ERROR: lint `misaligned_transmute` has been removed: this lint has been split into ca
-
-fn main() {}
diff --git a/src/tools/clippy/tests/ui/deprecated_old.stderr b/src/tools/clippy/tests/ui/deprecated_old.stderr
deleted file mode 100644
index 685bca64df59a..0000000000000
--- a/src/tools/clippy/tests/ui/deprecated_old.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error: lint `unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
- --> tests/ui/deprecated_old.rs:1:8
- |
-LL | #[warn(unstable_as_slice)]
- | ^^^^^^^^^^^^^^^^^
- |
- = note: `-D renamed-and-removed-lints` implied by `-D warnings`
- = help: to override `-D warnings` add `#[allow(renamed_and_removed_lints)]`
-
-error: lint `unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been stabilized in 1.7
- --> tests/ui/deprecated_old.rs:4:8
- |
-LL | #[warn(unstable_as_mut_slice)]
- | ^^^^^^^^^^^^^^^^^^^^^
-
-error: lint `misaligned_transmute` has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr
- --> tests/ui/deprecated_old.rs:6:8
- |
-LL | #[warn(misaligned_transmute)]
- | ^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
diff --git a/src/tools/clippy/tests/ui/deref_by_slicing.fixed b/src/tools/clippy/tests/ui/deref_by_slicing.fixed
index a3c2e84566681..87b33b1f881d8 100644
--- a/src/tools/clippy/tests/ui/deref_by_slicing.fixed
+++ b/src/tools/clippy/tests/ui/deref_by_slicing.fixed
@@ -25,4 +25,8 @@ fn main() {
let bytes: &[u8] = &[];
let _ = (&*bytes).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
+
+ // issue 12751
+ let a = &mut [1, 2, 3][..];
+ let _ = &*a;
}
diff --git a/src/tools/clippy/tests/ui/deref_by_slicing.rs b/src/tools/clippy/tests/ui/deref_by_slicing.rs
index 5b4a73712ee6e..8d8882a1781e8 100644
--- a/src/tools/clippy/tests/ui/deref_by_slicing.rs
+++ b/src/tools/clippy/tests/ui/deref_by_slicing.rs
@@ -25,4 +25,8 @@ fn main() {
let bytes: &[u8] = &[];
let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
+
+ // issue 12751
+ let a = &mut [1, 2, 3][..];
+ let _ = &a[..];
}
diff --git a/src/tools/clippy/tests/ui/deref_by_slicing.stderr b/src/tools/clippy/tests/ui/deref_by_slicing.stderr
index 17b00610899d6..ceb9ab6db73dc 100644
--- a/src/tools/clippy/tests/ui/deref_by_slicing.stderr
+++ b/src/tools/clippy/tests/ui/deref_by_slicing.stderr
@@ -55,5 +55,11 @@ error: slicing when dereferencing would work
LL | let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
| ^^^^^^^^^^^^ help: reborrow the original value instead: `(&*bytes)`
-error: aborting due to 9 previous errors
+error: slicing when dereferencing would work
+ --> tests/ui/deref_by_slicing.rs:31:13
+ |
+LL | let _ = &a[..];
+ | ^^^^^^ help: reborrow the original value instead: `&*a`
+
+error: aborting due to 10 previous errors
diff --git a/src/tools/clippy/tests/ui/doc/footnote_issue_13183.rs b/src/tools/clippy/tests/ui/doc/footnote_issue_13183.rs
new file mode 100644
index 0000000000000..a18b4c3ac539b
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/footnote_issue_13183.rs
@@ -0,0 +1,10 @@
+// This is a regression test for <https://github.com/rust-lang/rust-clippy/issues/13183>.
+// It should not warn on missing backticks on footnote references.
+
+#![warn(clippy::doc_markdown)]
+// Should not warn!
+//! Here's a footnote[^example_footnote_identifier]
+//!
+//! [^example_footnote_identifier]: This is merely an example.
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/empty_drop.stderr b/src/tools/clippy/tests/ui/empty_drop.stderr
index 4223ddaf3fba5..d4d020fec30cf 100644
--- a/src/tools/clippy/tests/ui/empty_drop.stderr
+++ b/src/tools/clippy/tests/ui/empty_drop.stderr
@@ -4,10 +4,11 @@ error: empty drop implementation
LL | / impl Drop for Foo {
LL | | fn drop(&mut self) {}
LL | | }
- | |_^ help: try removing this impl
+ | |_^
|
= note: `-D clippy::empty-drop` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::empty_drop)]`
+ = help: try removing this impl
error: empty drop implementation
--> tests/ui/empty_drop.rs:23:1
@@ -17,7 +18,9 @@ LL | | fn drop(&mut self) {
LL | | {}
LL | | }
LL | | }
- | |_^ help: try removing this impl
+ | |_^
+ |
+ = help: try removing this impl
error: aborting due to 2 previous errors
diff --git a/src/tools/clippy/tests/ui/eta.fixed b/src/tools/clippy/tests/ui/eta.fixed
index 7126f2799455f..ca422ee29c104 100644
--- a/src/tools/clippy/tests/ui/eta.fixed
+++ b/src/tools/clippy/tests/ui/eta.fixed
@@ -2,6 +2,7 @@
#![allow(unused)]
#![allow(
clippy::needless_borrow,
+ clippy::needless_option_as_deref,
clippy::needless_pass_by_value,
clippy::no_effect,
clippy::option_map_unit_fn,
@@ -482,3 +483,19 @@ mod issue_12853 {
x();
}
}
+
+mod issue_13073 {
+ fn get_default() -> Option<&'static str> {
+ Some("foo")
+ }
+
+ pub fn foo() {
+ // shouldn't lint
+ let bind: Option<String> = None;
+ let _field = bind.as_deref().or_else(|| get_default()).unwrap();
+ let bind: Option<&'static str> = None;
+ let _field = bind.as_deref().or_else(|| get_default()).unwrap();
+ // should lint
+ let _field = bind.or_else(get_default).unwrap();
+ }
+}
diff --git a/src/tools/clippy/tests/ui/eta.rs b/src/tools/clippy/tests/ui/eta.rs
index 0787abf5f3e37..c0db91c03ef45 100644
--- a/src/tools/clippy/tests/ui/eta.rs
+++ b/src/tools/clippy/tests/ui/eta.rs
@@ -2,6 +2,7 @@
#![allow(unused)]
#![allow(
clippy::needless_borrow,
+ clippy::needless_option_as_deref,
clippy::needless_pass_by_value,
clippy::no_effect,
clippy::option_map_unit_fn,
@@ -482,3 +483,19 @@ mod issue_12853 {
x();
}
}
+
+mod issue_13073 {
+ fn get_default() -> Option<&'static str> {
+ Some("foo")
+ }
+
+ pub fn foo() {
+ // shouldn't lint
+ let bind: Option<String> = None;
+ let _field = bind.as_deref().or_else(|| get_default()).unwrap();
+ let bind: Option<&'static str> = None;
+ let _field = bind.as_deref().or_else(|| get_default()).unwrap();
+ // should lint
+ let _field = bind.or_else(|| get_default()).unwrap();
+ }
+}
diff --git a/src/tools/clippy/tests/ui/eta.stderr b/src/tools/clippy/tests/ui/eta.stderr
index c757601042f16..5540261fc5744 100644
--- a/src/tools/clippy/tests/ui/eta.stderr
+++ b/src/tools/clippy/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
error: redundant closure
- --> tests/ui/eta.rs:29:27
+ --> tests/ui/eta.rs:30:27
|
LL | let a = Some(1u8).map(|a| foo(a));
| ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
@@ -8,31 +8,31 @@ LL | let a = Some(1u8).map(|a| foo(a));
= help: to override `-D warnings` add `#[allow(clippy::redundant_closure)]`
error: redundant closure
- --> tests/ui/eta.rs:33:40
+ --> tests/ui/eta.rs:34:40
|
LL | let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
| ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
error: redundant closure
- --> tests/ui/eta.rs:34:35
+ --> tests/ui/eta.rs:35:35
|
LL | let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
| ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
error: redundant closure
- --> tests/ui/eta.rs:35:26
+ --> tests/ui/eta.rs:36:26
|
LL | all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
| ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
error: redundant closure
- --> tests/ui/eta.rs:42:27
+ --> tests/ui/eta.rs:43:27
|
LL | let e = Some(1u8).map(|a| generic(a));
| ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
error: redundant closure
- --> tests/ui/eta.rs:94:51
+ --> tests/ui/eta.rs:95:51
|
LL | let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
| ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -41,166 +41,172 @@ LL | let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
= help: to override `-D warnings` add `#[allow(clippy::redundant_closure_for_method_calls)]`
error: redundant closure
- --> tests/ui/eta.rs:95:51
+ --> tests/ui/eta.rs:96:51
|
LL | let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
| ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
error: redundant closure
- --> tests/ui/eta.rs:97:42
+ --> tests/ui/eta.rs:98:42
|
LL | let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
| ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
error: redundant closure
- --> tests/ui/eta.rs:101:29
+ --> tests/ui/eta.rs:102:29
|
LL | let e = Some("str").map(|s| s.to_string());
| ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
error: redundant closure
- --> tests/ui/eta.rs:102:27
+ --> tests/ui/eta.rs:103:27
|
LL | let e = Some('a').map(|s| s.to_uppercase());
| ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
error: redundant closure
- --> tests/ui/eta.rs:104:65
+ --> tests/ui/eta.rs:105:65
|
LL | let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
error: redundant closure
- --> tests/ui/eta.rs:167:22
+ --> tests/ui/eta.rs:168:22
|
LL | requires_fn_once(|| x());
| ^^^^^^ help: replace the closure with the function itself: `x`
error: redundant closure
- --> tests/ui/eta.rs:174:27
+ --> tests/ui/eta.rs:175:27
|
LL | let a = Some(1u8).map(|a| foo_ptr(a));
| ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
error: redundant closure
- --> tests/ui/eta.rs:179:27
+ --> tests/ui/eta.rs:180:27
|
LL | let a = Some(1u8).map(|a| closure(a));
| ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
error: redundant closure
- --> tests/ui/eta.rs:211:28
+ --> tests/ui/eta.rs:212:28
|
LL | x.into_iter().for_each(|x| add_to_res(x));
| ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
error: redundant closure
- --> tests/ui/eta.rs:212:28
+ --> tests/ui/eta.rs:213:28
|
LL | y.into_iter().for_each(|x| add_to_res(x));
| ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
error: redundant closure
- --> tests/ui/eta.rs:213:28
+ --> tests/ui/eta.rs:214:28
|
LL | z.into_iter().for_each(|x| add_to_res(x));
| ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
error: redundant closure
- --> tests/ui/eta.rs:220:21
+ --> tests/ui/eta.rs:221:21
|
LL | Some(1).map(|n| closure(n));
| ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
error: redundant closure
- --> tests/ui/eta.rs:224:21
+ --> tests/ui/eta.rs:225:21
|
LL | Some(1).map(|n| in_loop(n));
| ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
error: redundant closure
- --> tests/ui/eta.rs:317:18
+ --> tests/ui/eta.rs:318:18
|
LL | takes_fn_mut(|| f());
| ^^^^^^ help: replace the closure with the function itself: `&mut f`
error: redundant closure
- --> tests/ui/eta.rs:320:19
+ --> tests/ui/eta.rs:321:19
|
LL | takes_fn_once(|| f());
| ^^^^^^ help: replace the closure with the function itself: `&mut f`
error: redundant closure
- --> tests/ui/eta.rs:324:26
+ --> tests/ui/eta.rs:325:26
|
LL | move || takes_fn_mut(|| f_used_once())
| ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
error: redundant closure
- --> tests/ui/eta.rs:336:19
+ --> tests/ui/eta.rs:337:19
|
LL | array_opt.map(|a| a.as_slice());
| ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
error: redundant closure
- --> tests/ui/eta.rs:339:19
+ --> tests/ui/eta.rs:340:19
|
LL | slice_opt.map(|s| s.len());
| ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
error: redundant closure
- --> tests/ui/eta.rs:342:17
+ --> tests/ui/eta.rs:343:17
|
LL | ptr_opt.map(|p| p.is_null());
| ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
error: redundant closure
- --> tests/ui/eta.rs:346:17
+ --> tests/ui/eta.rs:347:17
|
LL | dyn_opt.map(|d| d.method_on_dyn());
| ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
error: redundant closure
- --> tests/ui/eta.rs:406:19
+ --> tests/ui/eta.rs:407:19
|
LL | let _ = f(&0, |x, y| f2(x, y));
| ^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `f2`
error: redundant closure
- --> tests/ui/eta.rs:434:22
+ --> tests/ui/eta.rs:435:22
|
LL | test.map(|t| t.method())
| ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `Test::method`
error: redundant closure
- --> tests/ui/eta.rs:438:22
+ --> tests/ui/eta.rs:439:22
|
LL | test.map(|t| t.method())
| ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `super::Outer::method`
error: redundant closure
- --> tests/ui/eta.rs:451:18
+ --> tests/ui/eta.rs:452:18
|
LL | test.map(|t| t.method())
| ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `test_mod::Test::method`
error: redundant closure
- --> tests/ui/eta.rs:458:30
+ --> tests/ui/eta.rs:459:30
|
LL | test.map(|t| t.method())
| ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `crate::issue_10854::d::Test::method`
error: redundant closure
- --> tests/ui/eta.rs:477:38
+ --> tests/ui/eta.rs:478:38
|
LL | let x = Box::new(|| None.map(|x| f(x)));
| ^^^^^^^^ help: replace the closure with the function itself: `&f`
error: redundant closure
- --> tests/ui/eta.rs:481:38
+ --> tests/ui/eta.rs:482:38
|
LL | let x = Box::new(|| None.map(|x| f(x)));
| ^^^^^^^^ help: replace the closure with the function itself: `f`
-error: aborting due to 33 previous errors
+error: redundant closure
+ --> tests/ui/eta.rs:499:35
+ |
+LL | let _field = bind.or_else(|| get_default()).unwrap();
+ | ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `get_default`
+
+error: aborting due to 34 previous errors
diff --git a/src/tools/clippy/tests/ui/excessive_precision.stderr b/src/tools/clippy/tests/ui/excessive_precision.stderr
index 6d8e166a649d8..81e4fb6765d0b 100644
--- a/src/tools/clippy/tests/ui/excessive_precision.stderr
+++ b/src/tools/clippy/tests/ui/excessive_precision.stderr
@@ -2,100 +2,179 @@ error: float has excessive precision
--> tests/ui/excessive_precision.rs:20:26
|
LL | const BAD32_1: f32 = 0.123_456_789_f32;
- | ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79_f32`
+ | ^^^^^^^^^^^^^^^^^
|
= note: `-D clippy::excessive-precision` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::excessive_precision)]`
+help: consider changing the type or truncating it to
+ |
+LL | const BAD32_1: f32 = 0.123_456_79_f32;
+ | ~~~~~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:21:26
|
LL | const BAD32_2: f32 = 0.123_456_789;
- | ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79`
+ | ^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | const BAD32_2: f32 = 0.123_456_79;
+ | ~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:22:26
|
LL | const BAD32_3: f32 = 0.100_000_000_000_1;
- | ^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.1`
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | const BAD32_3: f32 = 0.1;
+ | ~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:23:29
|
LL | const BAD32_EDGE: f32 = 1.000_000_9;
- | ^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.000_001`
+ | ^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | const BAD32_EDGE: f32 = 1.000_001;
+ | ~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:27:26
|
LL | const BAD64_3: f64 = 0.100_000_000_000_000_000_1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.1`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | const BAD64_3: f64 = 0.1;
+ | ~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:30:22
|
LL | println!("{:?}", 8.888_888_888_888_888_888_888);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `8.888_888_888_888_89`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | println!("{:?}", 8.888_888_888_888_89);
+ | ~~~~~~~~~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:41:22
|
LL | let bad32: f32 = 1.123_456_789;
- | ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8`
+ | ^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let bad32: f32 = 1.123_456_8;
+ | ~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:42:26
|
LL | let bad32_suf: f32 = 1.123_456_789_f32;
- | ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8_f32`
+ | ^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let bad32_suf: f32 = 1.123_456_8_f32;
+ | ~~~~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:43:21
|
LL | let bad32_inf = 1.123_456_789_f32;
- | ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8_f32`
+ | ^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let bad32_inf = 1.123_456_8_f32;
+ | ~~~~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:53:36
|
LL | let bad_vec32: Vec<f32> = vec![0.123_456_789];
- | ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79`
+ | ^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let bad_vec32: Vec<f32> = vec![0.123_456_79];
+ | ~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:54:36
|
LL | let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_789];
- | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_789_123_456_78`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_78];
+ | ~~~~~~~~~~~~~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:58:24
|
LL | let bad_e32: f32 = 1.123_456_788_888e-10;
- | ^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8e-10`
+ | ^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let bad_e32: f32 = 1.123_456_8e-10;
+ | ~~~~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:61:27
|
LL | let bad_bige32: f32 = 1.123_456_788_888E-10;
- | ^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8E-10`
+ | ^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let bad_bige32: f32 = 1.123_456_8E-10;
+ | ~~~~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:70:13
|
LL | let _ = 2.225_073_858_507_201_1e-308_f64;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `2.225_073_858_507_201e-308_f64`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let _ = 2.225_073_858_507_201e-308_f64;
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:73:13
|
LL | let _ = 1.000_000_000_000_001e-324_f64;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0_f64`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | let _ = 0_f64;
+ | ~~~~~
error: float has excessive precision
--> tests/ui/excessive_precision.rs:83:20
|
LL | const _: f64 = 3.0000000000000000e+00;
- | ^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `3.0`
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or truncating it to
+ |
+LL | const _: f64 = 3.0;
+ | ~~~
error: aborting due to 16 previous errors
diff --git a/src/tools/clippy/tests/ui/explicit_counter_loop.rs b/src/tools/clippy/tests/ui/explicit_counter_loop.rs
index c25e79a36171f..28b477b69215b 100644
--- a/src/tools/clippy/tests/ui/explicit_counter_loop.rs
+++ b/src/tools/clippy/tests/ui/explicit_counter_loop.rs
@@ -278,3 +278,16 @@ mod issue_10058 {
}
}
}
+
+mod issue_13123 {
+ pub fn test() {
+ let mut vec = vec![1, 2, 3, 4];
+ let mut _index = 0;
+ 'label: for v in vec {
+ _index += 1;
+ if v == 1 {
+ break 'label;
+ }
+ }
+ }
+}
diff --git a/src/tools/clippy/tests/ui/explicit_counter_loop.stderr b/src/tools/clippy/tests/ui/explicit_counter_loop.stderr
index e28f8783f9c36..1b2d1f8570a3e 100644
--- a/src/tools/clippy/tests/ui/explicit_counter_loop.stderr
+++ b/src/tools/clippy/tests/ui/explicit_counter_loop.stderr
@@ -57,5 +57,11 @@ LL | for _item in slice {
|
= note: `idx_u32` is of type `u32`, making it ineligible for `Iterator::enumerate`
-error: aborting due to 9 previous errors
+error: the variable `_index` is used as a loop counter
+ --> tests/ui/explicit_counter_loop.rs:286:9
+ |
+LL | 'label: for v in vec {
+ | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `'label: for (_index, v) in vec.into_iter().enumerate()`
+
+error: aborting due to 10 previous errors
diff --git a/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.stderr b/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.stderr
index e5bb8d1326975..a05b7138bc99b 100644
--- a/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.stderr
+++ b/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.stderr
@@ -2,106 +2,190 @@ error: casting function pointer `foo` to `i8`
--> tests/ui/fn_to_numeric_cast_any.rs:23:13
|
LL | let _ = foo as i8;
- | ^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i8`
+ | ^^^^^^^^^
|
= note: `-D clippy::fn-to-numeric-cast-any` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast_any)]`
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as i8;
+ | ~~~~~~~~~~~
error: casting function pointer `foo` to `i16`
--> tests/ui/fn_to_numeric_cast_any.rs:26:13
|
LL | let _ = foo as i16;
- | ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i16`
+ | ^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as i16;
+ | ~~~~~~~~~~~~
error: casting function pointer `foo` to `i32`
--> tests/ui/fn_to_numeric_cast_any.rs:28:13
|
LL | let _ = foo as i32;
- | ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i32`
+ | ^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as i32;
+ | ~~~~~~~~~~~~
error: casting function pointer `foo` to `i64`
--> tests/ui/fn_to_numeric_cast_any.rs:30:13
|
LL | let _ = foo as i64;
- | ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i64`
+ | ^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as i64;
+ | ~~~~~~~~~~~~
error: casting function pointer `foo` to `i128`
--> tests/ui/fn_to_numeric_cast_any.rs:32:13
|
LL | let _ = foo as i128;
- | ^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i128`
+ | ^^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as i128;
+ | ~~~~~~~~~~~~~
error: casting function pointer `foo` to `isize`
--> tests/ui/fn_to_numeric_cast_any.rs:34:13
|
LL | let _ = foo as isize;
- | ^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as isize`
+ | ^^^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as isize;
+ | ~~~~~~~~~~~~~~
error: casting function pointer `foo` to `u8`
--> tests/ui/fn_to_numeric_cast_any.rs:37:13
|
LL | let _ = foo as u8;
- | ^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u8`
+ | ^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as u8;
+ | ~~~~~~~~~~~
error: casting function pointer `foo` to `u16`
--> tests/ui/fn_to_numeric_cast_any.rs:39:13
|
LL | let _ = foo as u16;
- | ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u16`
+ | ^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as u16;
+ | ~~~~~~~~~~~~
error: casting function pointer `foo` to `u32`
--> tests/ui/fn_to_numeric_cast_any.rs:41:13
|
LL | let _ = foo as u32;
- | ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u32`
+ | ^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as u32;
+ | ~~~~~~~~~~~~
error: casting function pointer `foo` to `u64`
--> tests/ui/fn_to_numeric_cast_any.rs:43:13
|
LL | let _ = foo as u64;
- | ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u64`
+ | ^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as u64;
+ | ~~~~~~~~~~~~
error: casting function pointer `foo` to `u128`
--> tests/ui/fn_to_numeric_cast_any.rs:45:13
|
LL | let _ = foo as u128;
- | ^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u128`
+ | ^^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as u128;
+ | ~~~~~~~~~~~~~
error: casting function pointer `foo` to `usize`
--> tests/ui/fn_to_numeric_cast_any.rs:47:13
|
LL | let _ = foo as usize;
- | ^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as usize`
+ | ^^^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as usize;
+ | ~~~~~~~~~~~~~~
error: casting function pointer `Struct::static_method` to `usize`
--> tests/ui/fn_to_numeric_cast_any.rs:52:13
|
LL | let _ = Struct::static_method as usize;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `Struct::static_method() as usize`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = Struct::static_method() as usize;
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: casting function pointer `f` to `usize`
--> tests/ui/fn_to_numeric_cast_any.rs:57:5
|
LL | f as usize
- | ^^^^^^^^^^ help: did you mean to invoke the function?: `f() as usize`
+ | ^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | f() as usize
+ |
error: casting function pointer `T::static_method` to `usize`
--> tests/ui/fn_to_numeric_cast_any.rs:62:5
|
LL | T::static_method as usize
- | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `T::static_method() as usize`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | T::static_method() as usize
+ |
error: casting function pointer `(clos as fn(u32) -> u32)` to `usize`
--> tests/ui/fn_to_numeric_cast_any.rs:69:13
|
LL | let _ = (clos as fn(u32) -> u32) as usize;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `(clos as fn(u32) -> u32)() as usize`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = (clos as fn(u32) -> u32)() as usize;
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: casting function pointer `foo` to `*const ()`
--> tests/ui/fn_to_numeric_cast_any.rs:74:13
|
LL | let _ = foo as *const ();
- | ^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as *const ()`
+ | ^^^^^^^^^^^^^^^^
+ |
+help: did you mean to invoke the function?
+ |
+LL | let _ = foo() as *const ();
+ | ~~~~~~~~~~~~~~~~~~
error: aborting due to 17 previous errors
diff --git a/src/tools/clippy/tests/ui/for_kv_map.fixed b/src/tools/clippy/tests/ui/for_kv_map.fixed
index a2112d7b73005..1733b29128fe5 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.fixed
+++ b/src/tools/clippy/tests/ui/for_kv_map.fixed
@@ -40,6 +40,16 @@ fn main() {
let _k = k;
}
+ let m: HashMap<u64, u64> = HashMap::new();
+ let rm = &m;
+ 'label: for k in rm.keys() {
+ //~^ ERROR: you seem to want to iterate on a map's keys
+ let _k = k;
+ if *k == 0u64 {
+ break 'label;
+ }
+ }
+
// The following should not produce warnings.
let m: HashMap<u64, u64> = HashMap::new();
diff --git a/src/tools/clippy/tests/ui/for_kv_map.rs b/src/tools/clippy/tests/ui/for_kv_map.rs
index 1b7959b8f92d6..de465a7c8e6e3 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.rs
+++ b/src/tools/clippy/tests/ui/for_kv_map.rs
@@ -40,6 +40,16 @@ fn main() {
let _k = k;
}
+ let m: HashMap<u64, u64> = HashMap::new();
+ let rm = &m;
+ 'label: for (k, _value) in rm {
+ //~^ ERROR: you seem to want to iterate on a map's keys
+ let _k = k;
+ if *k == 0u64 {
+ break 'label;
+ }
+ }
+
// The following should not produce warnings.
let m: HashMap<u64, u64> = HashMap::new();
diff --git a/src/tools/clippy/tests/ui/for_kv_map.stderr b/src/tools/clippy/tests/ui/for_kv_map.stderr
index f4ce473d095bf..adcc3ab8fdb90 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.stderr
+++ b/src/tools/clippy/tests/ui/for_kv_map.stderr
@@ -55,5 +55,16 @@ help: use the corresponding method
LL | for k in rm.keys() {
| ~ ~~~~~~~~~
-error: aborting due to 5 previous errors
+error: you seem to want to iterate on a map's keys
+ --> tests/ui/for_kv_map.rs:45:32
+ |
+LL | 'label: for (k, _value) in rm {
+ | ^^
+ |
+help: use the corresponding method
+ |
+LL | 'label: for k in rm.keys() {
+ | ~ ~~~~~~~~~
+
+error: aborting due to 6 previous errors
diff --git a/src/tools/clippy/tests/ui/get_unwrap.stderr b/src/tools/clippy/tests/ui/get_unwrap.stderr
index a08b6657dcc7c..0f8b279da1e7a 100644
--- a/src/tools/clippy/tests/ui/get_unwrap.stderr
+++ b/src/tools/clippy/tests/ui/get_unwrap.stderr
@@ -1,14 +1,18 @@
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:37:17
|
LL | let _ = boxed_slice.get(1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: the lint level is defined here
--> tests/ui/get_unwrap.rs:9:9
|
LL | #![deny(clippy::get_unwrap)]
| ^^^^^^^^^^^^^^^^^^
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &boxed_slice[1];
+ | ~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:37:17
@@ -21,11 +25,16 @@ LL | let _ = boxed_slice.get(1).unwrap();
= note: `-D clippy::unwrap-used` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::unwrap_used)]`
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:38:17
|
LL | let _ = some_slice.get(0).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_slice[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_slice[0];
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:38:17
@@ -36,11 +45,16 @@ LL | let _ = some_slice.get(0).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a Vec
--> tests/ui/get_unwrap.rs:39:17
|
LL | let _ = some_vec.get(0).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vec[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_vec[0];
+ | ~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:39:17
@@ -51,11 +65,16 @@ LL | let _ = some_vec.get(0).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a VecDeque
--> tests/ui/get_unwrap.rs:40:17
|
LL | let _ = some_vecdeque.get(0).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vecdeque[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_vecdeque[0];
+ | ~~~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:40:17
@@ -66,11 +85,16 @@ LL | let _ = some_vecdeque.get(0).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a HashMap
--> tests/ui/get_unwrap.rs:41:17
|
LL | let _ = some_hashmap.get(&1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_hashmap[&1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_hashmap[&1];
+ | ~~~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:41:17
@@ -81,11 +105,16 @@ LL | let _ = some_hashmap.get(&1).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a BTreeMap
--> tests/ui/get_unwrap.rs:42:17
|
LL | let _ = some_btreemap.get(&1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_btreemap[&1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = &some_btreemap[&1];
+ | ~~~~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:42:17
@@ -96,11 +125,16 @@ LL | let _ = some_btreemap.get(&1).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:46:21
|
LL | let _: u8 = *boxed_slice.get(1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _: u8 = boxed_slice[1];
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:46:22
@@ -111,11 +145,16 @@ LL | let _: u8 = *boxed_slice.get(1).unwrap();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:51:9
|
LL | *boxed_slice.get_mut(0).unwrap() = 1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | boxed_slice[0] = 1;
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:51:10
@@ -126,11 +165,16 @@ LL | *boxed_slice.get_mut(0).unwrap() = 1;
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:52:9
|
LL | *some_slice.get_mut(0).unwrap() = 1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_slice[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | some_slice[0] = 1;
+ | ~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:52:10
@@ -141,11 +185,16 @@ LL | *some_slice.get_mut(0).unwrap() = 1;
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a Vec
--> tests/ui/get_unwrap.rs:53:9
|
LL | *some_vec.get_mut(0).unwrap() = 1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | some_vec[0] = 1;
+ | ~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:53:10
@@ -156,11 +205,16 @@ LL | *some_vec.get_mut(0).unwrap() = 1;
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a VecDeque
--> tests/ui/get_unwrap.rs:54:9
|
LL | *some_vecdeque.get_mut(0).unwrap() = 1;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vecdeque[0]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | some_vecdeque[0] = 1;
+ | ~~~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:54:10
@@ -171,11 +225,16 @@ LL | *some_vecdeque.get_mut(0).unwrap() = 1;
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a Vec
--> tests/ui/get_unwrap.rs:66:17
|
LL | let _ = some_vec.get(0..1).unwrap().to_vec();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = some_vec[0..1].to_vec();
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:66:17
@@ -186,11 +245,16 @@ LL | let _ = some_vec.get(0..1).unwrap().to_vec();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a Vec
--> tests/ui/get_unwrap.rs:67:17
|
LL | let _ = some_vec.get_mut(0..1).unwrap().to_vec();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _ = some_vec[0..1].to_vec();
+ | ~~~~~~~~~~~~~~
error: used `unwrap()` on an `Option` value
--> tests/ui/get_unwrap.rs:67:17
@@ -201,29 +265,49 @@ LL | let _ = some_vec.get_mut(0..1).unwrap().to_vec();
= note: if this value is `None`, it will panic
= help: consider using `expect()` to provide a better panic message
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:77:24
|
LL | let _x: &i32 = f.get(1 + 2).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^ help: try: `&f[1 + 2]`
+ | ^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _x: &i32 = &f[1 + 2];
+ | ~~~~~~~~~
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:80:18
|
LL | let _x = f.get(1 + 2).unwrap().to_string();
- | ^^^^^^^^^^^^^^^^^^^^^ help: try: `f[1 + 2]`
+ | ^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _x = f[1 + 2].to_string();
+ | ~~~~~~~~
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:83:18
|
LL | let _x = f.get(1 + 2).unwrap().abs();
- | ^^^^^^^^^^^^^^^^^^^^^ help: try: `f[1 + 2]`
+ | ^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let _x = f[1 + 2].abs();
+ | ~~~~~~~~
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
--> tests/ui/get_unwrap.rs:100:33
|
LL | let b = rest.get_mut(linidx(j, k) - linidx(i, k) - 1).unwrap();
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut rest[linidx(j, k) - linidx(i, k) - 1]`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: using `[]` is clearer and more concise
+ |
+LL | let b = &mut rest[linidx(j, k) - linidx(i, k) - 1];
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 30 previous errors
diff --git a/src/tools/clippy/tests/ui/if_let_mutex.rs b/src/tools/clippy/tests/ui/if_let_mutex.rs
index cb6915e0ebaaa..bb0eadfca1c7a 100644
--- a/src/tools/clippy/tests/ui/if_let_mutex.rs
+++ b/src/tools/clippy/tests/ui/if_let_mutex.rs
@@ -1,4 +1,5 @@
#![warn(clippy::if_let_mutex)]
+#![allow(clippy::redundant_pattern_matching)]
use std::ops::Deref;
use std::sync::Mutex;
@@ -50,4 +51,12 @@ fn mutex_ref(mutex: &Mutex<i32>) {
};
}
+fn multiple_mutexes(m1: &Mutex<()>, m2: &Mutex<()>) {
+ if let Ok(_) = m1.lock() {
+ m2.lock();
+ } else {
+ m1.lock();
+ }
+}
+
fn main() {}
diff --git a/src/tools/clippy/tests/ui/if_let_mutex.stderr b/src/tools/clippy/tests/ui/if_let_mutex.stderr
index 6e0115c23af68..45df4ac4d6795 100644
--- a/src/tools/clippy/tests/ui/if_let_mutex.stderr
+++ b/src/tools/clippy/tests/ui/if_let_mutex.stderr
@@ -1,5 +1,5 @@
error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
- --> tests/ui/if_let_mutex.rs:10:5
+ --> tests/ui/if_let_mutex.rs:11:5
|
LL | if let Err(locked) = m.lock() {
| ^ - this Mutex will remain locked for the entire `if let`-block...
@@ -19,7 +19,7 @@ LL | | };
= help: to override `-D warnings` add `#[allow(clippy::if_let_mutex)]`
error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
- --> tests/ui/if_let_mutex.rs:23:5
+ --> tests/ui/if_let_mutex.rs:24:5
|
LL | if let Some(locked) = m.lock().unwrap().deref() {
| ^ - this Mutex will remain locked for the entire `if let`-block...
@@ -37,7 +37,7 @@ LL | | };
= help: move the lock call outside of the `if let ...` expression
error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
- --> tests/ui/if_let_mutex.rs:45:5
+ --> tests/ui/if_let_mutex.rs:46:5
|
LL | if let Ok(i) = mutex.lock() {
| ^ ----- this Mutex will remain locked for the entire `if let`-block...
@@ -53,5 +53,21 @@ LL | | };
|
= help: move the lock call outside of the `if let ...` expression
-error: aborting due to 3 previous errors
+error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
+ --> tests/ui/if_let_mutex.rs:55:5
+ |
+LL | if let Ok(_) = m1.lock() {
+ | ^ -- this Mutex will remain locked for the entire `if let`-block...
+ | _____|
+ | |
+LL | | m2.lock();
+LL | | } else {
+LL | | m1.lock();
+ | | -- ... and is tried to lock again here, which will always deadlock.
+LL | | }
+ | |_____^
+ |
+ = help: move the lock call outside of the `if let ...` expression
+
+error: aborting due to 4 previous errors
diff --git a/src/tools/clippy/tests/ui/if_then_some_else_none.fixed b/src/tools/clippy/tests/ui/if_then_some_else_none.fixed
new file mode 100644
index 0000000000000..ad13372a68b7e
--- /dev/null
+++ b/src/tools/clippy/tests/ui/if_then_some_else_none.fixed
@@ -0,0 +1,119 @@
+#![warn(clippy::if_then_some_else_none)]
+#![allow(clippy::redundant_pattern_matching, clippy::unnecessary_lazy_evaluations)]
+
+fn main() {
+ // Should issue an error.
+ let _ = foo().then(|| { println!("true!"); "foo" });
+
+ // Should issue an error when macros are used.
+ let _ = matches!(true, true).then(|| { println!("true!"); matches!(true, false) });
+
+ // Should issue an error. Binary expression `o < 32` should be parenthesized.
+ let x = Some(5);
+ let _ = x.and_then(|o| (o < 32).then_some(o));
+ //~^ ERROR: this could be simplified with `bool::then_some`
+
+ // Should issue an error. Unary expression `!x` should be parenthesized.
+ let x = true;
+ let _ = (!x).then_some(0);
+ //~^ ERROR: this could be simplified with `bool::then_some`
+
+ // Should not issue an error since the `else` block has a statement besides `None`.
+ let _ = if foo() {
+ println!("true!");
+ Some("foo")
+ } else {
+ eprintln!("false...");
+ None
+ };
+
+ // Should not issue an error since there are more than 2 blocks in the if-else chain.
+ let _ = if foo() {
+ println!("foo true!");
+ Some("foo")
+ } else if bar() {
+ println!("bar true!");
+ Some("bar")
+ } else {
+ None
+ };
+
+ let _ = if foo() {
+ println!("foo true!");
+ Some("foo")
+ } else {
+ bar().then(|| {
+ println!("bar true!");
+ "bar"
+ })
+ };
+
+ // Should not issue an error since the `then` block has `None`, not `Some`.
+ let _ = if foo() { None } else { Some("foo is false") };
+
+ // Should not issue an error since the `else` block doesn't use `None` directly.
+ let _ = if foo() { Some("foo is true") } else { into_none() };
+
+ // Should not issue an error since the `then` block doesn't use `Some` directly.
+ let _ = if foo() { into_some("foo") } else { None };
+}
+
+#[clippy::msrv = "1.49"]
+fn _msrv_1_49() {
+ // `bool::then` was stabilized in 1.50. Do not lint this
+ let _ = if foo() {
+ println!("true!");
+ Some(149)
+ } else {
+ None
+ };
+}
+
+#[clippy::msrv = "1.50"]
+fn _msrv_1_50() {
+ let _ = foo().then(|| { println!("true!"); 150 });
+}
+
+fn foo() -> bool {
+ unimplemented!()
+}
+
+fn bar() -> bool {
+ unimplemented!()
+}
+
+fn into_some<T>(v: T) -> Option<T> {
+ Some(v)
+}
+
+fn into_none<T>() -> Option<T> {
+ None
+}
+
+// Should not warn
+fn f(b: bool, v: Option<()>) -> Option<()> {
+ if b {
+ v?; // This is a potential early return, is not equivalent with `bool::then`
+
+ Some(())
+ } else {
+ None
+ }
+}
+
+fn issue11394(b: bool, v: Result<(), ()>) -> Result<(), ()> {
+ let x = if b {
+ #[allow(clippy::let_unit_value)]
+ let _ = v?;
+ Some(())
+ } else {
+ None
+ };
+
+ Ok(())
+}
+
+const fn issue12103(x: u32) -> Option<u32> {
+ // Should not issue an error in `const` context
+ if x > 42 { Some(150) } else { None }
+}
diff --git a/src/tools/clippy/tests/ui/if_then_some_else_none.rs b/src/tools/clippy/tests/ui/if_then_some_else_none.rs
index ccde154bd56ca..73edbb7da2a87 100644
--- a/src/tools/clippy/tests/ui/if_then_some_else_none.rs
+++ b/src/tools/clippy/tests/ui/if_then_some_else_none.rs
@@ -1,5 +1,5 @@
#![warn(clippy::if_then_some_else_none)]
-#![allow(clippy::redundant_pattern_matching)]
+#![allow(clippy::redundant_pattern_matching, clippy::unnecessary_lazy_evaluations)]
fn main() {
// Should issue an error.
diff --git a/src/tools/clippy/tests/ui/if_then_some_else_none.stderr b/src/tools/clippy/tests/ui/if_then_some_else_none.stderr
index e0a95aebdc134..aed01e026cbe7 100644
--- a/src/tools/clippy/tests/ui/if_then_some_else_none.stderr
+++ b/src/tools/clippy/tests/ui/if_then_some_else_none.stderr
@@ -9,9 +9,8 @@ LL | | Some("foo")
LL | | } else {
LL | | None
LL | | };
- | |_____^
+ | |_____^ help: try: `foo().then(|| { println!("true!"); "foo" })`
|
- = help: consider using `bool::then` like: `foo().then(|| { /* snippet */ "foo" })`
= note: `-D clippy::if-then-some-else-none` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::if_then_some_else_none)]`
@@ -26,25 +25,19 @@ LL | | Some(matches!(true, false))
LL | | } else {
LL | | None
LL | | };
- | |_____^
- |
- = help: consider using `bool::then` like: `matches!(true, true).then(|| { /* snippet */ matches!(true, false) })`
+ | |_____^ help: try: `matches!(true, true).then(|| { println!("true!"); matches!(true, false) })`
error: this could be simplified with `bool::then_some`
--> tests/ui/if_then_some_else_none.rs:25:28
|
LL | let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = help: consider using `bool::then_some` like: `(o < 32).then_some(o)`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(o < 32).then_some(o)`
error: this could be simplified with `bool::then_some`
--> tests/ui/if_then_some_else_none.rs:30:13
|
LL | let _ = if !x { Some(0) } else { None };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = help: consider using `bool::then_some` like: `(!x).then_some(0)`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(!x).then_some(0)`
error: this could be simplified with `bool::then`
--> tests/ui/if_then_some_else_none.rs:86:13
@@ -57,9 +50,7 @@ LL | | Some(150)
LL | | } else {
LL | | None
LL | | };
- | |_____^
- |
- = help: consider using `bool::then` like: `foo().then(|| { /* snippet */ 150 })`
+ | |_____^ help: try: `foo().then(|| { println!("true!"); 150 })`
error: aborting due to 5 previous errors
diff --git a/src/tools/clippy/tests/ui/implicit_hasher.fixed b/src/tools/clippy/tests/ui/implicit_hasher.fixed
new file mode 100644
index 0000000000000..2d6dc0274cf2a
--- /dev/null
+++ b/src/tools/clippy/tests/ui/implicit_hasher.fixed
@@ -0,0 +1,102 @@
+//@aux-build:proc_macros.rs
+#![deny(clippy::implicit_hasher)]
+
+#[macro_use]
+extern crate proc_macros;
+
+use std::cmp::Eq;
+use std::collections::{HashMap, HashSet};
+use std::hash::{BuildHasher, Hash};
+
+pub trait Foo<T>: Sized {
+ fn make() -> (Self, Self);
+}
+
+impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashMap<K, V, S> {
+ fn make() -> (Self, Self) {
+ // OK, don't suggest to modify these
+ let _: HashMap<i32, i32> = HashMap::new();
+ let _: HashSet<i32> = HashSet::new();
+
+ (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+ }
+}
+impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for (HashMap<K, V, S>,) {
+ fn make() -> (Self, Self) {
+ ((HashMap::default(),), (HashMap::with_capacity_and_hasher(10, Default::default()),))
+ }
+}
+impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashMap<String, String, S> {
+ fn make() -> (Self, Self) {
+ (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+ }
+}
+
+impl<K: Hash + Eq, V, S: BuildHasher + Default> Foo<i32> for HashMap<K, V, S> {
+ fn make() -> (Self, Self) {
+ (HashMap::default(), HashMap::with_capacity_and_hasher(10, S::default()))
+ }
+}
+impl<S: BuildHasher + Default> Foo<i64> for HashMap<String, String, S> {
+ fn make() -> (Self, Self) {
+ (HashMap::default(), HashMap::with_capacity_and_hasher(10, S::default()))
+ }
+}
+
+impl<T: Hash + Eq, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashSet<T, S> {
+ fn make() -> (Self, Self) {
+ (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
+ }
+}
+impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashSet<String, S> {
+ fn make() -> (Self, Self) {
+ (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
+ }
+}
+
+impl<T: Hash + Eq, S: BuildHasher + Default> Foo<i32> for HashSet<T, S> {
+ fn make() -> (Self, Self) {
+ (HashSet::default(), HashSet::with_capacity_and_hasher(10, S::default()))
+ }
+}
+impl<S: BuildHasher + Default> Foo<i64> for HashSet<String, S> {
+ fn make() -> (Self, Self) {
+ (HashSet::default(), HashSet::with_capacity_and_hasher(10, S::default()))
+ }
+}
+
+pub fn map<S: ::std::hash::BuildHasher>(map: &mut HashMap<i32, i32, S>) {}
+
+pub fn set<S: ::std::hash::BuildHasher>(set: &mut HashSet<i32, S>) {}
+
+#[inline_macros]
+pub mod gen {
+ use super::*;
+ inline! {
+ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<u8> for HashMap<K, V, S> {
+ fn make() -> (Self, Self) {
+ (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+ }
+ }
+
+ pub fn bar(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
+ }
+}
+
+// When the macro is in a different file, the suggestion spans can't be combined properly
+// and should not cause an ICE
+// See #2707
+#[macro_use]
+#[path = "auxiliary/test_macro.rs"]
+pub mod test_macro;
+__implicit_hasher_test_macro!(impl<K, V> for HashMap<K, V> where V: test_macro::A);
+
+// #4260
+external! {
+ pub fn f(input: &HashMap<u32, u32>) {}
+}
+
+// #7712
+pub async fn election_vote<S: ::std::hash::BuildHasher>(_data: HashMap<i32, i32, S>) {}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/implicit_hasher.rs b/src/tools/clippy/tests/ui/implicit_hasher.rs
index f7cd541741b11..0a334357bd1b8 100644
--- a/src/tools/clippy/tests/ui/implicit_hasher.rs
+++ b/src/tools/clippy/tests/ui/implicit_hasher.rs
@@ -1,11 +1,8 @@
//@aux-build:proc_macros.rs
-//@no-rustfix
#![deny(clippy::implicit_hasher)]
-#![allow(unused)]
#[macro_use]
extern crate proc_macros;
-use proc_macros::external;
use std::cmp::Eq;
use std::collections::{HashMap, HashSet};
@@ -68,9 +65,11 @@ impl<S: BuildHasher + Default> Foo<i64> for HashSet<String, S> {
}
}
-pub fn foo(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
+pub fn map(map: &mut HashMap<i32, i32>) {}
-#[proc_macros::inline_macros]
+pub fn set(set: &mut HashSet<i32>) {}
+
+#[inline_macros]
pub mod gen {
use super::*;
inline! {
diff --git a/src/tools/clippy/tests/ui/implicit_hasher.stderr b/src/tools/clippy/tests/ui/implicit_hasher.stderr
index a3df8edf389be..48c6ebc209cf3 100644
--- a/src/tools/clippy/tests/ui/implicit_hasher.stderr
+++ b/src/tools/clippy/tests/ui/implicit_hasher.stderr
@@ -1,40 +1,121 @@
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
- --> tests/ui/implicit_hasher.rs:14:1
+error: impl for `HashMap` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:15:35
+ |
+LL | impl<K: Hash + Eq, V> Foo<i8> for HashMap<K, V> {
+ | ^^^^^^^^^^^^^
+ |
+note: the lint level is defined here
+ --> tests/ui/implicit_hasher.rs:2:9
+ |
+LL | #![deny(clippy::implicit_hasher)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+help: add a type parameter for `BuildHasher`
+ |
+LL ~ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashMap<K, V, S> {
+LL | fn make() -> (Self, Self) {
+...
+LL |
+LL ~ (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+ |
+
+error: impl for `HashMap` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:24:36
+ |
+LL | impl<K: Hash + Eq, V> Foo<i8> for (HashMap<K, V>,) {
+ | ^^^^^^^^^^^^^
+ |
+help: add a type parameter for `BuildHasher`
+ |
+LL ~ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for (HashMap<K, V, S>,) {
+LL | fn make() -> (Self, Self) {
+LL ~ ((HashMap::default(),), (HashMap::with_capacity_and_hasher(10, Default::default()),))
+ |
+
+error: impl for `HashMap` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:29:19
+ |
+LL | impl Foo<i16> for HashMap<String, String> {
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: add a type parameter for `BuildHasher`
+ |
+LL ~ impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashMap<String, String, S> {
+LL | fn make() -> (Self, Self) {
+LL ~ (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+ |
+
+error: impl for `HashSet` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:46:32
+ |
+LL | impl<T: Hash + Eq> Foo<i8> for HashSet<T> {
+ | ^^^^^^^^^^
+ |
+help: add a type parameter for `BuildHasher`
+ |
+LL ~ impl<T: Hash + Eq, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashSet<T, S> {
+LL | fn make() -> (Self, Self) {
+LL ~ (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
|
-LL | pub trait Foo<T>: Sized {
- | ^^^^^^^^^^^^^^^^^^^^^^^
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
- --> tests/ui/implicit_hasher.rs:71:1
+error: impl for `HashSet` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:51:19
+ |
+LL | impl Foo<i16> for HashSet<String> {
+ | ^^^^^^^^^^^^^^^
+ |
+help: add a type parameter for `BuildHasher`
+ |
+LL ~ impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashSet<String, S> {
+LL | fn make() -> (Self, Self) {
+LL ~ (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
|
-LL | pub fn foo(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
- --> tests/ui/implicit_hasher.rs:74:1
+error: parameter of type `HashMap` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:68:22
+ |
+LL | pub fn map(map: &mut HashMap<i32, i32>) {}
+ | ^^^^^^^^^^^^^^^^^
|
-LL | pub mod gen {
- | ^^^^^^^^^^^
+help: add a type parameter for `BuildHasher`
+ |
+LL | pub fn map<S: ::std::hash::BuildHasher>(map: &mut HashMap<i32, i32, S>) {}
+ | +++++++++++++++++++++++++++++ ~~~~~~~~~~~~~~~~~~~~
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
- --> tests/ui/implicit_hasher.rs:92:1
+error: parameter of type `HashSet` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:70:22
+ |
+LL | pub fn set(set: &mut HashSet<i32>) {}
+ | ^^^^^^^^^^^^
|
-LL | pub mod test_macro;
- | ^^^^^^^^^^^^^^^^^^^
+help: add a type parameter for `BuildHasher`
+ |
+LL | pub fn set<S: ::std::hash::BuildHasher>(set: &mut HashSet<i32, S>) {}
+ | +++++++++++++++++++++++++++++ ~~~~~~~~~~~~~~~
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
- --> tests/ui/implicit_hasher.rs:96:1
+error: impl for `HashMap` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:76:43
+ |
+LL | impl<K: Hash + Eq, V> Foo<u8> for HashMap<K, V> {
+ | ^^^^^^^^^^^^^
|
-LL | external! {
- | ^^^^^^^^^
+ = note: this error originates in the macro `__inline_mac_mod_gen` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: add a type parameter for `BuildHasher`
+ |
+LL ~ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<u8> for HashMap<K, V, S> {
+LL | fn make() -> (Self, Self) {
+LL ~ (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
|
- = note: this error originates in the macro `external` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
- --> tests/ui/implicit_hasher.rs:101:1
+error: parameter of type `HashMap` should be generalized over different hashers
+ --> tests/ui/implicit_hasher.rs:100:35
|
LL | pub async fn election_vote(_data: HashMap<i32, i32>) {}
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^
+ |
+help: add a type parameter for `BuildHasher`
+ |
+LL | pub async fn election_vote<S: ::std::hash::BuildHasher>(_data: HashMap<i32, i32, S>) {}
+ | +++++++++++++++++++++++++++++ ~~~~~~~~~~~~~~~~~~~~
-error: aborting due to 6 previous errors
+error: aborting due to 9 previous errors
diff --git a/src/tools/clippy/tests/ui/implicit_return.stderr b/src/tools/clippy/tests/ui/implicit_return.stderr
index f06d4e983c57a..3b06f26f5a05f 100644
--- a/src/tools/clippy/tests/ui/implicit_return.stderr
+++ b/src/tools/clippy/tests/ui/implicit_return.stderr
@@ -2,88 +2,157 @@ error: missing `return` statement
--> tests/ui/implicit_return.rs:15:5
|
LL | true
- | ^^^^ help: add `return` as shown: `return true`
+ | ^^^^
|
= note: `-D clippy::implicit-return` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::implicit_return)]`
+help: add `return` as shown
+ |
+LL | return true
+ |
error: missing `return` statement
--> tests/ui/implicit_return.rs:19:15
|
LL | if true { true } else { false }
- | ^^^^ help: add `return` as shown: `return true`
+ | ^^^^
+ |
+help: add `return` as shown
+ |
+LL | if true { return true } else { false }
+ | ~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:19:29
|
LL | if true { true } else { false }
- | ^^^^^ help: add `return` as shown: `return false`
+ | ^^^^^
+ |
+help: add `return` as shown
+ |
+LL | if true { true } else { return false }
+ | ~~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:25:17
|
LL | true => false,
- | ^^^^^ help: add `return` as shown: `return false`
+ | ^^^^^
+ |
+help: add `return` as shown
+ |
+LL | true => return false,
+ | ~~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:26:20
|
LL | false => { true },
- | ^^^^ help: add `return` as shown: `return true`
+ | ^^^^
+ |
+help: add `return` as shown
+ |
+LL | false => { return true },
+ | ~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:39:9
|
LL | break true;
- | ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+ | ^^^^^^^^^^
+ |
+help: change `break` to `return` as shown
+ |
+LL | return true;
+ | ~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:46:13
|
LL | break true;
- | ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+ | ^^^^^^^^^^
+ |
+help: change `break` to `return` as shown
+ |
+LL | return true;
+ | ~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:54:13
|
LL | break true;
- | ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+ | ^^^^^^^^^^
+ |
+help: change `break` to `return` as shown
+ |
+LL | return true;
+ | ~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:72:18
|
LL | let _ = || { true };
- | ^^^^ help: add `return` as shown: `return true`
+ | ^^^^
+ |
+help: add `return` as shown
+ |
+LL | let _ = || { return true };
+ | ~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:73:16
|
LL | let _ = || true;
- | ^^^^ help: add `return` as shown: `return true`
+ | ^^^^
+ |
+help: add `return` as shown
+ |
+LL | let _ = || return true;
+ | ~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:81:5
|
LL | format!("test {}", "test")
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `return` as shown: `return format!("test {}", "test")`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: add `return` as shown
+ |
+LL | return format!("test {}", "test")
+ |
error: missing `return` statement
--> tests/ui/implicit_return.rs:90:5
|
LL | m!(true, false)
- | ^^^^^^^^^^^^^^^ help: add `return` as shown: `return m!(true, false)`
+ | ^^^^^^^^^^^^^^^
+ |
+help: add `return` as shown
+ |
+LL | return m!(true, false)
+ |
error: missing `return` statement
--> tests/ui/implicit_return.rs:96:13
|
LL | break true;
- | ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+ | ^^^^^^^^^^
+ |
+help: change `break` to `return` as shown
+ |
+LL | return true;
+ | ~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:101:17
|
LL | break 'outer false;
- | ^^^^^^^^^^^^^^^^^^ help: change `break` to `return` as shown: `return false`
+ | ^^^^^^^^^^^^^^^^^^
+ |
+help: change `break` to `return` as shown
+ |
+LL | return false;
+ | ~~~~~~~~~~~~
error: missing `return` statement
--> tests/ui/implicit_return.rs:116:5
@@ -104,7 +173,12 @@ error: missing `return` statement
--> tests/ui/implicit_return.rs:130:5
|
LL | true
- | ^^^^ help: add `return` as shown: `return true`
+ | ^^^^
+ |
+help: add `return` as shown
+ |
+LL | return true
+ |
error: aborting due to 16 previous errors
diff --git a/src/tools/clippy/tests/ui/lossy_float_literal.stderr b/src/tools/clippy/tests/ui/lossy_float_literal.stderr
index b5a07418734c9..3026854e317ae 100644
--- a/src/tools/clippy/tests/ui/lossy_float_literal.stderr
+++ b/src/tools/clippy/tests/ui/lossy_float_literal.stderr
@@ -2,70 +2,124 @@ error: literal cannot be represented as the underlying type without loss of prec
--> tests/ui/lossy_float_literal.rs:14:18
|
LL | let _: f32 = 16_777_217.0;
- | ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_216.0`
+ | ^^^^^^^^^^^^
|
= note: `-D clippy::lossy-float-literal` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::lossy_float_literal)]`
+help: consider changing the type or replacing it with
+ |
+LL | let _: f32 = 16_777_216.0;
+ | ~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:15:18
|
LL | let _: f32 = 16_777_219.0;
- | ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
+ | ^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _: f32 = 16_777_220.0;
+ | ~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:16:18
|
LL | let _: f32 = 16_777_219.;
- | ^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
+ | ^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _: f32 = 16_777_220.0;
+ | ~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:17:18
|
LL | let _: f32 = 16_777_219.000;
- | ^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
+ | ^^^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _: f32 = 16_777_220.0;
+ | ~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:18:13
|
LL | let _ = 16_777_219f32;
- | ^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220_f32`
+ | ^^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _ = 16_777_220_f32;
+ | ~~~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:19:19
|
LL | let _: f32 = -16_777_219.0;
- | ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
+ | ^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _: f32 = -16_777_220.0;
+ | ~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:21:18
|
LL | let _: f64 = 9_007_199_254_740_993.0;
- | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _: f64 = 9_007_199_254_740_992.0;
+ | ~~~~~~~~~~~~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:22:18
|
LL | let _: f64 = 9_007_199_254_740_993.;
- | ^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _: f64 = 9_007_199_254_740_992.0;
+ | ~~~~~~~~~~~~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:23:18
|
LL | let _: f64 = 9_007_199_254_740_993.00;
- | ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _: f64 = 9_007_199_254_740_992.0;
+ | ~~~~~~~~~~~~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:24:13
|
LL | let _ = 9_007_199_254_740_993f64;
- | ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992_f64`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _ = 9_007_199_254_740_992_f64;
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~
error: literal cannot be represented as the underlying type without loss of precision
--> tests/ui/lossy_float_literal.rs:25:19
|
LL | let _: f64 = -9_007_199_254_740_993.0;
- | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider changing the type or replacing it with
+ |
+LL | let _: f64 = -9_007_199_254_740_992.0;
+ | ~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 11 previous errors
diff --git a/src/tools/clippy/tests/ui/missing_trait_methods.rs b/src/tools/clippy/tests/ui/missing_trait_methods.rs
index 1b09b717ff70a..55b904bde59af 100644
--- a/src/tools/clippy/tests/ui/missing_trait_methods.rs
+++ b/src/tools/clippy/tests/ui/missing_trait_methods.rs
@@ -49,4 +49,12 @@ impl B for Complete {
}
}
+trait MissingMultiple {
+ fn one() {}
+ fn two() {}
+ fn three() {}
+}
+
+impl MissingMultiple for Partial {}
+
fn main() {}
diff --git a/src/tools/clippy/tests/ui/missing_trait_methods.stderr b/src/tools/clippy/tests/ui/missing_trait_methods.stderr
index f5d5d4418b287..9c4968b022d7e 100644
--- a/src/tools/clippy/tests/ui/missing_trait_methods.stderr
+++ b/src/tools/clippy/tests/ui/missing_trait_methods.stderr
@@ -24,5 +24,41 @@ help: implement the method
LL | fn b<'a, T: AsRef<[u8]>>(a: &'a T) -> &'a [u8] {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: aborting due to 2 previous errors
+error: missing trait method provided by default: `one`
+ --> tests/ui/missing_trait_methods.rs:58:1
+ |
+LL | impl MissingMultiple for Partial {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: implement the method
+ --> tests/ui/missing_trait_methods.rs:53:5
+ |
+LL | fn one() {}
+ | ^^^^^^^^
+
+error: missing trait method provided by default: `two`
+ --> tests/ui/missing_trait_methods.rs:58:1
+ |
+LL | impl MissingMultiple for Partial {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: implement the method
+ --> tests/ui/missing_trait_methods.rs:54:5
+ |
+LL | fn two() {}
+ | ^^^^^^^^
+
+error: missing trait method provided by default: `three`
+ --> tests/ui/missing_trait_methods.rs:58:1
+ |
+LL | impl MissingMultiple for Partial {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: implement the method
+ --> tests/ui/missing_trait_methods.rs:55:5
+ |
+LL | fn three() {}
+ | ^^^^^^^^^^
+
+error: aborting due to 5 previous errors
diff --git a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
index 5478372cbe00f..c1dc8b5e8d09c 100644
--- a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
+++ b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
@@ -333,4 +333,12 @@ fn main() {
f(&y); // Don't lint
f("".to_owned()); // Lint
}
+ {
+ fn takes_writer<T: std::io::Write>(_: T) {}
+
+ fn issue_12856(mut buffer: &mut Vec<u8>) {
+ takes_writer(&mut buffer); // Don't lint, would make buffer unavailable later
+ buffer.extend(b"\n");
+ }
+ }
}
diff --git a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
index 2643815d939b5..c7f66824d5818 100644
--- a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
+++ b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
@@ -333,4 +333,12 @@ fn main() {
f(&y); // Don't lint
f(&"".to_owned()); // Lint
}
+ {
+ fn takes_writer<T: std::io::Write>(_: T) {}
+
+ fn issue_12856(mut buffer: &mut Vec<u8>) {
+ takes_writer(&mut buffer); // Don't lint, would make buffer unavailable later
+ buffer.extend(b"\n");
+ }
+ }
}
diff --git a/src/tools/clippy/tests/ui/needless_pub_self.stderr b/src/tools/clippy/tests/ui/needless_pub_self.stderr
index 0bff2e4b8b71b..1fdd841656594 100644
--- a/src/tools/clippy/tests/ui/needless_pub_self.stderr
+++ b/src/tools/clippy/tests/ui/needless_pub_self.stderr
@@ -2,22 +2,27 @@ error: unnecessary `pub(self)`
--> tests/ui/needless_pub_self.rs:13:1
|
LL | pub(self) fn a() {}
- | ^^^^^^^^^ help: remove it
+ | ^^^^^^^^^
|
= note: `-D clippy::needless-pub-self` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::needless_pub_self)]`
+ = help: remove it
error: unnecessary `pub(in self)`
--> tests/ui/needless_pub_self.rs:14:1
|
LL | pub(in self) fn b() {}
- | ^^^^^^^^^^^^ help: remove it
+ | ^^^^^^^^^^^^
+ |
+ = help: remove it
error: unnecessary `pub(self)`
--> tests/ui/needless_pub_self.rs:20:5
|
LL | pub(self) fn f() {}
- | ^^^^^^^^^ help: remove it
+ | ^^^^^^^^^
+ |
+ = help: remove it
error: aborting due to 3 previous errors
diff --git a/src/tools/clippy/tests/ui/nonminimal_bool.rs b/src/tools/clippy/tests/ui/nonminimal_bool.rs
index d117e8bf9c7a1..52b0155a762ea 100644
--- a/src/tools/clippy/tests/ui/nonminimal_bool.rs
+++ b/src/tools/clippy/tests/ui/nonminimal_bool.rs
@@ -177,3 +177,9 @@ fn issue_12371(x: usize) -> bool {
// Should not warn!
!x != 0
}
+
+// Not linted because it is slow to do so
+// https://github.com/rust-lang/rust-clippy/issues/13206
+fn many_ops(a: bool, b: bool, c: bool, d: bool, e: bool, f: bool) -> bool {
+ (a && c && f) || (!a && b && !d) || (!b && !c && !e) || (d && e && !f)
+}
diff --git a/src/tools/clippy/tests/ui/patterns.fixed b/src/tools/clippy/tests/ui/patterns.fixed
index 332cba9715575..feaec33ac15a1 100644
--- a/src/tools/clippy/tests/ui/patterns.fixed
+++ b/src/tools/clippy/tests/ui/patterns.fixed
@@ -1,7 +1,7 @@
//@aux-build:proc_macros.rs
#![warn(clippy::all)]
#![allow(unused)]
-#![allow(clippy::uninlined_format_args)]
+#![allow(clippy::uninlined_format_args, clippy::single_match)]
#[macro_use]
extern crate proc_macros;
diff --git a/src/tools/clippy/tests/ui/patterns.rs b/src/tools/clippy/tests/ui/patterns.rs
index 45d907688e379..53812c7deec3e 100644
--- a/src/tools/clippy/tests/ui/patterns.rs
+++ b/src/tools/clippy/tests/ui/patterns.rs
@@ -1,7 +1,7 @@
//@aux-build:proc_macros.rs
#![warn(clippy::all)]
#![allow(unused)]
-#![allow(clippy::uninlined_format_args)]
+#![allow(clippy::uninlined_format_args, clippy::single_match)]
#[macro_use]
extern crate proc_macros;
diff --git a/src/tools/clippy/tests/ui/rename.fixed b/src/tools/clippy/tests/ui/rename.fixed
index d70c9f8d06c07..b810fd8224f63 100644
--- a/src/tools/clippy/tests/ui/rename.fixed
+++ b/src/tools/clippy/tests/ui/rename.fixed
@@ -13,7 +13,10 @@
#![allow(clippy::disallowed_methods)]
#![allow(clippy::disallowed_types)]
#![allow(clippy::mixed_read_write_in_expression)]
+#![allow(clippy::manual_find_map)]
+#![allow(clippy::manual_filter_map)]
#![allow(clippy::useless_conversion)]
+#![allow(clippy::redundant_pattern_matching)]
#![allow(clippy::match_result_ok)]
#![allow(clippy::non_canonical_clone_impl)]
#![allow(clippy::non_canonical_partial_ord_impl)]
@@ -47,6 +50,7 @@
#![allow(invalid_value)]
#![allow(invalid_from_utf8_unchecked)]
#![allow(let_underscore_drop)]
+#![allow(unexpected_cfgs)]
#![allow(enum_intrinsics_non_enums)]
#![allow(non_fmt_panics)]
#![allow(named_arguments_used_positionally)]
@@ -55,65 +59,72 @@
#![allow(unknown_lints)]
#![allow(unused_labels)]
#![allow(ambiguous_wide_pointer_comparisons)]
-#![warn(clippy::almost_complete_range)]
-#![warn(clippy::disallowed_names)]
-#![warn(clippy::blocks_in_conditions)]
-#![warn(clippy::blocks_in_conditions)]
-#![warn(clippy::blocks_in_conditions)]
-#![warn(clippy::box_collection)]
-#![warn(clippy::redundant_static_lifetimes)]
-#![warn(clippy::cognitive_complexity)]
-#![warn(clippy::derived_hash_with_manual_eq)]
-#![warn(clippy::disallowed_methods)]
-#![warn(clippy::disallowed_types)]
-#![warn(clippy::mixed_read_write_in_expression)]
-#![warn(clippy::useless_conversion)]
-#![warn(clippy::match_result_ok)]
-#![warn(clippy::non_canonical_clone_impl)]
-#![warn(clippy::non_canonical_partial_ord_impl)]
-#![warn(clippy::arithmetic_side_effects)]
-#![warn(clippy::overly_complex_bool_expr)]
-#![warn(clippy::new_without_default)]
-#![warn(clippy::bind_instead_of_map)]
-#![warn(clippy::expect_used)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::panicking_overflow_checks)]
-#![warn(clippy::needless_borrow)]
-#![warn(clippy::expect_used)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::single_char_add_str)]
-#![warn(clippy::module_name_repetitions)]
-#![warn(clippy::missing_const_for_thread_local)]
-#![warn(clippy::recursive_format_impl)]
-#![warn(clippy::unwrap_or_default)]
-#![warn(clippy::invisible_characters)]
-#![warn(invalid_reference_casting)]
-#![warn(suspicious_double_ref_op)]
-#![warn(invalid_nan_comparisons)]
-#![warn(drop_bounds)]
-#![warn(dropping_copy_types)]
-#![warn(dropping_references)]
-#![warn(useless_ptr_null_checks)]
-#![warn(for_loops_over_fallibles)]
-#![warn(for_loops_over_fallibles)]
-#![warn(for_loops_over_fallibles)]
-#![warn(forgetting_copy_types)]
-#![warn(forgetting_references)]
-#![warn(array_into_iter)]
-#![warn(invalid_atomic_ordering)]
-#![warn(invalid_value)]
-#![warn(invalid_from_utf8_unchecked)]
-#![warn(let_underscore_drop)]
-#![warn(enum_intrinsics_non_enums)]
-#![warn(non_fmt_panics)]
-#![warn(named_arguments_used_positionally)]
-#![warn(temporary_cstring_as_ptr)]
-#![warn(undropped_manually_drops)]
-#![warn(unknown_lints)]
-#![warn(unused_labels)]
-#![warn(ambiguous_wide_pointer_comparisons)]
+#![allow(clippy::reversed_empty_ranges)]
+#![warn(clippy::almost_complete_range)] //~ ERROR: lint `clippy::almost_complete_letter_range`
+#![warn(clippy::disallowed_names)] //~ ERROR: lint `clippy::blacklisted_name`
+#![warn(clippy::blocks_in_conditions)] //~ ERROR: lint `clippy::block_in_if_condition_expr`
+#![warn(clippy::blocks_in_conditions)] //~ ERROR: lint `clippy::block_in_if_condition_stmt`
+#![warn(clippy::blocks_in_conditions)] //~ ERROR: lint `clippy::blocks_in_if_conditions`
+#![warn(clippy::box_collection)] //~ ERROR: lint `clippy::box_vec`
+#![warn(clippy::redundant_static_lifetimes)] //~ ERROR: lint `clippy::const_static_lifetime`
+#![warn(clippy::cognitive_complexity)] //~ ERROR: lint `clippy::cyclomatic_complexity`
+#![warn(clippy::derived_hash_with_manual_eq)] //~ ERROR: lint `clippy::derive_hash_xor_eq`
+#![warn(clippy::disallowed_methods)] //~ ERROR: lint `clippy::disallowed_method`
+#![warn(clippy::disallowed_types)] //~ ERROR: lint `clippy::disallowed_type`
+#![warn(clippy::mixed_read_write_in_expression)] //~ ERROR: lint `clippy::eval_order_dependence`
+#![warn(clippy::manual_find_map)] //~ ERROR: lint `clippy::find_map`
+#![warn(clippy::manual_filter_map)] //~ ERROR: lint `clippy::filter_map`
+#![warn(clippy::useless_conversion)] //~ ERROR: lint `clippy::identity_conversion`
+#![warn(clippy::redundant_pattern_matching)] //~ ERROR: lint `clippy::if_let_redundant_pattern_matching`
+#![warn(clippy::match_result_ok)] //~ ERROR: lint `clippy::if_let_some_result`
+#![warn(clippy::non_canonical_clone_impl)] //~ ERROR: lint `clippy::incorrect_clone_impl_on_copy_type`
+#![warn(clippy::non_canonical_partial_ord_impl)] //~ ERROR: lint `clippy::incorrect_partial_ord_impl_on_ord_type`
+#![warn(clippy::arithmetic_side_effects)] //~ ERROR: lint `clippy::integer_arithmetic`
+#![warn(clippy::overly_complex_bool_expr)] //~ ERROR: lint `clippy::logic_bug`
+#![warn(clippy::new_without_default)] //~ ERROR: lint `clippy::new_without_default_derive`
+#![warn(clippy::bind_instead_of_map)] //~ ERROR: lint `clippy::option_and_then_some`
+#![warn(clippy::expect_used)] //~ ERROR: lint `clippy::option_expect_used`
+#![warn(clippy::map_unwrap_or)] //~ ERROR: lint `clippy::option_map_unwrap_or`
+#![warn(clippy::map_unwrap_or)] //~ ERROR: lint `clippy::option_map_unwrap_or_else`
+#![warn(clippy::unwrap_used)] //~ ERROR: lint `clippy::option_unwrap_used`
+#![warn(clippy::panicking_overflow_checks)] //~ ERROR: lint `clippy::overflow_check_conditional`
+#![warn(clippy::needless_borrow)] //~ ERROR: lint `clippy::ref_in_deref`
+#![warn(clippy::expect_used)] //~ ERROR: lint `clippy::result_expect_used`
+#![warn(clippy::map_unwrap_or)] //~ ERROR: lint `clippy::result_map_unwrap_or_else`
+#![warn(clippy::unwrap_used)] //~ ERROR: lint `clippy::result_unwrap_used`
+#![warn(clippy::single_char_add_str)] //~ ERROR: lint `clippy::single_char_push_str`
+#![warn(clippy::module_name_repetitions)] //~ ERROR: lint `clippy::stutter`
+#![warn(clippy::missing_const_for_thread_local)] //~ ERROR: lint `clippy::thread_local_initializer_can_be_made_const`
+#![warn(clippy::recursive_format_impl)] //~ ERROR: lint `clippy::to_string_in_display`
+#![warn(clippy::unwrap_or_default)] //~ ERROR: lint `clippy::unwrap_or_else_default`
+#![warn(clippy::invisible_characters)] //~ ERROR: lint `clippy::zero_width_space`
+#![warn(invalid_reference_casting)] //~ ERROR: lint `clippy::cast_ref_to_mut`
+#![warn(suspicious_double_ref_op)] //~ ERROR: lint `clippy::clone_double_ref`
+#![warn(invalid_nan_comparisons)] //~ ERROR: lint `clippy::cmp_nan`
+#![warn(drop_bounds)] //~ ERROR: lint `clippy::drop_bounds`
+#![warn(dropping_copy_types)] //~ ERROR: lint `clippy::drop_copy`
+#![warn(dropping_references)] //~ ERROR: lint `clippy::drop_ref`
+#![warn(useless_ptr_null_checks)] //~ ERROR: lint `clippy::fn_null_check`
+#![warn(for_loops_over_fallibles)] //~ ERROR: lint `clippy::for_loop_over_option`
+#![warn(for_loops_over_fallibles)] //~ ERROR: lint `clippy::for_loop_over_result`
+#![warn(for_loops_over_fallibles)] //~ ERROR: lint `clippy::for_loops_over_fallibles`
+#![warn(forgetting_copy_types)] //~ ERROR: lint `clippy::forget_copy`
+#![warn(forgetting_references)] //~ ERROR: lint `clippy::forget_ref`
+#![warn(array_into_iter)] //~ ERROR: lint `clippy::into_iter_on_array`
+#![warn(invalid_atomic_ordering)] //~ ERROR: lint `clippy::invalid_atomic_ordering`
+#![warn(invalid_value)] //~ ERROR: lint `clippy::invalid_ref`
+#![warn(invalid_from_utf8_unchecked)] //~ ERROR: lint `clippy::invalid_utf8_in_unchecked`
+#![warn(let_underscore_drop)] //~ ERROR: lint `clippy::let_underscore_drop`
+#![warn(unexpected_cfgs)] //~ ERROR: lint `clippy::maybe_misused_cfg`
+#![warn(enum_intrinsics_non_enums)] //~ ERROR: lint `clippy::mem_discriminant_non_enum`
+#![warn(unexpected_cfgs)] //~ ERROR: lint `clippy::mismatched_target_os`
+#![warn(non_fmt_panics)] //~ ERROR: lint `clippy::panic_params`
+#![warn(named_arguments_used_positionally)] //~ ERROR: lint `clippy::positional_named_format_parameters`
+#![warn(temporary_cstring_as_ptr)] //~ ERROR: lint `clippy::temporary_cstring_as_ptr`
+#![warn(undropped_manually_drops)] //~ ERROR: lint `clippy::undropped_manually_drops`
+#![warn(unknown_lints)] //~ ERROR: lint `clippy::unknown_clippy_lints`
+#![warn(unused_labels)] //~ ERROR: lint `clippy::unused_label`
+#![warn(ambiguous_wide_pointer_comparisons)] //~ ERROR: lint `clippy::vtable_address_comparisons`
+#![warn(clippy::reversed_empty_ranges)] //~ ERROR: lint `clippy::reverse_range_loop`
fn main() {}
diff --git a/src/tools/clippy/tests/ui/rename.rs b/src/tools/clippy/tests/ui/rename.rs
index 8d0ac3c8f9555..e03df1658ee36 100644
--- a/src/tools/clippy/tests/ui/rename.rs
+++ b/src/tools/clippy/tests/ui/rename.rs
@@ -13,7 +13,10 @@
#![allow(clippy::disallowed_methods)]
#![allow(clippy::disallowed_types)]
#![allow(clippy::mixed_read_write_in_expression)]
+#![allow(clippy::manual_find_map)]
+#![allow(clippy::manual_filter_map)]
#![allow(clippy::useless_conversion)]
+#![allow(clippy::redundant_pattern_matching)]
#![allow(clippy::match_result_ok)]
#![allow(clippy::non_canonical_clone_impl)]
#![allow(clippy::non_canonical_partial_ord_impl)]
@@ -47,6 +50,7 @@
#![allow(invalid_value)]
#![allow(invalid_from_utf8_unchecked)]
#![allow(let_underscore_drop)]
+#![allow(unexpected_cfgs)]
#![allow(enum_intrinsics_non_enums)]
#![allow(non_fmt_panics)]
#![allow(named_arguments_used_positionally)]
@@ -55,65 +59,72 @@
#![allow(unknown_lints)]
#![allow(unused_labels)]
#![allow(ambiguous_wide_pointer_comparisons)]
-#![warn(clippy::almost_complete_letter_range)]
-#![warn(clippy::blacklisted_name)]
-#![warn(clippy::block_in_if_condition_expr)]
-#![warn(clippy::block_in_if_condition_stmt)]
-#![warn(clippy::blocks_in_if_conditions)]
-#![warn(clippy::box_vec)]
-#![warn(clippy::const_static_lifetime)]
-#![warn(clippy::cyclomatic_complexity)]
-#![warn(clippy::derive_hash_xor_eq)]
-#![warn(clippy::disallowed_method)]
-#![warn(clippy::disallowed_type)]
-#![warn(clippy::eval_order_dependence)]
-#![warn(clippy::identity_conversion)]
-#![warn(clippy::if_let_some_result)]
-#![warn(clippy::incorrect_clone_impl_on_copy_type)]
-#![warn(clippy::incorrect_partial_ord_impl_on_ord_type)]
-#![warn(clippy::integer_arithmetic)]
-#![warn(clippy::logic_bug)]
-#![warn(clippy::new_without_default_derive)]
-#![warn(clippy::option_and_then_some)]
-#![warn(clippy::option_expect_used)]
-#![warn(clippy::option_map_unwrap_or)]
-#![warn(clippy::option_map_unwrap_or_else)]
-#![warn(clippy::option_unwrap_used)]
-#![warn(clippy::overflow_check_conditional)]
-#![warn(clippy::ref_in_deref)]
-#![warn(clippy::result_expect_used)]
-#![warn(clippy::result_map_unwrap_or_else)]
-#![warn(clippy::result_unwrap_used)]
-#![warn(clippy::single_char_push_str)]
-#![warn(clippy::stutter)]
-#![warn(clippy::thread_local_initializer_can_be_made_const)]
-#![warn(clippy::to_string_in_display)]
-#![warn(clippy::unwrap_or_else_default)]
-#![warn(clippy::zero_width_space)]
-#![warn(clippy::cast_ref_to_mut)]
-#![warn(clippy::clone_double_ref)]
-#![warn(clippy::cmp_nan)]
-#![warn(clippy::drop_bounds)]
-#![warn(clippy::drop_copy)]
-#![warn(clippy::drop_ref)]
-#![warn(clippy::fn_null_check)]
-#![warn(clippy::for_loop_over_option)]
-#![warn(clippy::for_loop_over_result)]
-#![warn(clippy::for_loops_over_fallibles)]
-#![warn(clippy::forget_copy)]
-#![warn(clippy::forget_ref)]
-#![warn(clippy::into_iter_on_array)]
-#![warn(clippy::invalid_atomic_ordering)]
-#![warn(clippy::invalid_ref)]
-#![warn(clippy::invalid_utf8_in_unchecked)]
-#![warn(clippy::let_underscore_drop)]
-#![warn(clippy::mem_discriminant_non_enum)]
-#![warn(clippy::panic_params)]
-#![warn(clippy::positional_named_format_parameters)]
-#![warn(clippy::temporary_cstring_as_ptr)]
-#![warn(clippy::undropped_manually_drops)]
-#![warn(clippy::unknown_clippy_lints)]
-#![warn(clippy::unused_label)]
-#![warn(clippy::vtable_address_comparisons)]
+#![allow(clippy::reversed_empty_ranges)]
+#![warn(clippy::almost_complete_letter_range)] //~ ERROR: lint `clippy::almost_complete_letter_range`
+#![warn(clippy::blacklisted_name)] //~ ERROR: lint `clippy::blacklisted_name`
+#![warn(clippy::block_in_if_condition_expr)] //~ ERROR: lint `clippy::block_in_if_condition_expr`
+#![warn(clippy::block_in_if_condition_stmt)] //~ ERROR: lint `clippy::block_in_if_condition_stmt`
+#![warn(clippy::blocks_in_if_conditions)] //~ ERROR: lint `clippy::blocks_in_if_conditions`
+#![warn(clippy::box_vec)] //~ ERROR: lint `clippy::box_vec`
+#![warn(clippy::const_static_lifetime)] //~ ERROR: lint `clippy::const_static_lifetime`
+#![warn(clippy::cyclomatic_complexity)] //~ ERROR: lint `clippy::cyclomatic_complexity`
+#![warn(clippy::derive_hash_xor_eq)] //~ ERROR: lint `clippy::derive_hash_xor_eq`
+#![warn(clippy::disallowed_method)] //~ ERROR: lint `clippy::disallowed_method`
+#![warn(clippy::disallowed_type)] //~ ERROR: lint `clippy::disallowed_type`
+#![warn(clippy::eval_order_dependence)] //~ ERROR: lint `clippy::eval_order_dependence`
+#![warn(clippy::find_map)] //~ ERROR: lint `clippy::find_map`
+#![warn(clippy::filter_map)] //~ ERROR: lint `clippy::filter_map`
+#![warn(clippy::identity_conversion)] //~ ERROR: lint `clippy::identity_conversion`
+#![warn(clippy::if_let_redundant_pattern_matching)] //~ ERROR: lint `clippy::if_let_redundant_pattern_matching`
+#![warn(clippy::if_let_some_result)] //~ ERROR: lint `clippy::if_let_some_result`
+#![warn(clippy::incorrect_clone_impl_on_copy_type)] //~ ERROR: lint `clippy::incorrect_clone_impl_on_copy_type`
+#![warn(clippy::incorrect_partial_ord_impl_on_ord_type)] //~ ERROR: lint `clippy::incorrect_partial_ord_impl_on_ord_type`
+#![warn(clippy::integer_arithmetic)] //~ ERROR: lint `clippy::integer_arithmetic`
+#![warn(clippy::logic_bug)] //~ ERROR: lint `clippy::logic_bug`
+#![warn(clippy::new_without_default_derive)] //~ ERROR: lint `clippy::new_without_default_derive`
+#![warn(clippy::option_and_then_some)] //~ ERROR: lint `clippy::option_and_then_some`
+#![warn(clippy::option_expect_used)] //~ ERROR: lint `clippy::option_expect_used`
+#![warn(clippy::option_map_unwrap_or)] //~ ERROR: lint `clippy::option_map_unwrap_or`
+#![warn(clippy::option_map_unwrap_or_else)] //~ ERROR: lint `clippy::option_map_unwrap_or_else`
+#![warn(clippy::option_unwrap_used)] //~ ERROR: lint `clippy::option_unwrap_used`
+#![warn(clippy::overflow_check_conditional)] //~ ERROR: lint `clippy::overflow_check_conditional`
+#![warn(clippy::ref_in_deref)] //~ ERROR: lint `clippy::ref_in_deref`
+#![warn(clippy::result_expect_used)] //~ ERROR: lint `clippy::result_expect_used`
+#![warn(clippy::result_map_unwrap_or_else)] //~ ERROR: lint `clippy::result_map_unwrap_or_else`
+#![warn(clippy::result_unwrap_used)] //~ ERROR: lint `clippy::result_unwrap_used`
+#![warn(clippy::single_char_push_str)] //~ ERROR: lint `clippy::single_char_push_str`
+#![warn(clippy::stutter)] //~ ERROR: lint `clippy::stutter`
+#![warn(clippy::thread_local_initializer_can_be_made_const)] //~ ERROR: lint `clippy::thread_local_initializer_can_be_made_const`
+#![warn(clippy::to_string_in_display)] //~ ERROR: lint `clippy::to_string_in_display`
+#![warn(clippy::unwrap_or_else_default)] //~ ERROR: lint `clippy::unwrap_or_else_default`
+#![warn(clippy::zero_width_space)] //~ ERROR: lint `clippy::zero_width_space`
+#![warn(clippy::cast_ref_to_mut)] //~ ERROR: lint `clippy::cast_ref_to_mut`
+#![warn(clippy::clone_double_ref)] //~ ERROR: lint `clippy::clone_double_ref`
+#![warn(clippy::cmp_nan)] //~ ERROR: lint `clippy::cmp_nan`
+#![warn(clippy::drop_bounds)] //~ ERROR: lint `clippy::drop_bounds`
+#![warn(clippy::drop_copy)] //~ ERROR: lint `clippy::drop_copy`
+#![warn(clippy::drop_ref)] //~ ERROR: lint `clippy::drop_ref`
+#![warn(clippy::fn_null_check)] //~ ERROR: lint `clippy::fn_null_check`
+#![warn(clippy::for_loop_over_option)] //~ ERROR: lint `clippy::for_loop_over_option`
+#![warn(clippy::for_loop_over_result)] //~ ERROR: lint `clippy::for_loop_over_result`
+#![warn(clippy::for_loops_over_fallibles)] //~ ERROR: lint `clippy::for_loops_over_fallibles`
+#![warn(clippy::forget_copy)] //~ ERROR: lint `clippy::forget_copy`
+#![warn(clippy::forget_ref)] //~ ERROR: lint `clippy::forget_ref`
+#![warn(clippy::into_iter_on_array)] //~ ERROR: lint `clippy::into_iter_on_array`
+#![warn(clippy::invalid_atomic_ordering)] //~ ERROR: lint `clippy::invalid_atomic_ordering`
+#![warn(clippy::invalid_ref)] //~ ERROR: lint `clippy::invalid_ref`
+#![warn(clippy::invalid_utf8_in_unchecked)] //~ ERROR: lint `clippy::invalid_utf8_in_unchecked`
+#![warn(clippy::let_underscore_drop)] //~ ERROR: lint `clippy::let_underscore_drop`
+#![warn(clippy::maybe_misused_cfg)] //~ ERROR: lint `clippy::maybe_misused_cfg`
+#![warn(clippy::mem_discriminant_non_enum)] //~ ERROR: lint `clippy::mem_discriminant_non_enum`
+#![warn(clippy::mismatched_target_os)] //~ ERROR: lint `clippy::mismatched_target_os`
+#![warn(clippy::panic_params)] //~ ERROR: lint `clippy::panic_params`
+#![warn(clippy::positional_named_format_parameters)] //~ ERROR: lint `clippy::positional_named_format_parameters`
+#![warn(clippy::temporary_cstring_as_ptr)] //~ ERROR: lint `clippy::temporary_cstring_as_ptr`
+#![warn(clippy::undropped_manually_drops)] //~ ERROR: lint `clippy::undropped_manually_drops`
+#![warn(clippy::unknown_clippy_lints)] //~ ERROR: lint `clippy::unknown_clippy_lints`
+#![warn(clippy::unused_label)] //~ ERROR: lint `clippy::unused_label`
+#![warn(clippy::vtable_address_comparisons)] //~ ERROR: lint `clippy::vtable_address_comparisons`
+#![warn(clippy::reverse_range_loop)] //~ ERROR: lint `clippy::reverse_range_loop`
fn main() {}
diff --git a/src/tools/clippy/tests/ui/rename.stderr b/src/tools/clippy/tests/ui/rename.stderr
index d6637324a030b..46d9f0fac59f9 100644
--- a/src/tools/clippy/tests/ui/rename.stderr
+++ b/src/tools/clippy/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
error: lint `clippy::almost_complete_letter_range` has been renamed to `clippy::almost_complete_range`
- --> tests/ui/rename.rs:58:9
+ --> tests/ui/rename.rs:63:9
|
LL | #![warn(clippy::almost_complete_letter_range)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::almost_complete_range`
@@ -8,358 +8,394 @@ LL | #![warn(clippy::almost_complete_letter_range)]
= help: to override `-D warnings` add `#[allow(renamed_and_removed_lints)]`
error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
- --> tests/ui/rename.rs:59:9
+ --> tests/ui/rename.rs:64:9
|
LL | #![warn(clippy::blacklisted_name)]
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_conditions`
- --> tests/ui/rename.rs:60:9
+ --> tests/ui/rename.rs:65:9
|
LL | #![warn(clippy::block_in_if_condition_expr)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_conditions`
- --> tests/ui/rename.rs:61:9
+ --> tests/ui/rename.rs:66:9
|
LL | #![warn(clippy::block_in_if_condition_stmt)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
error: lint `clippy::blocks_in_if_conditions` has been renamed to `clippy::blocks_in_conditions`
- --> tests/ui/rename.rs:62:9
+ --> tests/ui/rename.rs:67:9
|
LL | #![warn(clippy::blocks_in_if_conditions)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
- --> tests/ui/rename.rs:63:9
+ --> tests/ui/rename.rs:68:9
|
LL | #![warn(clippy::box_vec)]
| ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
- --> tests/ui/rename.rs:64:9
+ --> tests/ui/rename.rs:69:9
|
LL | #![warn(clippy::const_static_lifetime)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
- --> tests/ui/rename.rs:65:9
+ --> tests/ui/rename.rs:70:9
|
LL | #![warn(clippy::cyclomatic_complexity)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
error: lint `clippy::derive_hash_xor_eq` has been renamed to `clippy::derived_hash_with_manual_eq`
- --> tests/ui/rename.rs:66:9
+ --> tests/ui/rename.rs:71:9
|
LL | #![warn(clippy::derive_hash_xor_eq)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::derived_hash_with_manual_eq`
error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
- --> tests/ui/rename.rs:67:9
+ --> tests/ui/rename.rs:72:9
|
LL | #![warn(clippy::disallowed_method)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
- --> tests/ui/rename.rs:68:9
+ --> tests/ui/rename.rs:73:9
|
LL | #![warn(clippy::disallowed_type)]
| ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
- --> tests/ui/rename.rs:69:9
+ --> tests/ui/rename.rs:74:9
|
LL | #![warn(clippy::eval_order_dependence)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
+error: lint `clippy::find_map` has been renamed to `clippy::manual_find_map`
+ --> tests/ui/rename.rs:75:9
+ |
+LL | #![warn(clippy::find_map)]
+ | ^^^^^^^^^^^^^^^^ help: use the new name: `clippy::manual_find_map`
+
+error: lint `clippy::filter_map` has been renamed to `clippy::manual_filter_map`
+ --> tests/ui/rename.rs:76:9
+ |
+LL | #![warn(clippy::filter_map)]
+ | ^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::manual_filter_map`
+
error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
- --> tests/ui/rename.rs:70:9
+ --> tests/ui/rename.rs:77:9
|
LL | #![warn(clippy::identity_conversion)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
+error: lint `clippy::if_let_redundant_pattern_matching` has been renamed to `clippy::redundant_pattern_matching`
+ --> tests/ui/rename.rs:78:9
+ |
+LL | #![warn(clippy::if_let_redundant_pattern_matching)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_pattern_matching`
+
error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
- --> tests/ui/rename.rs:71:9
+ --> tests/ui/rename.rs:79:9
|
LL | #![warn(clippy::if_let_some_result)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
error: lint `clippy::incorrect_clone_impl_on_copy_type` has been renamed to `clippy::non_canonical_clone_impl`
- --> tests/ui/rename.rs:72:9
+ --> tests/ui/rename.rs:80:9
|
LL | #![warn(clippy::incorrect_clone_impl_on_copy_type)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::non_canonical_clone_impl`
error: lint `clippy::incorrect_partial_ord_impl_on_ord_type` has been renamed to `clippy::non_canonical_partial_ord_impl`
- --> tests/ui/rename.rs:73:9
+ --> tests/ui/rename.rs:81:9
|
LL | #![warn(clippy::incorrect_partial_ord_impl_on_ord_type)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::non_canonical_partial_ord_impl`
error: lint `clippy::integer_arithmetic` has been renamed to `clippy::arithmetic_side_effects`
- --> tests/ui/rename.rs:74:9
+ --> tests/ui/rename.rs:82:9
|
LL | #![warn(clippy::integer_arithmetic)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::arithmetic_side_effects`
error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
- --> tests/ui/rename.rs:75:9
+ --> tests/ui/rename.rs:83:9
|
LL | #![warn(clippy::logic_bug)]
| ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
- --> tests/ui/rename.rs:76:9
+ --> tests/ui/rename.rs:84:9
|
LL | #![warn(clippy::new_without_default_derive)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
- --> tests/ui/rename.rs:77:9
+ --> tests/ui/rename.rs:85:9
|
LL | #![warn(clippy::option_and_then_some)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
- --> tests/ui/rename.rs:78:9
+ --> tests/ui/rename.rs:86:9
|
LL | #![warn(clippy::option_expect_used)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
- --> tests/ui/rename.rs:79:9
+ --> tests/ui/rename.rs:87:9
|
LL | #![warn(clippy::option_map_unwrap_or)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
- --> tests/ui/rename.rs:80:9
+ --> tests/ui/rename.rs:88:9
|
LL | #![warn(clippy::option_map_unwrap_or_else)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
- --> tests/ui/rename.rs:81:9
+ --> tests/ui/rename.rs:89:9
|
LL | #![warn(clippy::option_unwrap_used)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
error: lint `clippy::overflow_check_conditional` has been renamed to `clippy::panicking_overflow_checks`
- --> tests/ui/rename.rs:82:9
+ --> tests/ui/rename.rs:90:9
|
LL | #![warn(clippy::overflow_check_conditional)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::panicking_overflow_checks`
error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
- --> tests/ui/rename.rs:83:9
+ --> tests/ui/rename.rs:91:9
|
LL | #![warn(clippy::ref_in_deref)]
| ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
- --> tests/ui/rename.rs:84:9
+ --> tests/ui/rename.rs:92:9
|
LL | #![warn(clippy::result_expect_used)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
- --> tests/ui/rename.rs:85:9
+ --> tests/ui/rename.rs:93:9
|
LL | #![warn(clippy::result_map_unwrap_or_else)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
- --> tests/ui/rename.rs:86:9
+ --> tests/ui/rename.rs:94:9
|
LL | #![warn(clippy::result_unwrap_used)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
- --> tests/ui/rename.rs:87:9
+ --> tests/ui/rename.rs:95:9
|
LL | #![warn(clippy::single_char_push_str)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
- --> tests/ui/rename.rs:88:9
+ --> tests/ui/rename.rs:96:9
|
LL | #![warn(clippy::stutter)]
| ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
error: lint `clippy::thread_local_initializer_can_be_made_const` has been renamed to `clippy::missing_const_for_thread_local`
- --> tests/ui/rename.rs:89:9
+ --> tests/ui/rename.rs:97:9
|
LL | #![warn(clippy::thread_local_initializer_can_be_made_const)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::missing_const_for_thread_local`
error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
- --> tests/ui/rename.rs:90:9
+ --> tests/ui/rename.rs:98:9
|
LL | #![warn(clippy::to_string_in_display)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
error: lint `clippy::unwrap_or_else_default` has been renamed to `clippy::unwrap_or_default`
- --> tests/ui/rename.rs:91:9
+ --> tests/ui/rename.rs:99:9
|
LL | #![warn(clippy::unwrap_or_else_default)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_or_default`
error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
- --> tests/ui/rename.rs:92:9
+ --> tests/ui/rename.rs:100:9
|
LL | #![warn(clippy::zero_width_space)]
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
error: lint `clippy::cast_ref_to_mut` has been renamed to `invalid_reference_casting`
- --> tests/ui/rename.rs:93:9
+ --> tests/ui/rename.rs:101:9
|
LL | #![warn(clippy::cast_ref_to_mut)]
| ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_reference_casting`
error: lint `clippy::clone_double_ref` has been renamed to `suspicious_double_ref_op`
- --> tests/ui/rename.rs:94:9
+ --> tests/ui/rename.rs:102:9
|
LL | #![warn(clippy::clone_double_ref)]
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `suspicious_double_ref_op`
error: lint `clippy::cmp_nan` has been renamed to `invalid_nan_comparisons`
- --> tests/ui/rename.rs:95:9
+ --> tests/ui/rename.rs:103:9
|
LL | #![warn(clippy::cmp_nan)]
| ^^^^^^^^^^^^^^^ help: use the new name: `invalid_nan_comparisons`
error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
- --> tests/ui/rename.rs:96:9
+ --> tests/ui/rename.rs:104:9
|
LL | #![warn(clippy::drop_bounds)]
| ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
error: lint `clippy::drop_copy` has been renamed to `dropping_copy_types`
- --> tests/ui/rename.rs:97:9
+ --> tests/ui/rename.rs:105:9
|
LL | #![warn(clippy::drop_copy)]
| ^^^^^^^^^^^^^^^^^ help: use the new name: `dropping_copy_types`
error: lint `clippy::drop_ref` has been renamed to `dropping_references`
- --> tests/ui/rename.rs:98:9
+ --> tests/ui/rename.rs:106:9
|
LL | #![warn(clippy::drop_ref)]
| ^^^^^^^^^^^^^^^^ help: use the new name: `dropping_references`
error: lint `clippy::fn_null_check` has been renamed to `useless_ptr_null_checks`
- --> tests/ui/rename.rs:99:9
+ --> tests/ui/rename.rs:107:9
|
LL | #![warn(clippy::fn_null_check)]
| ^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `useless_ptr_null_checks`
error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
- --> tests/ui/rename.rs:100:9
+ --> tests/ui/rename.rs:108:9
|
LL | #![warn(clippy::for_loop_over_option)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
- --> tests/ui/rename.rs:101:9
+ --> tests/ui/rename.rs:109:9
|
LL | #![warn(clippy::for_loop_over_result)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
- --> tests/ui/rename.rs:102:9
+ --> tests/ui/rename.rs:110:9
|
LL | #![warn(clippy::for_loops_over_fallibles)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
error: lint `clippy::forget_copy` has been renamed to `forgetting_copy_types`
- --> tests/ui/rename.rs:103:9
+ --> tests/ui/rename.rs:111:9
|
LL | #![warn(clippy::forget_copy)]
| ^^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_copy_types`
error: lint `clippy::forget_ref` has been renamed to `forgetting_references`
- --> tests/ui/rename.rs:104:9
+ --> tests/ui/rename.rs:112:9
|
LL | #![warn(clippy::forget_ref)]
| ^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_references`
error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
- --> tests/ui/rename.rs:105:9
+ --> tests/ui/rename.rs:113:9
|
LL | #![warn(clippy::into_iter_on_array)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
- --> tests/ui/rename.rs:106:9
+ --> tests/ui/rename.rs:114:9
|
LL | #![warn(clippy::invalid_atomic_ordering)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
- --> tests/ui/rename.rs:107:9
+ --> tests/ui/rename.rs:115:9
|
LL | #![warn(clippy::invalid_ref)]
| ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
error: lint `clippy::invalid_utf8_in_unchecked` has been renamed to `invalid_from_utf8_unchecked`
- --> tests/ui/rename.rs:108:9
+ --> tests/ui/rename.rs:116:9
|
LL | #![warn(clippy::invalid_utf8_in_unchecked)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_from_utf8_unchecked`
error: lint `clippy::let_underscore_drop` has been renamed to `let_underscore_drop`
- --> tests/ui/rename.rs:109:9
+ --> tests/ui/rename.rs:117:9
|
LL | #![warn(clippy::let_underscore_drop)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
+error: lint `clippy::maybe_misused_cfg` has been renamed to `unexpected_cfgs`
+ --> tests/ui/rename.rs:118:9
+ |
+LL | #![warn(clippy::maybe_misused_cfg)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unexpected_cfgs`
+
error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
- --> tests/ui/rename.rs:110:9
+ --> tests/ui/rename.rs:119:9
|
LL | #![warn(clippy::mem_discriminant_non_enum)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
+error: lint `clippy::mismatched_target_os` has been renamed to `unexpected_cfgs`
+ --> tests/ui/rename.rs:120:9
+ |
+LL | #![warn(clippy::mismatched_target_os)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unexpected_cfgs`
+
error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
- --> tests/ui/rename.rs:111:9
+ --> tests/ui/rename.rs:121:9
|
LL | #![warn(clippy::panic_params)]
| ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
- --> tests/ui/rename.rs:112:9
+ --> tests/ui/rename.rs:122:9
|
LL | #![warn(clippy::positional_named_format_parameters)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
- --> tests/ui/rename.rs:113:9
+ --> tests/ui/rename.rs:123:9
|
LL | #![warn(clippy::temporary_cstring_as_ptr)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
error: lint `clippy::undropped_manually_drops` has been renamed to `undropped_manually_drops`
- --> tests/ui/rename.rs:114:9
+ --> tests/ui/rename.rs:124:9
|
LL | #![warn(clippy::undropped_manually_drops)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `undropped_manually_drops`
error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
- --> tests/ui/rename.rs:115:9
+ --> tests/ui/rename.rs:125:9
|
LL | #![warn(clippy::unknown_clippy_lints)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
error: lint `clippy::unused_label` has been renamed to `unused_labels`
- --> tests/ui/rename.rs:116:9
+ --> tests/ui/rename.rs:126:9
|
LL | #![warn(clippy::unused_label)]
| ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
error: lint `clippy::vtable_address_comparisons` has been renamed to `ambiguous_wide_pointer_comparisons`
- --> tests/ui/rename.rs:117:9
+ --> tests/ui/rename.rs:127:9
|
LL | #![warn(clippy::vtable_address_comparisons)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `ambiguous_wide_pointer_comparisons`
-error: aborting due to 60 previous errors
+error: lint `clippy::reverse_range_loop` has been renamed to `clippy::reversed_empty_ranges`
+ --> tests/ui/rename.rs:128:9
+ |
+LL | #![warn(clippy::reverse_range_loop)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::reversed_empty_ranges`
+
+error: aborting due to 66 previous errors
diff --git a/src/tools/clippy/tests/ui/set_contains_or_insert.rs b/src/tools/clippy/tests/ui/set_contains_or_insert.rs
index 8465007402ab0..d3a3e1c878b3a 100644
--- a/src/tools/clippy/tests/ui/set_contains_or_insert.rs
+++ b/src/tools/clippy/tests/ui/set_contains_or_insert.rs
@@ -3,17 +3,78 @@
#![allow(clippy::needless_borrow)]
#![warn(clippy::set_contains_or_insert)]
-use std::collections::HashSet;
+use std::collections::{BTreeSet, HashSet};
-fn main() {
- should_warn_cases();
+fn should_warn_hashset() {
+ let mut set = HashSet::new();
+ let value = 5;
+
+ if !set.contains(&value) {
+ set.insert(value);
+ println!("Just a comment");
+ }
+
+ if set.contains(&value) {
+ set.insert(value);
+ println!("Just a comment");
+ }
+
+ if !set.contains(&value) {
+ set.insert(value);
+ }
- should_not_warn_cases();
+ if !!set.contains(&value) {
+ set.insert(value);
+ println!("Just a comment");
+ }
+
+ if (&set).contains(&value) {
+ set.insert(value);
+ }
+
+ let borrow_value = &6;
+ if !set.contains(borrow_value) {
+ set.insert(*borrow_value);
+ }
+
+ let borrow_set = &mut set;
+ if !borrow_set.contains(&value) {
+ borrow_set.insert(value);
+ }
}
-fn should_warn_cases() {
+fn should_not_warn_hashset() {
let mut set = HashSet::new();
let value = 5;
+ let another_value = 6;
+
+ if !set.contains(&value) {
+ set.insert(another_value);
+ }
+
+ if !set.contains(&value) {
+ println!("Just a comment");
+ }
+
+ if simply_true() {
+ set.insert(value);
+ }
+
+ if !set.contains(&value) {
+ set.replace(value); //it is not insert
+ println!("Just a comment");
+ }
+
+ if set.contains(&value) {
+ println!("value is already in set");
+ } else {
+ set.insert(value);
+ }
+}
+
+fn should_warn_btreeset() {
+ let mut set = BTreeSet::new();
+ let value = 5;
if !set.contains(&value) {
set.insert(value);
@@ -49,8 +110,8 @@ fn should_warn_cases() {
}
}
-fn should_not_warn_cases() {
- let mut set = HashSet::new();
+fn should_not_warn_btreeset() {
+ let mut set = BTreeSet::new();
let value = 5;
let another_value = 6;
@@ -81,3 +142,11 @@ fn should_not_warn_cases() {
fn simply_true() -> bool {
true
}
+
+// This is placed last in order to be able to add new tests without changing line numbers
+fn main() {
+ should_warn_hashset();
+ should_warn_btreeset();
+ should_not_warn_hashset();
+ should_not_warn_btreeset();
+}
diff --git a/src/tools/clippy/tests/ui/set_contains_or_insert.stderr b/src/tools/clippy/tests/ui/set_contains_or_insert.stderr
index 507e20964fc20..14ad630054482 100644
--- a/src/tools/clippy/tests/ui/set_contains_or_insert.stderr
+++ b/src/tools/clippy/tests/ui/set_contains_or_insert.stderr
@@ -1,5 +1,5 @@
error: usage of `HashSet::insert` after `HashSet::contains`
- --> tests/ui/set_contains_or_insert.rs:18:13
+ --> tests/ui/set_contains_or_insert.rs:12:13
|
LL | if !set.contains(&value) {
| ^^^^^^^^^^^^^^^^
@@ -10,7 +10,7 @@ LL | set.insert(value);
= help: to override `-D warnings` add `#[allow(clippy::set_contains_or_insert)]`
error: usage of `HashSet::insert` after `HashSet::contains`
- --> tests/ui/set_contains_or_insert.rs:23:12
+ --> tests/ui/set_contains_or_insert.rs:17:12
|
LL | if set.contains(&value) {
| ^^^^^^^^^^^^^^^^
@@ -18,7 +18,7 @@ LL | set.insert(value);
| ^^^^^^^^^^^^^
error: usage of `HashSet::insert` after `HashSet::contains`
- --> tests/ui/set_contains_or_insert.rs:28:13
+ --> tests/ui/set_contains_or_insert.rs:22:13
|
LL | if !set.contains(&value) {
| ^^^^^^^^^^^^^^^^
@@ -26,7 +26,7 @@ LL | set.insert(value);
| ^^^^^^^^^^^^^
error: usage of `HashSet::insert` after `HashSet::contains`
- --> tests/ui/set_contains_or_insert.rs:32:14
+ --> tests/ui/set_contains_or_insert.rs:26:14
|
LL | if !!set.contains(&value) {
| ^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL | set.insert(value);
| ^^^^^^^^^^^^^
error: usage of `HashSet::insert` after `HashSet::contains`
- --> tests/ui/set_contains_or_insert.rs:37:15
+ --> tests/ui/set_contains_or_insert.rs:31:15
|
LL | if (&set).contains(&value) {
| ^^^^^^^^^^^^^^^^
@@ -42,7 +42,7 @@ LL | set.insert(value);
| ^^^^^^^^^^^^^
error: usage of `HashSet::insert` after `HashSet::contains`
- --> tests/ui/set_contains_or_insert.rs:42:13
+ --> tests/ui/set_contains_or_insert.rs:36:13
|
LL | if !set.contains(borrow_value) {
| ^^^^^^^^^^^^^^^^^^^^^^
@@ -50,12 +50,68 @@ LL | set.insert(*borrow_value);
| ^^^^^^^^^^^^^^^^^^^^^
error: usage of `HashSet::insert` after `HashSet::contains`
- --> tests/ui/set_contains_or_insert.rs:47:20
+ --> tests/ui/set_contains_or_insert.rs:41:20
|
LL | if !borrow_set.contains(&value) {
| ^^^^^^^^^^^^^^^^
LL | borrow_set.insert(value);
| ^^^^^^^^^^^^^
-error: aborting due to 7 previous errors
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+ --> tests/ui/set_contains_or_insert.rs:79:13
+ |
+LL | if !set.contains(&value) {
+ | ^^^^^^^^^^^^^^^^
+LL | set.insert(value);
+ | ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+ --> tests/ui/set_contains_or_insert.rs:84:12
+ |
+LL | if set.contains(&value) {
+ | ^^^^^^^^^^^^^^^^
+LL | set.insert(value);
+ | ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+ --> tests/ui/set_contains_or_insert.rs:89:13
+ |
+LL | if !set.contains(&value) {
+ | ^^^^^^^^^^^^^^^^
+LL | set.insert(value);
+ | ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+ --> tests/ui/set_contains_or_insert.rs:93:14
+ |
+LL | if !!set.contains(&value) {
+ | ^^^^^^^^^^^^^^^^
+LL | set.insert(value);
+ | ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+ --> tests/ui/set_contains_or_insert.rs:98:15
+ |
+LL | if (&set).contains(&value) {
+ | ^^^^^^^^^^^^^^^^
+LL | set.insert(value);
+ | ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+ --> tests/ui/set_contains_or_insert.rs:103:13
+ |
+LL | if !set.contains(borrow_value) {
+ | ^^^^^^^^^^^^^^^^^^^^^^
+LL | set.insert(*borrow_value);
+ | ^^^^^^^^^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+ --> tests/ui/set_contains_or_insert.rs:108:20
+ |
+LL | if !borrow_set.contains(&value) {
+ | ^^^^^^^^^^^^^^^^
+LL | borrow_set.insert(value);
+ | ^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors
diff --git a/src/tools/clippy/tests/ui/single_match.fixed b/src/tools/clippy/tests/ui/single_match.fixed
index acd70416d8bf0..5249c4408899a 100644
--- a/src/tools/clippy/tests/ui/single_match.fixed
+++ b/src/tools/clippy/tests/ui/single_match.fixed
@@ -253,3 +253,46 @@ mod issue8634 {
}
}
}
+
+fn issue11365() {
+ enum Foo {
+ A,
+ B,
+ C,
+ }
+ use Foo::{A, B, C};
+
+ match Some(A) {
+ Some(A | B | C) => println!(),
+ None => {},
+ }
+
+ match Some(A) {
+ Some(A | B) => println!(),
+ Some { 0: C } | None => {},
+ }
+
+ match [A, A] {
+ [A, _] => println!(),
+ [_, A | B | C] => {},
+ }
+
+ match Ok::<_, u32>(Some(A)) {
+ Ok(Some(A)) => println!(),
+ Err(_) | Ok(None | Some(B | C)) => {},
+ }
+
+ if let Ok(Some(A)) = Ok::<_, u32>(Some(A)) { println!() }
+
+ match &Some(A) {
+ Some(A | B | C) => println!(),
+ None => {},
+ }
+
+ match &Some(A) {
+ &Some(A | B | C) => println!(),
+ None => {},
+ }
+
+ if let Some(A | B) = &Some(A) { println!() }
+}
diff --git a/src/tools/clippy/tests/ui/single_match.rs b/src/tools/clippy/tests/ui/single_match.rs
index bde7819981089..882098a56e780 100644
--- a/src/tools/clippy/tests/ui/single_match.rs
+++ b/src/tools/clippy/tests/ui/single_match.rs
@@ -311,3 +311,52 @@ mod issue8634 {
}
}
}
+
+fn issue11365() {
+ enum Foo {
+ A,
+ B,
+ C,
+ }
+ use Foo::{A, B, C};
+
+ match Some(A) {
+ Some(A | B | C) => println!(),
+ None => {},
+ }
+
+ match Some(A) {
+ Some(A | B) => println!(),
+ Some { 0: C } | None => {},
+ }
+
+ match [A, A] {
+ [A, _] => println!(),
+ [_, A | B | C] => {},
+ }
+
+ match Ok::<_, u32>(Some(A)) {
+ Ok(Some(A)) => println!(),
+ Err(_) | Ok(None | Some(B | C)) => {},
+ }
+
+ match Ok::<_, u32>(Some(A)) {
+ Ok(Some(A)) => println!(),
+ Err(_) | Ok(None | Some(_)) => {},
+ }
+
+ match &Some(A) {
+ Some(A | B | C) => println!(),
+ None => {},
+ }
+
+ match &Some(A) {
+ &Some(A | B | C) => println!(),
+ None => {},
+ }
+
+ match &Some(A) {
+ Some(A | B) => println!(),
+ None | Some(_) => {},
+ }
+}
diff --git a/src/tools/clippy/tests/ui/single_match.stderr b/src/tools/clippy/tests/ui/single_match.stderr
index a249c120ee4a4..ceb2a193bf7b1 100644
--- a/src/tools/clippy/tests/ui/single_match.stderr
+++ b/src/tools/clippy/tests/ui/single_match.stderr
@@ -198,5 +198,23 @@ LL + }
LL + }
|
-error: aborting due to 18 previous errors
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ --> tests/ui/single_match.rs:343:5
+ |
+LL | / match Ok::<_, u32>(Some(A)) {
+LL | | Ok(Some(A)) => println!(),
+LL | | Err(_) | Ok(None | Some(_)) => {},
+LL | | }
+ | |_____^ help: try: `if let Ok(Some(A)) = Ok::<_, u32>(Some(A)) { println!() }`
+
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ --> tests/ui/single_match.rs:358:5
+ |
+LL | / match &Some(A) {
+LL | | Some(A | B) => println!(),
+LL | | None | Some(_) => {},
+LL | | }
+ | |_____^ help: try: `if let Some(A | B) = &Some(A) { println!() }`
+
+error: aborting due to 20 previous errors
diff --git a/src/tools/clippy/tests/ui/std_instead_of_core.fixed b/src/tools/clippy/tests/ui/std_instead_of_core.fixed
index 6ede7bfcd9f66..227b98c683e97 100644
--- a/src/tools/clippy/tests/ui/std_instead_of_core.fixed
+++ b/src/tools/clippy/tests/ui/std_instead_of_core.fixed
@@ -75,8 +75,17 @@ mod std_in_proc_macro_derive {
struct B {}
}
-fn main() {
- std_instead_of_core();
- std_instead_of_alloc();
- alloc_instead_of_core();
+// Some intrinsics are usable on stable but live in an unstable module, but should still suggest
+// replacing std -> core
+fn intrinsic(a: *mut u8, b: *mut u8) {
+ unsafe {
+ core::intrinsics::copy(a, b, 1);
+ //~^ std_instead_of_core
+ }
}
+
+#[clippy::msrv = "1.76"]
+fn msrv_1_76(_: std::net::IpAddr) {}
+
+#[clippy::msrv = "1.77"]
+fn msrv_1_77(_: core::net::IpAddr) {}
diff --git a/src/tools/clippy/tests/ui/std_instead_of_core.rs b/src/tools/clippy/tests/ui/std_instead_of_core.rs
index e22b4f61f3ecc..01bb78dd3bf1d 100644
--- a/src/tools/clippy/tests/ui/std_instead_of_core.rs
+++ b/src/tools/clippy/tests/ui/std_instead_of_core.rs
@@ -75,8 +75,17 @@ mod std_in_proc_macro_derive {
struct B {}
}
-fn main() {
- std_instead_of_core();
- std_instead_of_alloc();
- alloc_instead_of_core();
+// Some intrinsics are usable on stable but live in an unstable module, but should still suggest
+// replacing std -> core
+fn intrinsic(a: *mut u8, b: *mut u8) {
+ unsafe {
+ std::intrinsics::copy(a, b, 1);
+ //~^ std_instead_of_core
+ }
}
+
+#[clippy::msrv = "1.76"]
+fn msrv_1_76(_: std::net::IpAddr) {}
+
+#[clippy::msrv = "1.77"]
+fn msrv_1_77(_: std::net::IpAddr) {}
diff --git a/src/tools/clippy/tests/ui/std_instead_of_core.stderr b/src/tools/clippy/tests/ui/std_instead_of_core.stderr
index 22cb9db7050b8..45d60d235ceb3 100644
--- a/src/tools/clippy/tests/ui/std_instead_of_core.stderr
+++ b/src/tools/clippy/tests/ui/std_instead_of_core.stderr
@@ -85,5 +85,17 @@ LL | use alloc::slice::from_ref;
= note: `-D clippy::alloc-instead-of-core` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::alloc_instead_of_core)]`
-error: aborting due to 13 previous errors
+error: used import from `std` instead of `core`
+ --> tests/ui/std_instead_of_core.rs:82:9
+ |
+LL | std::intrinsics::copy(a, b, 1);
+ | ^^^ help: consider importing the item from `core`: `core`
+
+error: used import from `std` instead of `core`
+ --> tests/ui/std_instead_of_core.rs:91:17
+ |
+LL | fn msrv_1_77(_: std::net::IpAddr) {}
+ | ^^^ help: consider importing the item from `core`: `core`
+
+error: aborting due to 15 previous errors
diff --git a/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.stderr b/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.stderr
index 4faf0237c17ad..43b03676b1db5 100644
--- a/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.stderr
@@ -2,51 +2,84 @@ error: `^` is not the exponentiation operator
--> tests/ui/suspicious_xor_used_as_pow.rs:19:13
|
LL | let _ = 2 ^ 5;
- | ^^^^^ help: did you mean to write: `2.pow(5)`
+ | ^^^^^
|
= note: `-D clippy::suspicious-xor-used-as-pow` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::suspicious_xor_used_as_pow)]`
+help: did you mean to write
+ |
+LL | let _ = 2.pow(5);
+ | ~~~~~~~~
error: `^` is not the exponentiation operator
--> tests/ui/suspicious_xor_used_as_pow.rs:22:13
|
LL | let _ = 2i32 ^ 9i32;
- | ^^^^^^^^^^^ help: did you mean to write: `2i32.pow(9i32)`
+ | ^^^^^^^^^^^
+ |
+help: did you mean to write
+ |
+LL | let _ = 2i32.pow(9i32);
+ | ~~~~~~~~~~~~~~
error: `^` is not the exponentiation operator
--> tests/ui/suspicious_xor_used_as_pow.rs:24:13
|
LL | let _ = 2i32 ^ 2i32;
- | ^^^^^^^^^^^ help: did you mean to write: `2i32.pow(2i32)`
+ | ^^^^^^^^^^^
+ |
+help: did you mean to write
+ |
+LL | let _ = 2i32.pow(2i32);
+ | ~~~~~~~~~~~~~~
error: `^` is not the exponentiation operator
--> tests/ui/suspicious_xor_used_as_pow.rs:26:13
|
LL | let _ = 50i32 ^ 3i32;
- | ^^^^^^^^^^^^ help: did you mean to write: `50i32.pow(3i32)`
+ | ^^^^^^^^^^^^
+ |
+help: did you mean to write
+ |
+LL | let _ = 50i32.pow(3i32);
+ | ~~~~~~~~~~~~~~~
error: `^` is not the exponentiation operator
--> tests/ui/suspicious_xor_used_as_pow.rs:28:13
|
LL | let _ = 5i32 ^ 8i32;
- | ^^^^^^^^^^^ help: did you mean to write: `5i32.pow(8i32)`
+ | ^^^^^^^^^^^
+ |
+help: did you mean to write
+ |
+LL | let _ = 5i32.pow(8i32);
+ | ~~~~~~~~~~~~~~
error: `^` is not the exponentiation operator
--> tests/ui/suspicious_xor_used_as_pow.rs:30:13
|
LL | let _ = 2i32 ^ 32i32;
- | ^^^^^^^^^^^^ help: did you mean to write: `2i32.pow(32i32)`
+ | ^^^^^^^^^^^^
+ |
+help: did you mean to write
+ |
+LL | let _ = 2i32.pow(32i32);
+ | ~~~~~~~~~~~~~~~
error: `^` is not the exponentiation operator
--> tests/ui/suspicious_xor_used_as_pow.rs:13:9
|
LL | 1 ^ 2 // should warn even if inside macro
- | ^^^^^ help: did you mean to write: `1.pow(2)`
+ | ^^^^^
...
LL | macro_test_inside!();
| -------------------- in this macro invocation
|
= note: this error originates in the macro `macro_test_inside` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: did you mean to write
+ |
+LL | 1.pow(2) // should warn even if inside macro
+ | ~~~~~~~~
error: aborting due to 7 previous errors
diff --git a/src/tools/clippy/tests/ui/try_err.fixed b/src/tools/clippy/tests/ui/try_err.fixed
index aae4f8ac47f82..f149bfb77740c 100644
--- a/src/tools/clippy/tests/ui/try_err.fixed
+++ b/src/tools/clippy/tests/ui/try_err.fixed
@@ -1,5 +1,5 @@
//@aux-build:proc_macros.rs
-
+#![feature(try_blocks)]
#![deny(clippy::try_err)]
#![allow(
clippy::unnecessary_wraps,
@@ -152,3 +152,11 @@ pub fn try_return(x: bool) -> Result<i32, i32> {
}
Ok(0)
}
+
+// Test that the lint is suppressed in try block.
+pub fn try_block() -> Result<(), i32> {
+ let _: Result<_, i32> = try {
+ Err(1)?;
+ };
+ Ok(())
+}
diff --git a/src/tools/clippy/tests/ui/try_err.rs b/src/tools/clippy/tests/ui/try_err.rs
index 927eccf2d54c5..841ec6b5d5c77 100644
--- a/src/tools/clippy/tests/ui/try_err.rs
+++ b/src/tools/clippy/tests/ui/try_err.rs
@@ -1,5 +1,5 @@
//@aux-build:proc_macros.rs
-
+#![feature(try_blocks)]
#![deny(clippy::try_err)]
#![allow(
clippy::unnecessary_wraps,
@@ -152,3 +152,11 @@ pub fn try_return(x: bool) -> Result<i32, i32> {
}
Ok(0)
}
+
+// Test that the lint is suppressed in try block.
+pub fn try_block() -> Result<(), i32> {
+ let _: Result<_, i32> = try {
+ Err(1)?;
+ };
+ Ok(())
+}
diff --git a/src/tools/clippy/tests/ui/uninit_vec.rs b/src/tools/clippy/tests/ui/uninit_vec.rs
index 58729a97d57bb..0cc77a8775d57 100644
--- a/src/tools/clippy/tests/ui/uninit_vec.rs
+++ b/src/tools/clippy/tests/ui/uninit_vec.rs
@@ -1,7 +1,7 @@
#![warn(clippy::uninit_vec)]
-use std::mem::MaybeUninit;
use std::cell::UnsafeCell;
+use std::mem::MaybeUninit;
#[derive(Default)]
struct MyVec {
diff --git a/src/tools/clippy/tests/ui/unneeded_field_pattern.rs b/src/tools/clippy/tests/ui/unneeded_field_pattern.rs
index 0dc21f4ce945d..1d42f81711bd6 100644
--- a/src/tools/clippy/tests/ui/unneeded_field_pattern.rs
+++ b/src/tools/clippy/tests/ui/unneeded_field_pattern.rs
@@ -1,6 +1,6 @@
//@aux-build:proc_macros.rs
#![warn(clippy::unneeded_field_pattern)]
-#![allow(dead_code, unused)]
+#![allow(dead_code, unused, clippy::single_match)]
#[macro_use]
extern crate proc_macros;
diff --git a/src/tools/clippy/tests/ui/unused_result_ok.fixed b/src/tools/clippy/tests/ui/unused_result_ok.fixed
new file mode 100644
index 0000000000000..e78fde5c9e3cc
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unused_result_ok.fixed
@@ -0,0 +1,40 @@
+//@aux-build:proc_macros.rs
+#![warn(clippy::unused_result_ok)]
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn bad_style(x: &str) {
+ let _ = x.parse::<u32>();
+}
+
+fn good_style(x: &str) -> Option<u32> {
+ x.parse::<u32>().ok()
+}
+
+#[rustfmt::skip]
+fn strange_parse(x: &str) {
+ let _ = x . parse::<i32>();
+}
+
+macro_rules! v {
+ () => {
+ Ok::<(), ()>(())
+ };
+}
+
+macro_rules! w {
+ () => {
+ let _ = Ok::<(), ()>(());
+ };
+}
+
+fn main() {
+ let _ = v!();
+ w!();
+
+ external! {
+ Ok::<(),()>(()).ok();
+ };
+}
diff --git a/src/tools/clippy/tests/ui/unused_result_ok.rs b/src/tools/clippy/tests/ui/unused_result_ok.rs
new file mode 100644
index 0000000000000..117d64c4cec60
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unused_result_ok.rs
@@ -0,0 +1,40 @@
+//@aux-build:proc_macros.rs
+#![warn(clippy::unused_result_ok)]
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn bad_style(x: &str) {
+ x.parse::<u32>().ok();
+}
+
+fn good_style(x: &str) -> Option<u32> {
+ x.parse::<u32>().ok()
+}
+
+#[rustfmt::skip]
+fn strange_parse(x: &str) {
+ x . parse::<i32>() . ok ();
+}
+
+macro_rules! v {
+ () => {
+ Ok::<(), ()>(())
+ };
+}
+
+macro_rules! w {
+ () => {
+ Ok::<(), ()>(()).ok();
+ };
+}
+
+fn main() {
+ v!().ok();
+ w!();
+
+ external! {
+ Ok::<(),()>(()).ok();
+ };
+}
diff --git a/src/tools/clippy/tests/ui/unused_result_ok.stderr b/src/tools/clippy/tests/ui/unused_result_ok.stderr
new file mode 100644
index 0000000000000..241e0c71261e3
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unused_result_ok.stderr
@@ -0,0 +1,52 @@
+error: ignoring a result with `.ok()` is misleading
+ --> tests/ui/unused_result_ok.rs:9:5
+ |
+LL | x.parse::<u32>().ok();
+ | ^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `-D clippy::unused-result-ok` implied by `-D warnings`
+ = help: to override `-D warnings` add `#[allow(clippy::unused_result_ok)]`
+help: consider using `let _ =` and removing the call to `.ok()` instead
+ |
+LL | let _ = x.parse::<u32>();
+ | ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: ignoring a result with `.ok()` is misleading
+ --> tests/ui/unused_result_ok.rs:18:5
+ |
+LL | x . parse::<i32>() . ok ();
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider using `let _ =` and removing the call to `.ok()` instead
+ |
+LL | let _ = x . parse::<i32>();
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: ignoring a result with `.ok()` is misleading
+ --> tests/ui/unused_result_ok.rs:34:5
+ |
+LL | v!().ok();
+ | ^^^^^^^^^
+ |
+help: consider using `let _ =` and removing the call to `.ok()` instead
+ |
+LL | let _ = v!();
+ | ~~~~~~~~~~~~
+
+error: ignoring a result with `.ok()` is misleading
+ --> tests/ui/unused_result_ok.rs:29:9
+ |
+LL | Ok::<(), ()>(()).ok();
+ | ^^^^^^^^^^^^^^^^^^^^^
+...
+LL | w!();
+ | ---- in this macro invocation
+ |
+ = note: this error originates in the macro `w` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider using `let _ =` and removing the call to `.ok()` instead
+ |
+LL | let _ = Ok::<(), ()>(());
+ | ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 4 previous errors
+
diff --git a/src/tools/clippy/tests/ui/unwrap_expect_used.rs b/src/tools/clippy/tests/ui/unwrap_expect_used.rs
index 96368a0705361..a56bd0a8d0790 100644
--- a/src/tools/clippy/tests/ui/unwrap_expect_used.rs
+++ b/src/tools/clippy/tests/ui/unwrap_expect_used.rs
@@ -31,7 +31,7 @@ fn main() {
// Don't trigger on unwrap_err on an option
Some(3).unwrap_err();
- Some(3).expect_err("Hellow none!");
+ Some(3).expect_err("Hello none!");
// Issue #11245: The `Err` variant can never be constructed so do not lint this.
let x: Result<(), !> = Ok(());
diff --git a/src/tools/clippy/tests/ui/while_let_on_iterator.fixed b/src/tools/clippy/tests/ui/while_let_on_iterator.fixed
index 59b5c858d0460..b8087c6e000f5 100644
--- a/src/tools/clippy/tests/ui/while_let_on_iterator.fixed
+++ b/src/tools/clippy/tests/ui/while_let_on_iterator.fixed
@@ -456,6 +456,15 @@ fn fn_once_closure() {
});
}
+fn issue13123() {
+ let mut it = 0..20;
+ 'label: for n in it {
+ if n % 25 == 0 {
+ break 'label;
+ }
+ }
+}
+
fn main() {
let mut it = 0..20;
for _ in it {
diff --git a/src/tools/clippy/tests/ui/while_let_on_iterator.rs b/src/tools/clippy/tests/ui/while_let_on_iterator.rs
index 559513d56946d..8e02f59b51265 100644
--- a/src/tools/clippy/tests/ui/while_let_on_iterator.rs
+++ b/src/tools/clippy/tests/ui/while_let_on_iterator.rs
@@ -456,6 +456,15 @@ fn fn_once_closure() {
});
}
+fn issue13123() {
+ let mut it = 0..20;
+ 'label: while let Some(n) = it.next() {
+ if n % 25 == 0 {
+ break 'label;
+ }
+ }
+}
+
fn main() {
let mut it = 0..20;
while let Some(..) = it.next() {
diff --git a/src/tools/clippy/tests/ui/while_let_on_iterator.stderr b/src/tools/clippy/tests/ui/while_let_on_iterator.stderr
index 8ff1f23644b16..d96b26acf345d 100644
--- a/src/tools/clippy/tests/ui/while_let_on_iterator.stderr
+++ b/src/tools/clippy/tests/ui/while_let_on_iterator.stderr
@@ -160,8 +160,14 @@ LL | while let Some(x) = it.next() {
error: this loop could be written as a `for` loop
--> tests/ui/while_let_on_iterator.rs:461:5
|
+LL | 'label: while let Some(n) = it.next() {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'label: for n in it`
+
+error: this loop could be written as a `for` loop
+ --> tests/ui/while_let_on_iterator.rs:470:5
+ |
LL | while let Some(..) = it.next() {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
-error: aborting due to 27 previous errors
+error: aborting due to 28 previous errors
diff --git a/src/tools/clippy/tests/versioncheck.rs b/src/tools/clippy/tests/versioncheck.rs
index eba5405e67ed2..6832833393766 100644
--- a/src/tools/clippy/tests/versioncheck.rs
+++ b/src/tools/clippy/tests/versioncheck.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)]
#![allow(clippy::single_match_else)]
diff --git a/src/tools/clippy/tests/workspace_test/path_dep/Cargo.toml b/src/tools/clippy/tests/workspace_test/path_dep/Cargo.toml
index 85a91cd2decd5..98b4fb7aa5042 100644
--- a/src/tools/clippy/tests/workspace_test/path_dep/Cargo.toml
+++ b/src/tools/clippy/tests/workspace_test/path_dep/Cargo.toml
@@ -1,3 +1,6 @@
[package]
name = "path_dep"
version = "0.1.0"
+
+[features]
+primary_package_test = []
diff --git a/src/tools/clippy/util/gh-pages/index.html b/src/tools/clippy/util/gh-pages/index.html
index 0c0f28e4fbd3d..300c9de178f2b 100644
--- a/src/tools/clippy/util/gh-pages/index.html
+++ b/src/tools/clippy/util/gh-pages/index.html
@@ -541,7 +541,7 @@ <h1>Clippy Lints</h1>
<div class="col-12 col-md-5 search-control">
<div class="input-group">
<label class="input-group-addon" id="filter-label" for="search-input">Filter:</label>
- <input type="text" class="form-control filter-input" placeholder="Keywords or search string" id="search-input"
+ <input type="text" class="form-control filter-input" placeholder="Keywords or search string (`S` or `/` to focus)" id="search-input"
ng-model="search" ng-blur="updatePath()" ng-keyup="$event.keyCode == 13 && updatePath()"
ng-model-options="{debounce: 50}" />
<span class="input-group-btn">
@@ -605,7 +605,7 @@ <h2 class="panel-title">
<a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a>
</div>
<!-- Jump to source -->
- <div class="lint-additional-info-item">
+ <div class="lint-additional-info-item" ng-if="lint.id_span">
<a href="https://github.com/rust-lang/rust-clippy/blob/{{docVersion}}/clippy_lints/{{lint.id_span.path}}#L{{lint.id_span.line}}">View Source</a>
</div>
</div>
diff --git a/src/tools/clippy/util/gh-pages/script.js b/src/tools/clippy/util/gh-pages/script.js
index 661f80a6d3468..ed1e090e1b540 100644
--- a/src/tools/clippy/util/gh-pages/script.js
+++ b/src/tools/clippy/util/gh-pages/script.js
@@ -1,5 +1,5 @@
(function () {
- var md = window.markdownit({
+ const md = window.markdownit({
html: true,
linkify: true,
typographer: true,
@@ -17,7 +17,7 @@
});
function scrollToLint(lintId) {
- var target = document.getElementById(lintId);
+ const target = document.getElementById(lintId);
if (!target) {
return;
}
@@ -25,21 +25,17 @@
}
function scrollToLintByURL($scope, $location) {
- var removeListener = $scope.$on('ngRepeatFinished', function (ngRepeatFinishedEvent) {
+ const removeListener = $scope.$on('ngRepeatFinished', function (ngRepeatFinishedEvent) {
scrollToLint($location.path().substring(1));
removeListener();
});
}
function selectGroup($scope, selectedGroup) {
- var groups = $scope.groups;
- for (var group in groups) {
+ const groups = $scope.groups;
+ for (const group in groups) {
if (groups.hasOwnProperty(group)) {
- if (group === selectedGroup) {
- groups[group] = true;
- } else {
- groups[group] = false;
- }
+ groups[group] = group === selectedGroup;
}
}
}
@@ -108,7 +104,7 @@
})
.controller("lintList", function ($scope, $http, $location, $timeout) {
// Level filter
- var LEVEL_FILTERS_DEFAULT = {allow: true, warn: true, deny: true, none: true};
+ const LEVEL_FILTERS_DEFAULT = {allow: true, warn: true, deny: true, none: true};
$scope.levels = { ...LEVEL_FILTERS_DEFAULT };
$scope.byLevels = function (lint) {
return $scope.levels[lint.level];
@@ -367,7 +363,7 @@
}
$scope.clearVersionFilters = function () {
- for (let filter in $scope.versionFilters) {
+ for (const filter in $scope.versionFilters) {
$scope.versionFilters[filter] = { enabled: false, minorVersion: null };
}
}
@@ -378,7 +374,7 @@
$scope.updateVersionFilters = function() {
for (const filter in $scope.versionFilters) {
- let minorVersion = $scope.versionFilters[filter].minorVersion;
+ const minorVersion = $scope.versionFilters[filter].minorVersion;
// 1.29.0 and greater
if (minorVersion && minorVersion > 28) {
@@ -391,14 +387,14 @@
}
$scope.byVersion = function(lint) {
- let filters = $scope.versionFilters;
+ const filters = $scope.versionFilters;
for (const filter in filters) {
if (filters[filter].enabled) {
- let minorVersion = filters[filter].minorVersion;
+ const minorVersion = filters[filter].minorVersion;
// Strip the "pre " prefix for pre 1.29.0 lints
- let lintVersion = lint.version.startsWith("pre ") ? lint.version.substring(4, lint.version.length) : lint.version;
- let lintMinorVersion = lintVersion.substring(2, 4);
+ const lintVersion = lint.version.startsWith("pre ") ? lint.version.substring(4, lint.version.length) : lint.version;
+ const lintMinorVersion = lintVersion.substring(2, 4);
switch (filter) {
// "=" gets the highest priority, since all filters are inclusive
@@ -441,8 +437,8 @@
// Search the description
// The use of `for`-loops instead of `foreach` enables us to return early
- let terms = searchStr.split(" ");
- let docsLowerCase = lint.docs.toLowerCase();
+ const terms = searchStr.split(" ");
+ const docsLowerCase = lint.docs.toLowerCase();
for (index = 0; index < terms.length; index++) {
// This is more likely and will therefore be checked first
if (docsLowerCase.indexOf(terms[index]) !== -1) {
@@ -479,7 +475,7 @@
const clipboard = document.getElementById("clipboard-" + lint.id);
if (clipboard) {
let resetClipboardTimeout = null;
- let resetClipboardIcon = clipboard.innerHTML;
+ const resetClipboardIcon = clipboard.innerHTML;
function resetClipboard() {
resetClipboardTimeout = null;
@@ -511,7 +507,7 @@
$scope.data = data;
$scope.loading = false;
- var selectedGroup = getQueryVariable("sel");
+ const selectedGroup = getQueryVariable("sel");
if (selectedGroup) {
selectGroup($scope, selectedGroup.toLowerCase());
}
@@ -519,7 +515,7 @@
scrollToLintByURL($scope, $location);
setTimeout(function () {
- var el = document.getElementById('filter-input');
+ const el = document.getElementById('filter-input');
if (el) { el.focus() }
}, 0);
})
@@ -531,10 +527,10 @@
})();
function getQueryVariable(variable) {
- var query = window.location.search.substring(1);
- var vars = query.split('&');
- for (var i = 0; i < vars.length; i++) {
- var pair = vars[i].split('=');
+ const query = window.location.search.substring(1);
+ const vars = query.split('&');
+ for (const entry of vars) {
+ const pair = entry.split('=');
if (decodeURIComponent(pair[0]) == variable) {
return decodeURIComponent(pair[1]);
}
@@ -579,6 +575,32 @@ function setTheme(theme, store) {
}
}
+function handleShortcut(ev) {
+ if (ev.ctrlKey || ev.altKey || ev.metaKey) {
+ return;
+ }
+
+ if (document.activeElement.tagName === "INPUT") {
+ if (ev.key === "Escape") {
+ document.activeElement.blur();
+ }
+ } else {
+ switch (ev.key) {
+ case "s":
+ case "S":
+ case "/":
+ ev.preventDefault(); // To prevent the key to be put into the input.
+ document.getElementById("search-input").focus();
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+document.addEventListener("keypress", handleShortcut);
+document.addEventListener("keydown", handleShortcut);
+
// loading the theme after the initial load
const prefersDark = window.matchMedia("(prefers-color-scheme: dark)");
const theme = localStorage.getItem('clippy-lint-list-theme');
diff --git a/tests/rustdoc-json/impls/pub_for_hidden_private.rs b/tests/rustdoc-json/impls/pub_for_hidden_private.rs
new file mode 100644
index 0000000000000..261ffbfeb4a4c
--- /dev/null
+++ b/tests/rustdoc-json/impls/pub_for_hidden_private.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: --document-private-items --document-hidden-items
+
+pub trait TheTrait {}
+
+#[doc(hidden)]
+struct Value {}
+
+//@ has '$.index[*][?(@.docs=="THE IMPL")]'
+/// THE IMPL
+impl TheTrait for Value {}
diff --git a/tests/rustdoc-json/pub_mod_in_private_mod.rs b/tests/rustdoc-json/pub_mod_in_private_mod.rs
new file mode 100644
index 0000000000000..112ab9c68f002
--- /dev/null
+++ b/tests/rustdoc-json/pub_mod_in_private_mod.rs
@@ -0,0 +1,6 @@
+// See https://github.com/rust-lang/rust/issues/101105
+
+//@ !has "$.index[*][?(@.name=='nucleus')]"
+mod corpus {
+ pub mod nucleus {}
+}
diff --git a/tests/ui/async-await/async-closures/fn-exception-target-features.rs b/tests/ui/async-await/async-closures/fn-exception-target-features.rs
new file mode 100644
index 0000000000000..de62fc8bf7e3c
--- /dev/null
+++ b/tests/ui/async-await/async-closures/fn-exception-target-features.rs
@@ -0,0 +1,17 @@
+//@ edition: 2021
+//@ only-x86_64
+
+#![feature(async_closure, target_feature_11)]
+// `target_feature_11` just to test safe functions w/ target features.
+
+use std::pin::Pin;
+use std::future::Future;
+
+#[target_feature(enable = "sse2")]
+fn target_feature() -> Pin<Box<dyn Future<Output = ()> + 'static>> { todo!() }
+
+fn test(f: impl async Fn()) {}
+
+fn main() {
+ test(target_feature); //~ ERROR the trait bound
+}
diff --git a/tests/ui/async-await/async-closures/fn-exception-target-features.stderr b/tests/ui/async-await/async-closures/fn-exception-target-features.stderr
new file mode 100644
index 0000000000000..396167f407055
--- /dev/null
+++ b/tests/ui/async-await/async-closures/fn-exception-target-features.stderr
@@ -0,0 +1,17 @@
+error[E0277]: the trait bound `fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {target_feature}: AsyncFn<()>` is not satisfied
+ --> $DIR/fn-exception-target-features.rs:16:10
+ |
+LL | test(target_feature);
+ | ---- ^^^^^^^^^^^^^^ the trait `AsyncFn<()>` is not implemented for fn item `fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {target_feature}`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `test`
+ --> $DIR/fn-exception-target-features.rs:13:17
+ |
+LL | fn test(f: impl async Fn()) {}
+ | ^^^^^^^^^^ required by this bound in `test`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/async-closures/fn-exception.rs b/tests/ui/async-await/async-closures/fn-exception.rs
new file mode 100644
index 0000000000000..0e06ebf48a4be
--- /dev/null
+++ b/tests/ui/async-await/async-closures/fn-exception.rs
@@ -0,0 +1,21 @@
+//@ edition: 2021
+
+#![feature(async_closure)]
+
+use std::pin::Pin;
+use std::future::Future;
+
+unsafe extern "Rust" {
+ pub unsafe fn unsafety() -> Pin<Box<dyn Future<Output = ()> + 'static>>;
+}
+
+unsafe extern "C" {
+ pub safe fn abi() -> Pin<Box<dyn Future<Output = ()> + 'static>>;
+}
+
+fn test(f: impl async Fn()) {}
+
+fn main() {
+ test(unsafety); //~ ERROR the trait bound
+ test(abi); //~ ERROR the trait bound
+}
diff --git a/tests/ui/async-await/async-closures/fn-exception.stderr b/tests/ui/async-await/async-closures/fn-exception.stderr
new file mode 100644
index 0000000000000..bacd079af0f2d
--- /dev/null
+++ b/tests/ui/async-await/async-closures/fn-exception.stderr
@@ -0,0 +1,31 @@
+error[E0277]: the trait bound `unsafe fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {unsafety}: AsyncFn<()>` is not satisfied
+ --> $DIR/fn-exception.rs:19:10
+ |
+LL | test(unsafety);
+ | ---- ^^^^^^^^ the trait `AsyncFn<()>` is not implemented for fn item `unsafe fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {unsafety}`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `test`
+ --> $DIR/fn-exception.rs:16:17
+ |
+LL | fn test(f: impl async Fn()) {}
+ | ^^^^^^^^^^ required by this bound in `test`
+
+error[E0277]: the trait bound `extern "C" fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {abi}: AsyncFn<()>` is not satisfied
+ --> $DIR/fn-exception.rs:20:10
+ |
+LL | test(abi);
+ | ---- ^^^ the trait `AsyncFn<()>` is not implemented for fn item `extern "C" fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {abi}`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `test`
+ --> $DIR/fn-exception.rs:16:17
+ |
+LL | fn test(f: impl async Fn()) {}
+ | ^^^^^^^^^^ required by this bound in `test`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.