Mirrors/rust-clippy
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-clippy synced 2024-11-24 05:33:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #12867 - flip1995:rustup, r=flip1995

Browse source 
Rustup

r? `@ghost`

changelog: none
This commit is contained in:
bors 2024-05-30 08:11:24 +00:00
commit c9139bd546
40 changed files with 169 additions and 154 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
clippy_dev/src/lib.rs
View file

@ -1,4 +1,3 @@
#![feature(lazy_cell)]
#![feature(let_chains)] #![feature(let_chains)]
#![feature(rustc_private)] #![feature(rustc_private)]
#![cfg_attr(feature = "deny-warnings", deny(warnings))] #![cfg_attr(feature = "deny-warnings", deny(warnings))]

8
clippy_lints/src/derive.rs
View file

@ -5,13 +5,13 @@ use rustc_errors::Applicability;
use rustc_hir::def_id::DefId; use rustc_hir::def_id::DefId;
use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, Visitor}; use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, Visitor};
use rustc_hir::{ use rustc_hir::{
self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, Impl, Item, ItemKind, UnsafeSource, Unsafety, self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, Impl, Item, ItemKind, Safety, UnsafeSource,
}; };
use rustc_lint::{LateContext, LateLintPass}; use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::hir::nested_filter; use rustc_middle::hir::nested_filter;
use rustc_middle::traits::Reveal; use rustc_middle::traits::Reveal;
use rustc_middle::ty::{ use rustc_middle::ty::{
self, ClauseKind, GenericArgKind, GenericParamDefKind, ParamEnv, ToPredicate, TraitPredicate, Ty, TyCtxt, self, ClauseKind, GenericArgKind, GenericParamDefKind, ParamEnv, TraitPredicate, Ty, TyCtxt, Upcast,
}; };
use rustc_session::declare_lint_pass; use rustc_session::declare_lint_pass;
use rustc_span::def_id::LocalDefId; use rustc_span::def_id::LocalDefId;
@ -419,7 +419,7 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
} }
if let Some(header) = kind.header() if let Some(header) = kind.header()
&& header.unsafety == Unsafety::Unsafe && header.safety == Safety::Unsafe
{ {
self.has_unsafe = true; self.has_unsafe = true;
} }
@ -514,7 +514,7 @@ fn param_env_for_derived_eq(tcx: TyCtxt<'_>, did: DefId, eq_trait_id: DefId) ->
trait_ref: ty::TraitRef::new(tcx, eq_trait_id, [tcx.mk_param_from_def(param)]), trait_ref: ty::TraitRef::new(tcx, eq_trait_id, [tcx.mk_param_from_def(param)]),
polarity: ty::PredicatePolarity::Positive, polarity: ty::PredicatePolarity::Positive,
}) })
.to_predicate(tcx) .upcast(tcx)
}), }),
)), )),
Reveal::UserFacing, Reveal::UserFacing,

8
clippy_lints/src/doc/missing_headers.rs
View file

@ -2,7 +2,7 @@ use super::{DocHeaders, MISSING_ERRORS_DOC, MISSING_PANICS_DOC, MISSING_SAFETY_D
use clippy_utils::diagnostics::{span_lint, span_lint_and_note}; use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
use clippy_utils::ty::{implements_trait, is_type_diagnostic_item}; use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
use clippy_utils::{is_doc_hidden, return_ty}; use clippy_utils::{is_doc_hidden, return_ty};
use rustc_hir::{BodyId, FnSig, OwnerId, Unsafety}; use rustc_hir::{BodyId, FnSig, OwnerId, Safety};
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::ty; use rustc_middle::ty;
use rustc_span::{sym, Span}; use rustc_span::{sym, Span};
@ -32,14 +32,14 @@ pub fn check(
} }
let span = cx.tcx.def_span(owner_id); let span = cx.tcx.def_span(owner_id);
match (headers.safety, sig.header.unsafety) { match (headers.safety, sig.header.safety) {
(false, Unsafety::Unsafe) => span_lint( (false, Safety::Unsafe) => span_lint(
cx, cx,
MISSING_SAFETY_DOC, MISSING_SAFETY_DOC,
span, span,
"unsafe function's docs miss `# Safety` section", "unsafe function's docs miss `# Safety` section",
), ),
(true, Unsafety::Normal) => span_lint( (true, Safety::Safe) => span_lint(
cx, cx,
UNNECESSARY_SAFETY_DOC, UNNECESSARY_SAFETY_DOC,
span, span,

6
clippy_lints/src/doc/mod.rs
View file

@ -13,7 +13,7 @@ use pulldown_cmark::{BrokenLink, CodeBlockKind, CowStr, Options};
use rustc_ast::ast::Attribute; use rustc_ast::ast::Attribute;
use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::fx::FxHashSet;
use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::intravisit::{self, Visitor};
use rustc_hir::{AnonConst, Expr, ImplItemKind, ItemKind, Node, TraitItemKind, Unsafety}; use rustc_hir::{AnonConst, Expr, ImplItemKind, ItemKind, Node, Safety, TraitItemKind};
use rustc_lint::{LateContext, LateLintPass, LintContext}; use rustc_lint::{LateContext, LateLintPass, LintContext};
use rustc_middle::hir::nested_filter; use rustc_middle::hir::nested_filter;
use rustc_middle::lint::in_external_macro; use rustc_middle::lint::in_external_macro;
@ -474,13 +474,13 @@ impl<'tcx> LateLintPass<'tcx> for Documentation {
} }
}, },
ItemKind::Trait(_, unsafety, ..) => match (headers.safety, unsafety) { ItemKind::Trait(_, unsafety, ..) => match (headers.safety, unsafety) {
(false, Unsafety::Unsafe) => span_lint( (false, Safety::Unsafe) => span_lint(
cx, cx,
MISSING_SAFETY_DOC, MISSING_SAFETY_DOC,
cx.tcx.def_span(item.owner_id), cx.tcx.def_span(item.owner_id),
"docs for unsafe trait missing `# Safety` section", "docs for unsafe trait missing `# Safety` section",
), ),
(true, Unsafety::Normal) => span_lint( (true, Safety::Safe) => span_lint(
cx, cx,
UNNECESSARY_SAFETY_DOC, UNNECESSARY_SAFETY_DOC,
cx.tcx.def_span(item.owner_id), cx.tcx.def_span(item.owner_id),

12
clippy_lints/src/eta_reduction.rs
View file

@ -5,7 +5,7 @@ use clippy_utils::ty::type_diagnostic_name;
use clippy_utils::usage::{local_used_after_expr, local_used_in}; use clippy_utils::usage::{local_used_after_expr, local_used_in};
use clippy_utils::{get_path_from_caller_to_method_type, is_adjusted, path_to_local, path_to_local_id}; use clippy_utils::{get_path_from_caller_to_method_type, is_adjusted, path_to_local, path_to_local_id};
use rustc_errors::Applicability; use rustc_errors::Applicability;
use rustc_hir::{BindingMode, Expr, ExprKind, FnRetTy, Param, PatKind, QPath, TyKind, Unsafety}; use rustc_hir::{BindingMode, Expr, ExprKind, FnRetTy, Param, PatKind, QPath, Safety, TyKind};
use rustc_infer::infer::TyCtxtInferExt; use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::{LateContext, LateLintPass}; use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::{ use rustc_middle::ty::{
@ -146,7 +146,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
ty::FnPtr(sig) => sig.skip_binder(), ty::FnPtr(sig) => sig.skip_binder(),
ty::Closure(_, subs) => cx ty::Closure(_, subs) => cx
.tcx .tcx
.signature_unclosure(subs.as_closure().sig(), Unsafety::Normal) .signature_unclosure(subs.as_closure().sig(), Safety::Safe)
.skip_binder(), .skip_binder(),
_ => { _ => {
if typeck.type_dependent_def_id(body.value.hir_id).is_some() if typeck.type_dependent_def_id(body.value.hir_id).is_some()
@ -154,7 +154,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
&& let output = typeck.expr_ty(body.value) && let output = typeck.expr_ty(body.value)
&& let ty::Tuple(tys) = *subs.type_at(1).kind() && let ty::Tuple(tys) = *subs.type_at(1).kind()
{ {
cx.tcx.mk_fn_sig(tys, output, false, Unsafety::Normal, Abi::Rust) cx.tcx.mk_fn_sig(tys, output, false, Safety::Safe, Abi::Rust)
} else { } else {
return; return;
} }
@ -241,11 +241,9 @@ fn check_inputs(
} }
fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure: ClosureArgs<'tcx>, call_sig: FnSig<'_>) -> bool { fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure: ClosureArgs<'tcx>, call_sig: FnSig<'_>) -> bool {
call_sig.unsafety == Unsafety::Normal call_sig.safety == Safety::Safe
&& !has_late_bound_to_non_late_bound_regions( && !has_late_bound_to_non_late_bound_regions(
cx.tcx cx.tcx.signature_unclosure(closure.sig(), Safety::Safe).skip_binder(),
.signature_unclosure(closure.sig(), Unsafety::Normal)
.skip_binder(),
call_sig, call_sig,
) )
} }

4
clippy_lints/src/functions/misnamed_getters.rs
View file

@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::snippet; use clippy_utils::source::snippet;
use rustc_errors::Applicability; use rustc_errors::Applicability;
use rustc_hir::intravisit::FnKind; use rustc_hir::intravisit::FnKind;
use rustc_hir::{Body, ExprKind, FnDecl, ImplicitSelfKind, Unsafety}; use rustc_hir::{Body, ExprKind, FnDecl, ImplicitSelfKind, Safety};
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::ty; use rustc_middle::ty;
use rustc_span::Span; use rustc_span::Span;
@ -34,7 +34,7 @@ pub fn check_fn(cx: &LateContext<'_>, kind: FnKind<'_>, decl: &FnDecl<'_>, body:
ImplicitSelfKind::None => return, ImplicitSelfKind::None => return,
}; };
let name = if sig.header.unsafety == Unsafety::Unsafe { let name = if sig.header.safety == Safety::Unsafe {
name.strip_suffix("_unchecked").unwrap_or(name) name.strip_suffix("_unchecked").unwrap_or(name)
} else { } else {
name name

16
clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
View file

@ -19,30 +19,30 @@ pub(super) fn check_fn<'tcx>(
body: &'tcx hir::Body<'tcx>, body: &'tcx hir::Body<'tcx>,
def_id: LocalDefId, def_id: LocalDefId,
) { ) {
let unsafety = match kind { let safety = match kind {
intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }) => unsafety, intravisit::FnKind::ItemFn(_, _, hir::FnHeader { safety, .. }) => safety,
intravisit::FnKind::Method(_, sig) => sig.header.unsafety, intravisit::FnKind::Method(_, sig) => sig.header.safety,
intravisit::FnKind::Closure => return, intravisit::FnKind::Closure => return,
}; };
check_raw_ptr(cx, unsafety, decl, body, def_id); check_raw_ptr(cx, safety, decl, body, def_id);
} }
pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) { pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
if let hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(eid)) = item.kind { if let hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(eid)) = item.kind {
let body = cx.tcx.hir().body(eid); let body = cx.tcx.hir().body(eid);
check_raw_ptr(cx, sig.header.unsafety, sig.decl, body, item.owner_id.def_id); check_raw_ptr(cx, sig.header.safety, sig.decl, body, item.owner_id.def_id);
} }
} }
fn check_raw_ptr<'tcx>( fn check_raw_ptr<'tcx>(
cx: &LateContext<'tcx>, cx: &LateContext<'tcx>,
unsafety: hir::Unsafety, safety: hir::Safety,
decl: &'tcx hir::FnDecl<'tcx>, decl: &'tcx hir::FnDecl<'tcx>,
body: &'tcx hir::Body<'tcx>, body: &'tcx hir::Body<'tcx>,
def_id: LocalDefId, def_id: LocalDefId,
) { ) {
if unsafety == hir::Unsafety::Normal && cx.effective_visibilities.is_exported(def_id) { if safety == hir::Safety::Safe && cx.effective_visibilities.is_exported(def_id) {
let raw_ptrs = iter_input_pats(decl, body) let raw_ptrs = iter_input_pats(decl, body)
.filter_map(|arg| raw_ptr_arg(cx, arg)) .filter_map(|arg| raw_ptr_arg(cx, arg))
.collect::<HirIdSet>(); .collect::<HirIdSet>();
@ -58,7 +58,7 @@ fn check_raw_ptr<'tcx>(
}, },
hir::ExprKind::MethodCall(_, recv, args, _) => { hir::ExprKind::MethodCall(_, recv, args, _) => {
let def_id = typeck.type_dependent_def_id(e.hir_id).unwrap(); let def_id = typeck.type_dependent_def_id(e.hir_id).unwrap();
if cx.tcx.fn_sig(def_id).skip_binder().skip_binder().unsafety == hir::Unsafety::Unsafe { if cx.tcx.fn_sig(def_id).skip_binder().skip_binder().safety == hir::Safety::Unsafe {
check_arg(cx, &raw_ptrs, recv); check_arg(cx, &raw_ptrs, recv);
for arg in args { for arg in args {
check_arg(cx, &raw_ptrs, arg); check_arg(cx, &raw_ptrs, arg);

4
clippy_lints/src/inherent_to_string.rs
View file

@ -1,7 +1,7 @@
use clippy_utils::diagnostics::span_lint_and_help; use clippy_utils::diagnostics::span_lint_and_help;
use clippy_utils::ty::{implements_trait, is_type_lang_item}; use clippy_utils::ty::{implements_trait, is_type_lang_item};
use clippy_utils::{return_ty, trait_ref_of_method}; use clippy_utils::{return_ty, trait_ref_of_method};
use rustc_hir::{GenericParamKind, ImplItem, ImplItemKind, LangItem, Unsafety}; use rustc_hir::{GenericParamKind, ImplItem, ImplItemKind, LangItem, Safety};
use rustc_lint::{LateContext, LateLintPass}; use rustc_lint::{LateContext, LateLintPass};
use rustc_session::declare_lint_pass; use rustc_session::declare_lint_pass;
use rustc_span::sym; use rustc_span::sym;
@ -99,7 +99,7 @@ impl<'tcx> LateLintPass<'tcx> for InherentToString {
if let ImplItemKind::Fn(ref signature, _) = impl_item.kind if let ImplItemKind::Fn(ref signature, _) = impl_item.kind
// #11201 // #11201
&& let header = signature.header && let header = signature.header
&& header.unsafety == Unsafety::Normal && header.safety == Safety::Safe
&& header.abi == Abi::Rust && header.abi == Abi::Rust
&& impl_item.ident.name == sym::to_string && impl_item.ident.name == sym::to_string
&& let decl = signature.decl && let decl = signature.decl

2
clippy_lints/src/iter_without_into_iter.rs
View file

@ -225,7 +225,7 @@ impl {self_ty_without_ref} {{
&& let ImplItemKind::Fn(sig, _) = item.kind && let ImplItemKind::Fn(sig, _) = item.kind
&& let FnRetTy::Return(ret) = sig.decl.output && let FnRetTy::Return(ret) = sig.decl.output
&& is_nameable_in_impl_trait(ret) && is_nameable_in_impl_trait(ret)
&& cx.tcx.generics_of(item_did).own_params.is_empty() && cx.tcx.generics_of(item_did).is_own_empty()
&& sig.decl.implicit_self == expected_implicit_self && sig.decl.implicit_self == expected_implicit_self
&& sig.decl.inputs.len() == 1 && sig.decl.inputs.len() == 1
&& let Some(imp) = get_parent_as_impl(cx.tcx, item.hir_id()) && let Some(imp) = get_parent_as_impl(cx.tcx, item.hir_id())

6
clippy_lints/src/methods/mod.rs
View file

@ -5052,7 +5052,7 @@ fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExpr
} }
const FN_HEADER: hir::FnHeader = hir::FnHeader { const FN_HEADER: hir::FnHeader = hir::FnHeader {
unsafety: hir::Unsafety::Normal, safety: hir::Safety::Safe,
constness: hir::Constness::NotConst, constness: hir::Constness::NotConst,
asyncness: hir::IsAsync::NotAsync, asyncness: hir::IsAsync::NotAsync,
abi: rustc_target::spec::abi::Abi::Rust, abi: rustc_target::spec::abi::Abi::Rust,
@ -5228,7 +5228,5 @@ impl OutType {
} }
fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool { fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
expected.constness == actual.constness expected.constness == actual.constness && expected.safety == actual.safety && expected.asyncness == actual.asyncness
&& expected.unsafety == actual.unsafety
&& expected.asyncness == actual.asyncness
} }

2
clippy_lints/src/methods/needless_collect.rs
View file

@ -127,7 +127,7 @@ pub(super) fn check<'tcx>(
} }
} }
/// checks for for collecting into a (generic) method or function argument /// checks for collecting into a (generic) method or function argument
/// taking an `IntoIterator` /// taking an `IntoIterator`
fn check_collect_into_intoiterator<'tcx>( fn check_collect_into_intoiterator<'tcx>(
cx: &LateContext<'tcx>, cx: &LateContext<'tcx>,

6
clippy_lints/src/multiple_unsafe_ops_per_block.rs
View file

@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::visitors::{for_each_expr_with_closures, Descend, Visitable}; use clippy_utils::visitors::{for_each_expr_with_closures, Descend, Visitable};
use core::ops::ControlFlow::Continue; use core::ops::ControlFlow::Continue;
use hir::def::{DefKind, Res}; use hir::def::{DefKind, Res};
use hir::{BlockCheckMode, ExprKind, QPath, UnOp, Unsafety}; use hir::{BlockCheckMode, ExprKind, QPath, Safety, UnOp};
use rustc_ast::Mutability; use rustc_ast::Mutability;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_lint::{LateContext, LateLintPass}; use rustc_lint::{LateContext, LateLintPass};
@ -133,7 +133,7 @@ fn collect_unsafe_exprs<'tcx>(
ty::FnPtr(sig) => sig, ty::FnPtr(sig) => sig,
_ => return Continue(Descend::Yes), _ => return Continue(Descend::Yes),
}; };
if sig.unsafety() == Unsafety::Unsafe { if sig.safety() == Safety::Unsafe {
unsafe_ops.push(("unsafe function call occurs here", expr.span)); unsafe_ops.push(("unsafe function call occurs here", expr.span));
} }
}, },
@ -144,7 +144,7 @@ fn collect_unsafe_exprs<'tcx>(
.type_dependent_def_id(expr.hir_id) .type_dependent_def_id(expr.hir_id)
.map(|def_id| cx.tcx.fn_sig(def_id)) .map(|def_id| cx.tcx.fn_sig(def_id))
{ {
if sig.skip_binder().unsafety() == Unsafety::Unsafe { if sig.skip_binder().safety() == Safety::Unsafe {
unsafe_ops.push(("unsafe method call occurs here", expr.span)); unsafe_ops.push(("unsafe method call occurs here", expr.span));
} }
} }

2
clippy_lints/src/new_without_default.rs
View file

@ -75,7 +75,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
if let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind { if let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind {
let name = impl_item.ident.name; let name = impl_item.ident.name;
let id = impl_item.owner_id; let id = impl_item.owner_id;
if sig.header.unsafety == hir::Unsafety::Unsafe { if sig.header.safety == hir::Safety::Unsafe {
// can't be implemented for unsafe new // can't be implemented for unsafe new
return; return;
} }

23
clippy_lints/src/ptr.rs
View file

@ -12,7 +12,7 @@ use rustc_hir::hir_id::{HirId, HirIdMap};
use rustc_hir::intravisit::{walk_expr, Visitor}; use rustc_hir::intravisit::{walk_expr, Visitor};
use rustc_hir::{ use rustc_hir::{
self as hir, AnonConst, BinOpKind, BindingMode, Body, Expr, ExprKind, FnRetTy, FnSig, GenericArg, ImplItemKind, self as hir, AnonConst, BinOpKind, BindingMode, Body, Expr, ExprKind, FnRetTy, FnSig, GenericArg, ImplItemKind,
ItemKind, Lifetime, Mutability, Node, Param, PatKind, QPath, TraitFn, TraitItem, TraitItemKind, TyKind, Unsafety, ItemKind, Lifetime, Mutability, Node, Param, PatKind, QPath, Safety, TraitFn, TraitItem, TraitItemKind, TyKind,
}; };
use rustc_infer::infer::TyCtxtInferExt; use rustc_infer::infer::TyCtxtInferExt;
use rustc_infer::traits::{Obligation, ObligationCause}; use rustc_infer::traits::{Obligation, ObligationCause};
@ -460,13 +460,19 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
} }
None None
}) { }) {
if !lifetime.is_anonymous() if let LifetimeName::Param(param_def_id) = lifetime.res
&& !lifetime.is_anonymous()
&& fn_sig && fn_sig
.output() .output()
.walk() .walk()
.filter_map(|arg| { .filter_map(|arg| {
arg.as_region().and_then(|lifetime| match lifetime.kind() { arg.as_region().and_then(|lifetime| match lifetime.kind() {
ty::ReEarlyParam(r) => Some(r.def_id), ty::ReEarlyParam(r) => Some(
cx.tcx
.generics_of(cx.tcx.parent(param_def_id.to_def_id()))
.region_param(r, cx.tcx)
.def_id,
),
ty::ReBound(_, r) => r.kind.get_id(), ty::ReBound(_, r) => r.kind.get_id(),
ty::ReLateParam(r) => r.bound_region.get_id(), ty::ReLateParam(r) => r.bound_region.get_id(),
ty::ReStatic ty::ReStatic
@ -476,14 +482,7 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
| ty::ReError(_) => None, | ty::ReError(_) => None,
}) })
}) })
.any(|def_id| { .any(|def_id| def_id.as_local().is_some_and(|def_id| def_id == param_def_id))
matches!(
lifetime.res,
LifetimeName::Param(param_def_id) if def_id
.as_local()
.is_some_and(|def_id| def_id == param_def_id),
)
})
{ {
// `&Cow<'a, T>` when the return type uses 'a is okay // `&Cow<'a, T>` when the return type uses 'a is okay
return None; return None;
@ -542,7 +541,7 @@ fn check_mut_from_ref<'tcx>(cx: &LateContext<'tcx>, sig: &FnSig<'_>, body: Optio
if let Some(args) = args if let Some(args) = args
&& !args.is_empty() && !args.is_empty()
&& body.map_or(true, |body| { && body.map_or(true, |body| {
sig.header.unsafety == Unsafety::Unsafe || contains_unsafe_block(cx, body.value) sig.header.safety == Safety::Unsafe || contains_unsafe_block(cx, body.value)
}) })
{ {
span_lint_and_then( span_lint_and_then(

2
clippy_lints/src/transmute/transmute_undefined_repr.rs
View file

@ -278,7 +278,7 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
ty = sized_ty; ty = sized_ty;
continue; continue;
} }
if def.repr().inhibit_struct_field_reordering_opt() { if def.repr().inhibit_struct_field_reordering() {
ReducedTy::OrderedFields(Some(sized_ty)) ReducedTy::OrderedFields(Some(sized_ty))
} else { } else {
ReducedTy::UnorderedFields(ty) ReducedTy::UnorderedFields(ty)

4
clippy_lints/src/undocumented_unsafe_blocks.rs
View file

@ -199,7 +199,7 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
let item_has_safety_comment = item_has_safety_comment(cx, item); let item_has_safety_comment = item_has_safety_comment(cx, item);
match (&item.kind, item_has_safety_comment) { match (&item.kind, item_has_safety_comment) {
// lint unsafe impl without safety comment // lint unsafe impl without safety comment
(ItemKind::Impl(impl_), HasSafetyComment::No) if impl_.unsafety == hir::Unsafety::Unsafe => { (ItemKind::Impl(impl_), HasSafetyComment::No) if impl_.safety == hir::Safety::Unsafe => {
if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, item.hir_id()) if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, item.hir_id())
&& !is_unsafe_from_proc_macro(cx, item.span) && !is_unsafe_from_proc_macro(cx, item.span)
{ {
@ -221,7 +221,7 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
} }
}, },
// lint safe impl with unnecessary safety comment // lint safe impl with unnecessary safety comment
(ItemKind::Impl(impl_), HasSafetyComment::Yes(pos)) if impl_.unsafety == hir::Unsafety::Normal => { (ItemKind::Impl(impl_), HasSafetyComment::Yes(pos)) if impl_.safety == hir::Safety::Safe => {
if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) { if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
let (span, help_span) = mk_spans(pos); let (span, help_span) = mk_spans(pos);

16
clippy_utils/src/ast_utils.rs
View file

@ -386,21 +386,21 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
( (
Trait(box ast::Trait { Trait(box ast::Trait {
is_auto: la, is_auto: la,
unsafety: lu, safety: lu,
generics: lg, generics: lg,
bounds: lb, bounds: lb,
items: li, items: li,
}), }),
Trait(box ast::Trait { Trait(box ast::Trait {
is_auto: ra, is_auto: ra,
unsafety: ru, safety: ru,
generics: rg, generics: rg,
bounds: rb, bounds: rb,
items: ri, items: ri,
}), }),
) => { ) => {
la == ra la == ra
&& matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No) && matches!(lu, Safety::Default) == matches!(ru, Safety::Default)
&& eq_generics(lg, rg) && eq_generics(lg, rg)
&& over(lb, rb, eq_generic_bound) && over(lb, rb, eq_generic_bound)
&& over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind)) && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
@ -408,7 +408,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
(TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, eq_generic_bound), (TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, eq_generic_bound),
( (
Impl(box ast::Impl { Impl(box ast::Impl {
unsafety: lu, safety: lu,
polarity: lp, polarity: lp,
defaultness: ld, defaultness: ld,
constness: lc, constness: lc,
@ -418,7 +418,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
items: li, items: li,
}), }),
Impl(box ast::Impl { Impl(box ast::Impl {
unsafety: ru, safety: ru,
polarity: rp, polarity: rp,
defaultness: rd, defaultness: rd,
constness: rc, constness: rc,
@ -428,7 +428,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
items: ri, items: ri,
}), }),
) => { ) => {
matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No) matches!(lu, Safety::Default) == matches!(ru, Safety::Default)
&& matches!(lp, ImplPolarity::Positive) == matches!(rp, ImplPolarity::Positive) && matches!(lp, ImplPolarity::Positive) == matches!(rp, ImplPolarity::Positive)
&& eq_defaultness(*ld, *rd) && eq_defaultness(*ld, *rd)
&& matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No) && matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
@ -605,7 +605,7 @@ fn eq_opt_coroutine_kind(l: Option<CoroutineKind>, r: Option<CoroutineKind>) ->
} }
pub fn eq_fn_header(l: &FnHeader, r: &FnHeader) -> bool { pub fn eq_fn_header(l: &FnHeader, r: &FnHeader) -> bool {
matches!(l.unsafety, Unsafe::No) == matches!(r.unsafety, Unsafe::No) matches!(l.safety, Safety::Default) == matches!(r.safety, Safety::Default)
&& eq_opt_coroutine_kind(l.coroutine_kind, r.coroutine_kind) && eq_opt_coroutine_kind(l.coroutine_kind, r.coroutine_kind)
&& matches!(l.constness, Const::No) == matches!(r.constness, Const::No) && matches!(l.constness, Const::No) == matches!(r.constness, Const::No)
&& eq_ext(&l.ext, &r.ext) && eq_ext(&l.ext, &r.ext)
@ -712,7 +712,7 @@ pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
both(ll, rl, |l, r| eq_id(l.ident, r.ident)) && l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty) both(ll, rl, |l, r| eq_id(l.ident, r.ident)) && l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty)
}, },
(BareFn(l), BareFn(r)) => { (BareFn(l), BareFn(r)) => {
l.unsafety == r.unsafety l.safety == r.safety
&& eq_ext(&l.ext, &r.ext) && eq_ext(&l.ext, &r.ext)
&& over(&l.generic_params, &r.generic_params, eq_generic_param) && over(&l.generic_params, &r.generic_params, eq_generic_param)
&& eq_fn_decl(&l.decl, &r.decl) && eq_fn_decl(&l.decl, &r.decl)

11
clippy_utils/src/check_proc_macro.rs
View file

@ -18,8 +18,8 @@ use rustc_ast::AttrStyle;
use rustc_hir::intravisit::FnKind; use rustc_hir::intravisit::FnKind;
use rustc_hir::{ use rustc_hir::{
Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, FnRetTy, HirId, Impl, Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, FnRetTy, HirId, Impl,
ImplItem, ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, MutTy, Node, QPath, TraitItem, ImplItem, ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, MutTy, Node, QPath, Safety, TraitItem,
TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Unsafety, Variant, VariantData, YieldSource, TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Variant, VariantData, YieldSource,
}; };
use rustc_lint::{LateContext, LintContext}; use rustc_lint::{LateContext, LintContext};
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
@ -207,10 +207,9 @@ fn item_search_pat(item: &Item<'_>) -> (Pat, Pat) {
ItemKind::Struct(VariantData::Struct { .. }, _) => (Pat::Str("struct"), Pat::Str("}")), ItemKind::Struct(VariantData::Struct { .. }, _) => (Pat::Str("struct"), Pat::Str("}")),
ItemKind::Struct(..) => (Pat::Str("struct"), Pat::Str(";")), ItemKind::Struct(..) => (Pat::Str("struct"), Pat::Str(";")),
ItemKind::Union(..) => (Pat::Str("union"), Pat::Str("}")), ItemKind::Union(..) => (Pat::Str("union"), Pat::Str("}")),
ItemKind::Trait(_, Unsafety::Unsafe, ..) ItemKind::Trait(_, Safety::Unsafe, ..)
| ItemKind::Impl(Impl { | ItemKind::Impl(Impl {
unsafety: Unsafety::Unsafe, safety: Safety::Unsafe, ..
..
}) => (Pat::Str("unsafe"), Pat::Str("}")), }) => (Pat::Str("unsafe"), Pat::Str("}")),
ItemKind::Trait(IsAuto::Yes, ..) => (Pat::Str("auto"), Pat::Str("}")), ItemKind::Trait(IsAuto::Yes, ..) => (Pat::Str("auto"), Pat::Str("}")),
ItemKind::Trait(..) => (Pat::Str("trait"), Pat::Str("}")), ItemKind::Trait(..) => (Pat::Str("trait"), Pat::Str("}")),
@ -323,7 +322,7 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ty_search_pat(ty).1), TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ty_search_pat(ty).1),
TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ty_search_pat(ty).1), TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ty_search_pat(ty).1),
TyKind::BareFn(bare_fn) => ( TyKind::BareFn(bare_fn) => (
if bare_fn.unsafety == Unsafety::Unsafe { if bare_fn.safety == Safety::Unsafe {
Pat::Str("unsafe") Pat::Str("unsafe")
} else if bare_fn.abi != Abi::Rust { } else if bare_fn.abi != Abi::Rust {
Pat::Str("extern") Pat::Str("extern")

8
clippy_utils/src/consts.rs
View file

@ -6,7 +6,7 @@ use crate::{clip, is_direct_expn_of, sext, unsext};
use rustc_ast::ast::{self, LitFloatType, LitKind}; use rustc_ast::ast::{self, LitFloatType, LitKind};
use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::Lrc;
use rustc_hir::def::{DefKind, Res}; use rustc_hir::def::{DefKind, Res};
use rustc_hir::{BinOp, BinOpKind, Block, ConstBlock, Expr, ExprKind, HirId, Item, ItemKind, Node, QPath, UnOp}; use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, Item, ItemKind, Node, QPath, UnOp};
use rustc_lexer::tokenize; use rustc_lexer::tokenize;
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::mir::interpret::{alloc_range, Scalar}; use rustc_middle::mir::interpret::{alloc_range, Scalar};
@ -412,8 +412,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
/// Simple constant folding: Insert an expression, get a constant or none. /// Simple constant folding: Insert an expression, get a constant or none.
pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant<'tcx>> { pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
match e.kind { match e.kind {
ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr(self.lcx.tcx.hir().body(body).value), ExprKind::ConstBlock(e) | ExprKind::DropTemps(e) => self.expr(e),
ExprKind::DropTemps(e) => self.expr(e),
ExprKind::Path(ref qpath) => { ExprKind::Path(ref qpath) => {
self.fetch_path_and_apply(qpath, e.hir_id, self.typeck_results.expr_ty(e), |this, result| { 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)?; let result = mir_to_const(this.lcx, result)?;
@ -491,8 +490,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
/// leaves the local crate. /// leaves the local crate.
pub fn expr_is_empty(&mut self, e: &Expr<'_>) -> Option<bool> { pub fn expr_is_empty(&mut self, e: &Expr<'_>) -> Option<bool> {
match e.kind { match e.kind {
ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr_is_empty(self.lcx.tcx.hir().body(body).value), ExprKind::ConstBlock(e) | ExprKind::DropTemps(e) => self.expr_is_empty(e),
ExprKind::DropTemps(e) => self.expr_is_empty(e),
ExprKind::Path(ref qpath) => { ExprKind::Path(ref qpath) => {
if !self if !self
.typeck_results .typeck_results

18
clippy_utils/src/diagnostics.rs
View file

@ -61,7 +61,8 @@ fn docs_link(diag: &mut Diag<'_, ()>, lint: &'static Lint) {
/// ``` /// ```
pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) { pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
#[expect(clippy::disallowed_methods)] #[expect(clippy::disallowed_methods)]
cx.span_lint(lint, sp, msg.into(), |diag| { cx.span_lint(lint, sp, |diag| {
diag.primary_message(msg);
docs_link(diag, lint); docs_link(diag, lint);
}); });
} }
@ -109,7 +110,8 @@ pub fn span_lint_and_help<T: LintContext>(
help: impl Into<SubdiagMessage>, help: impl Into<SubdiagMessage>,
) { ) {
#[expect(clippy::disallowed_methods)] #[expect(clippy::disallowed_methods)]
cx.span_lint(lint, span, msg.into(), |diag| { cx.span_lint(lint, span, |diag| {
diag.primary_message(msg);
if let Some(help_span) = help_span { if let Some(help_span) = help_span {
diag.span_help(help_span, help.into()); diag.span_help(help_span, help.into());
} else { } else {
@ -165,7 +167,8 @@ pub fn span_lint_and_note<T: LintContext>(
note: impl Into<SubdiagMessage>, note: impl Into<SubdiagMessage>,
) { ) {
#[expect(clippy::disallowed_methods)] #[expect(clippy::disallowed_methods)]
cx.span_lint(lint, span, msg.into(), |diag| { cx.span_lint(lint, span, |diag| {
diag.primary_message(msg);
if let Some(note_span) = note_span { if let Some(note_span) = note_span {
diag.span_note(note_span, note.into()); diag.span_note(note_span, note.into());
} else { } else {
@ -201,7 +204,8 @@ where
F: FnOnce(&mut Diag<'_, ()>), F: FnOnce(&mut Diag<'_, ()>),
{ {
#[expect(clippy::disallowed_methods)] #[expect(clippy::disallowed_methods)]
cx.span_lint(lint, sp, msg, |diag| { cx.span_lint(lint, sp, |diag| {
diag.primary_message(msg);
f(diag); f(diag);
docs_link(diag, lint); docs_link(diag, lint);
}); });
@ -233,7 +237,8 @@ where
/// the `#[allow]` will work. /// the `#[allow]` will work.
pub fn span_lint_hir(cx: &LateContext<'_>, lint: &'static Lint, hir_id: HirId, sp: Span, msg: impl Into<DiagMessage>) { pub fn span_lint_hir(cx: &LateContext<'_>, lint: &'static Lint, hir_id: HirId, sp: Span, msg: impl Into<DiagMessage>) {
#[expect(clippy::disallowed_methods)] #[expect(clippy::disallowed_methods)]
cx.tcx.node_span_lint(lint, hir_id, sp, msg.into(), |diag| { cx.tcx.node_span_lint(lint, hir_id, sp, |diag| {
diag.primary_message(msg);
docs_link(diag, lint); docs_link(diag, lint);
}); });
} }
@ -271,7 +276,8 @@ pub fn span_lint_hir_and_then(
f: impl FnOnce(&mut Diag<'_, ()>), f: impl FnOnce(&mut Diag<'_, ()>),
) { ) {
#[expect(clippy::disallowed_methods)] #[expect(clippy::disallowed_methods)]
cx.tcx.node_span_lint(lint, hir_id, sp, msg.into(), |diag| { cx.tcx.node_span_lint(lint, hir_id, sp, |diag| {
diag.primary_message(msg);
f(diag); f(diag);
docs_link(diag, lint); docs_link(diag, lint);
}); });

8
clippy_utils/src/hir_utils.rs
View file

@ -295,7 +295,7 @@ impl HirEqInterExpr<'_, '_, '_> {
self.eq_expr(lx, rx) && self.eq_ty(lt, rt) self.eq_expr(lx, rx) && self.eq_ty(lt, rt)
}, },
(&ExprKind::Closure(_l), &ExprKind::Closure(_r)) => false, (&ExprKind::Closure(_l), &ExprKind::Closure(_r)) => false,
(&ExprKind::ConstBlock(lb), &ExprKind::ConstBlock(rb)) => self.eq_body(lb.body, rb.body), (&ExprKind::ConstBlock(lb), &ExprKind::ConstBlock(rb)) => self.eq_expr(lb, rb),
(&ExprKind::Continue(li), &ExprKind::Continue(ri)) => { (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => {
both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name) both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
}, },
@ -769,8 +769,8 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
// closures inherit TypeckResults // closures inherit TypeckResults
self.hash_expr(self.cx.tcx.hir().body(body).value); self.hash_expr(self.cx.tcx.hir().body(body).value);
}, },
ExprKind::ConstBlock(ref l_id) => { ExprKind::ConstBlock(l_id) => {
self.hash_body(l_id.body); self.hash_expr(l_id);
}, },
ExprKind::DropTemps(e) | ExprKind::Yield(e, _) => { ExprKind::DropTemps(e) | ExprKind::Yield(e, _) => {
self.hash_expr(e); self.hash_expr(e);
@ -1082,7 +1082,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
mut_ty.mutbl.hash(&mut self.s); mut_ty.mutbl.hash(&mut self.s);
}, },
TyKind::BareFn(bfn) => { TyKind::BareFn(bfn) => {
bfn.unsafety.hash(&mut self.s); bfn.safety.hash(&mut self.s);
bfn.abi.hash(&mut self.s); bfn.abi.hash(&mut self.s);
for arg in bfn.decl.inputs { for arg in bfn.decl.inputs {
self.hash_ty(arg); self.hash_ty(arg);

2
clippy_utils/src/lib.rs
View file

@ -647,7 +647,7 @@ fn item_children_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: Symbol) -> Vec<Re
/// This function is expensive and should be used sparingly. /// This function is expensive and should be used sparingly.
pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Vec<Res> { pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Vec<Res> {
fn find_crates(tcx: TyCtxt<'_>, name: Symbol) -> impl Iterator<Item = DefId> + '_ { fn find_crates(tcx: TyCtxt<'_>, name: Symbol) -> impl Iterator<Item = DefId> + '_ {
tcx.crates(()) tcx.crates_including_speculative(())
.iter() .iter()
.copied() .copied()
.filter(move |&num| tcx.crate_name(num) == name) .filter(move |&num| tcx.crate_name(num) == name)

4
clippy_utils/src/mir/possible_borrower.rs
View file

@ -149,7 +149,7 @@ impl TypeVisitor<TyCtxt<'_>> for ContainsRegion {
} }
fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) { fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
use rustc_middle::mir::Rvalue::{Aggregate, BinaryOp, Cast, CheckedBinaryOp, Repeat, UnaryOp, Use}; use rustc_middle::mir::Rvalue::{Aggregate, BinaryOp, Cast, Repeat, UnaryOp, Use};
let mut visit_op = |op: &mir::Operand<'_>| match op { let mut visit_op = |op: &mir::Operand<'_>| match op {
mir::Operand::Copy(p) | mir::Operand::Move(p) => visit(p.local), mir::Operand::Copy(p) | mir::Operand::Move(p) => visit(p.local),
@ -159,7 +159,7 @@ fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
match rvalue { match rvalue {
Use(op) | Repeat(op, _) | Cast(_, op, _) | UnaryOp(_, op) => visit_op(op), Use(op) | Repeat(op, _) | Cast(_, op, _) | UnaryOp(_, op) => visit_op(op),
Aggregate(_, ops) => ops.iter().for_each(visit_op), Aggregate(_, ops) => ops.iter().for_each(visit_op),
BinaryOp(_, box (lhs, rhs)) | CheckedBinaryOp(_, box (lhs, rhs)) => { BinaryOp(_, box (lhs, rhs)) => {
visit_op(lhs); visit_op(lhs);
visit_op(rhs); visit_op(rhs);
}, },

4
clippy_utils/src/qualify_min_const_fn.rs
View file

@ -6,7 +6,7 @@
use clippy_config::msrvs::{self, Msrv}; use clippy_config::msrvs::{self, Msrv};
use hir::LangItem; use hir::LangItem;
use rustc_attr::StableSince; use rustc_attr::StableSince;
use rustc_const_eval::transform::check_consts::ConstCx; use rustc_const_eval::check_consts::ConstCx;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::def_id::DefId; use rustc_hir::def_id::DefId;
use rustc_infer::infer::TyCtxtInferExt; use rustc_infer::infer::TyCtxtInferExt;
@ -160,7 +160,7 @@ fn check_rvalue<'tcx>(
"transmute can attempt to turn pointers into integers, so is unstable in const fn".into(), "transmute can attempt to turn pointers into integers, so is unstable in const fn".into(),
)), )),
// binops are fine on integers // binops are fine on integers
Rvalue::BinaryOp(_, box (lhs, rhs)) | Rvalue::CheckedBinaryOp(_, box (lhs, rhs)) => { Rvalue::BinaryOp(_, box (lhs, rhs)) => {
check_operand(tcx, lhs, span, body, msrv)?; check_operand(tcx, lhs, span, body, msrv)?;
check_operand(tcx, rhs, span, body, msrv)?; check_operand(tcx, rhs, span, body, msrv)?;
let ty = lhs.ty(body, tcx); let ty = lhs.ty(body, tcx);

10
clippy_utils/src/ty.rs
View file

@ -9,7 +9,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res}; use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
use rustc_hir::def_id::DefId; use rustc_hir::def_id::DefId;
use rustc_hir::{Expr, FnDecl, LangItem, TyKind, Unsafety}; use rustc_hir::{Expr, FnDecl, LangItem, Safety, TyKind};
use rustc_infer::infer::TyCtxtInferExt; use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::mir::interpret::Scalar; use rustc_middle::mir::interpret::Scalar;
@ -18,8 +18,8 @@ use rustc_middle::traits::EvaluationResult;
use rustc_middle::ty::layout::ValidityRequirement; use rustc_middle::ty::layout::ValidityRequirement;
use rustc_middle::ty::{ use rustc_middle::ty::{
self, AdtDef, AliasTy, AssocKind, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef, self, AdtDef, AliasTy, AssocKind, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
GenericParamDefKind, IntTy, ParamEnv, Region, RegionKind, ToPredicate, TraitRef, Ty, TyCtxt, TypeSuperVisitable, GenericParamDefKind, IntTy, ParamEnv, Region, RegionKind, TraitRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
TypeVisitable, TypeVisitableExt, TypeVisitor, UintTy, VariantDef, VariantDiscr, TypeVisitableExt, TypeVisitor, UintTy, Upcast, VariantDef, VariantDiscr,
}; };
use rustc_span::symbol::Ident; use rustc_span::symbol::Ident;
use rustc_span::{sym, Span, Symbol, DUMMY_SP}; use rustc_span::{sym, Span, Symbol, DUMMY_SP};
@ -307,7 +307,7 @@ pub fn implements_trait_with_env_from_iter<'tcx>(
cause: ObligationCause::dummy(), cause: ObligationCause::dummy(),
param_env, param_env,
recursion_depth: 0, recursion_depth: 0,
predicate: Binder::dummy(trait_ref).to_predicate(tcx), predicate: trait_ref.upcast(tcx),
}; };
infcx infcx
.evaluate_obligation(&obligation) .evaluate_obligation(&obligation)
@ -558,7 +558,7 @@ pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
/// Returns `true` if the given type is an `unsafe` function. /// Returns `true` if the given type is an `unsafe` function.
pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool { pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
match ty.kind() { match ty.kind() {
ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe, ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).safety() == Safety::Unsafe,
_ => false, _ => false,
} }
} }

2
clippy_utils/src/ty/type_certainty/mod.rs
View file

@ -176,7 +176,7 @@ fn qpath_certainty(cx: &LateContext<'_>, qpath: &QPath<'_>, resolves_to_type: bo
.get(*lang_item) .get(*lang_item)
.map_or(Certainty::Uncertain, |def_id| { .map_or(Certainty::Uncertain, |def_id| {
let generics = cx.tcx.generics_of(def_id); let generics = cx.tcx.generics_of(def_id);
if generics.parent_count == 0 && generics.own_params.is_empty() { if generics.is_empty() {
Certainty::Certain(if resolves_to_type { Some(def_id) } else { None }) Certainty::Certain(if resolves_to_type { Some(def_id) } else { None })
} else { } else {
Certainty::Uncertain Certainty::Uncertain

10
clippy_utils/src/visitors.rs
View file

@ -6,7 +6,7 @@ use rustc_hir::def::{CtorKind, DefKind, Res};
use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor}; use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor};
use rustc_hir::{ use rustc_hir::{
AnonConst, Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, LetExpr, Pat, QPath, AnonConst, Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, LetExpr, Pat, QPath,
Stmt, UnOp, UnsafeSource, Unsafety, Safety, Stmt, UnOp, UnsafeSource,
}; };
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::hir::nested_filter; use rustc_middle::hir::nested_filter;
@ -421,16 +421,16 @@ pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
.typeck_results() .typeck_results()
.type_dependent_def_id(e.hir_id) .type_dependent_def_id(e.hir_id)
.map_or(false, |id| { .map_or(false, |id| {
self.cx.tcx.fn_sig(id).skip_binder().unsafety() == Unsafety::Unsafe self.cx.tcx.fn_sig(id).skip_binder().safety() == Safety::Unsafe
}) => }) =>
{ {
self.is_unsafe = true; self.is_unsafe = true;
}, },
ExprKind::Call(func, _) => match *self.cx.typeck_results().expr_ty(func).peel_refs().kind() { ExprKind::Call(func, _) => match *self.cx.typeck_results().expr_ty(func).peel_refs().kind() {
ty::FnDef(id, _) if self.cx.tcx.fn_sig(id).skip_binder().unsafety() == Unsafety::Unsafe => { ty::FnDef(id, _) if self.cx.tcx.fn_sig(id).skip_binder().safety() == Safety::Unsafe => {
self.is_unsafe = true; self.is_unsafe = true;
}, },
ty::FnPtr(sig) if sig.unsafety() == Unsafety::Unsafe => self.is_unsafe = true, ty::FnPtr(sig) if sig.safety() == Safety::Unsafe => self.is_unsafe = true,
_ => walk_expr(self, e), _ => walk_expr(self, e),
}, },
ExprKind::Path(ref p) ExprKind::Path(ref p)
@ -452,7 +452,7 @@ pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
} }
fn visit_nested_item(&mut self, id: ItemId) { fn visit_nested_item(&mut self, id: ItemId) {
if let ItemKind::Impl(i) = &self.cx.tcx.hir().item(id).kind { if let ItemKind::Impl(i) = &self.cx.tcx.hir().item(id).kind {
self.is_unsafe = i.unsafety == Unsafety::Unsafe; self.is_unsafe = i.safety == Safety::Unsafe;
} }
} }
} }

2
rust-toolchain
View file

@ -1,3 +1,3 @@
[toolchain] [toolchain]
channel = "nightly-2024-05-16" channel = "nightly-2024-05-30"
components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"] components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]

1
src/driver.rs
View file

@ -2,7 +2,6 @@
#![allow(rustc::untranslatable_diagnostic)] #![allow(rustc::untranslatable_diagnostic)]
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(let_chains)] #![feature(let_chains)]
#![feature(lazy_cell)]
#![feature(lint_reasons)] #![feature(lint_reasons)]
#![cfg_attr(feature = "deny-warnings", deny(warnings))] #![cfg_attr(feature = "deny-warnings", deny(warnings))]
// warn on lints, that are included in `rust-lang/rust`s bootstrap // warn on lints, that are included in `rust-lang/rust`s bootstrap

1
tests/compile-test.rs
View file

@ -1,4 +1,3 @@
#![feature(lazy_cell)]
#![feature(is_sorted)] #![feature(is_sorted)]
#![cfg_attr(feature = "deny-warnings", deny(warnings))] #![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)] #![warn(rust_2018_idioms, unused_lifetimes)]

1
tests/dogfood.rs
View file

@ -3,7 +3,6 @@
//! //!
//! See [Eating your own dog food](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) for context //! See [Eating your own dog food](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) for context
#![feature(lazy_cell)]
#![cfg_attr(feature = "deny-warnings", deny(warnings))] #![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)] #![warn(rust_2018_idioms, unused_lifetimes)]

1
tests/lint_message_convention.rs
View file

@ -1,4 +1,3 @@
#![feature(lazy_cell)]
#![cfg_attr(feature = "deny-warnings", deny(warnings))] #![cfg_attr(feature = "deny-warnings", deny(warnings))]
#![warn(rust_2018_idioms, unused_lifetimes)] #![warn(rust_2018_idioms, unused_lifetimes)]

8
tests/ui-internal/disallow_span_lint.rs
View file

@ -11,11 +11,15 @@ use rustc_lint::{Lint, LintContext};
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
pub fn a(cx: impl LintContext, lint: &'static Lint, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) { pub fn a(cx: impl LintContext, lint: &'static Lint, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
cx.span_lint(lint, span, msg, |_| {}); cx.span_lint(lint, span, |lint| {
lint.primary_message(msg);
});
} }
pub fn b(tcx: TyCtxt<'_>, lint: &'static Lint, hir_id: HirId, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) { pub fn b(tcx: TyCtxt<'_>, lint: &'static Lint, hir_id: HirId, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
tcx.node_span_lint(lint, hir_id, span, msg, |_| {}); tcx.node_span_lint(lint, hir_id, span, |lint| {
lint.primary_message(msg);
});
} }
fn main() {} fn main() {}

14
tests/ui-internal/disallow_span_lint.stderr
View file

@ -1,18 +1,22 @@
error: use of a disallowed method `rustc_lint::context::LintContext::span_lint` error: use of a disallowed method `rustc_lint::context::LintContext::span_lint`
--> tests/ui-internal/disallow_span_lint.rs:14:5 --> tests/ui-internal/disallow_span_lint.rs:14:5
| |
LL | cx.span_lint(lint, span, msg, |_| {}); LL | / cx.span_lint(lint, span, |lint| {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ LL | | lint.primary_message(msg);
LL | | });
| |______^
| |
= note: this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint*` functions instead (from clippy.toml) = note: this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint*` functions instead (from clippy.toml)
= note: `-D clippy::disallowed-methods` implied by `-D warnings` = note: `-D clippy::disallowed-methods` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::disallowed_methods)]` = help: to override `-D warnings` add `#[allow(clippy::disallowed_methods)]`
error: use of a disallowed method `rustc_middle::ty::context::TyCtxt::node_span_lint` error: use of a disallowed method `rustc_middle::ty::context::TyCtxt::node_span_lint`
--> tests/ui-internal/disallow_span_lint.rs:18:5 --> tests/ui-internal/disallow_span_lint.rs:20:5
| |
LL | tcx.node_span_lint(lint, hir_id, span, msg, |_| {}); LL | / tcx.node_span_lint(lint, hir_id, span, |lint| {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ LL | | lint.primary_message(msg);
LL | | });
| |______^
| |
= note: this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead (from clippy.toml) = note: this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead (from clippy.toml)

32
tests/ui/arithmetic_side_effects.stderr
View file

@ -1,11 +1,35 @@
error: arithmetic operation that can potentially result in unexpected side-effects
--> tests/ui/arithmetic_side_effects.rs:188:36
|
LL | let _ = const { let mut n = 1; n += 1; n };
| ^^^^^^
|
= note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::arithmetic_side_effects)]`
error: arithmetic operation that can potentially result in unexpected side-effects
--> tests/ui/arithmetic_side_effects.rs:191:40
|
LL | let _ = const { let mut n = 1; n = n + 1; n };
| ^^^^^
error: arithmetic operation that can potentially result in unexpected side-effects
--> tests/ui/arithmetic_side_effects.rs:194:40
|
LL | let _ = const { let mut n = 1; n = 1 + n; n };
| ^^^^^
error: arithmetic operation that can potentially result in unexpected side-effects
--> tests/ui/arithmetic_side_effects.rs:200:59
|
LL | let _ = const { let mut n = 1; n = -1; n = -(-1); n = -n; n };
| ^^
error: arithmetic operation that can potentially result in unexpected side-effects error: arithmetic operation that can potentially result in unexpected side-effects
--> tests/ui/arithmetic_side_effects.rs:304:5 --> tests/ui/arithmetic_side_effects.rs:304:5
| |
LL | _n += 1; LL | _n += 1;
| ^^^^^^^ | ^^^^^^^
|
= note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::arithmetic_side_effects)]`
error: arithmetic operation that can potentially result in unexpected side-effects error: arithmetic operation that can potentially result in unexpected side-effects
--> tests/ui/arithmetic_side_effects.rs:305:5 --> tests/ui/arithmetic_side_effects.rs:305:5
@ -727,5 +751,5 @@ error: arithmetic operation that can potentially result in unexpected side-effec
LL | one.sub_assign(1); LL | one.sub_assign(1);
| ^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^
error: aborting due to 121 previous errors error: aborting due to 125 previous errors

1
tests/ui/into_iter_on_ref.fixed
View file

@ -11,7 +11,6 @@ fn main() {
let _ = vec![1, 2, 3].into_iter(); let _ = vec![1, 2, 3].into_iter();
let _ = (&vec![1, 2, 3]).iter(); //~ ERROR: equivalent to `.iter() let _ = (&vec![1, 2, 3]).iter(); //~ ERROR: equivalent to `.iter()
let _ = vec![1, 2, 3].into_boxed_slice().iter(); //~ ERROR: equivalent to `.iter()
let _ = std::rc::Rc::from(&[X][..]).iter(); //~ ERROR: equivalent to `.iter() let _ = std::rc::Rc::from(&[X][..]).iter(); //~ ERROR: equivalent to `.iter()
let _ = std::sync::Arc::from(&[X][..]).iter(); //~ ERROR: equivalent to `.iter() let _ = std::sync::Arc::from(&[X][..]).iter(); //~ ERROR: equivalent to `.iter()

1
tests/ui/into_iter_on_ref.rs
View file

@ -11,7 +11,6 @@ fn main() {
let _ = vec![1, 2, 3].into_iter(); let _ = vec![1, 2, 3].into_iter();
let _ = (&vec![1, 2, 3]).into_iter(); //~ ERROR: equivalent to `.iter() let _ = (&vec![1, 2, 3]).into_iter(); //~ ERROR: equivalent to `.iter()
let _ = vec![1, 2, 3].into_boxed_slice().into_iter(); //~ ERROR: equivalent to `.iter()
let _ = std::rc::Rc::from(&[X][..]).into_iter(); //~ ERROR: equivalent to `.iter() let _ = std::rc::Rc::from(&[X][..]).into_iter(); //~ ERROR: equivalent to `.iter()
let _ = std::sync::Arc::from(&[X][..]).into_iter(); //~ ERROR: equivalent to `.iter() let _ = std::sync::Arc::from(&[X][..]).into_iter(); //~ ERROR: equivalent to `.iter()

58
tests/ui/into_iter_on_ref.stderr
View file

@ -8,160 +8,154 @@ LL | let _ = (&vec![1, 2, 3]).into_iter();
= help: to override `-D warnings` add `#[allow(clippy::into_iter_on_ref)]` = help: to override `-D warnings` add `#[allow(clippy::into_iter_on_ref)]`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
--> tests/ui/into_iter_on_ref.rs:14:46 --> tests/ui/into_iter_on_ref.rs:14:41
|
LL | let _ = vec![1, 2, 3].into_boxed_slice().into_iter();
| ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
--> tests/ui/into_iter_on_ref.rs:15:41
| |
LL | let _ = std::rc::Rc::from(&[X][..]).into_iter(); LL | let _ = std::rc::Rc::from(&[X][..]).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
--> tests/ui/into_iter_on_ref.rs:16:44 --> tests/ui/into_iter_on_ref.rs:15:44
| |
LL | let _ = std::sync::Arc::from(&[X][..]).into_iter(); LL | let _ = std::sync::Arc::from(&[X][..]).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
--> tests/ui/into_iter_on_ref.rs:18:32 --> tests/ui/into_iter_on_ref.rs:17:32
| |
LL | let _ = (&&&&&&&[1, 2, 3]).into_iter(); LL | let _ = (&&&&&&&[1, 2, 3]).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
--> tests/ui/into_iter_on_ref.rs:19:36 --> tests/ui/into_iter_on_ref.rs:18:36
| |
LL | let _ = (&&&&mut &&&[1, 2, 3]).into_iter(); LL | let _ = (&&&&mut &&&[1, 2, 3]).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `array` error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `array`
--> tests/ui/into_iter_on_ref.rs:20:40 --> tests/ui/into_iter_on_ref.rs:19:40
| |
LL | let _ = (&mut &mut &mut [1, 2, 3]).into_iter(); LL | let _ = (&mut &mut &mut [1, 2, 3]).into_iter();
| ^^^^^^^^^ help: call directly: `iter_mut` | ^^^^^^^^^ help: call directly: `iter_mut`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Option` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Option`
--> tests/ui/into_iter_on_ref.rs:22:24 --> tests/ui/into_iter_on_ref.rs:21:24
| |
LL | let _ = (&Some(4)).into_iter(); LL | let _ = (&Some(4)).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Option` error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Option`
--> tests/ui/into_iter_on_ref.rs:23:28 --> tests/ui/into_iter_on_ref.rs:22:28
| |
LL | let _ = (&mut Some(5)).into_iter(); LL | let _ = (&mut Some(5)).into_iter();
| ^^^^^^^^^ help: call directly: `iter_mut` | ^^^^^^^^^ help: call directly: `iter_mut`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Result` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Result`
--> tests/ui/into_iter_on_ref.rs:24:32 --> tests/ui/into_iter_on_ref.rs:23:32
| |
LL | let _ = (&Ok::<_, i32>(6)).into_iter(); LL | let _ = (&Ok::<_, i32>(6)).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Result` error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Result`
--> tests/ui/into_iter_on_ref.rs:25:37 --> tests/ui/into_iter_on_ref.rs:24:37
| |
LL | let _ = (&mut Err::<i32, _>(7)).into_iter(); LL | let _ = (&mut Err::<i32, _>(7)).into_iter();
| ^^^^^^^^^ help: call directly: `iter_mut` | ^^^^^^^^^ help: call directly: `iter_mut`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Vec` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Vec`
--> tests/ui/into_iter_on_ref.rs:26:34 --> tests/ui/into_iter_on_ref.rs:25:34
| |
LL | let _ = (&Vec::<i32>::new()).into_iter(); LL | let _ = (&Vec::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Vec` error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Vec`
--> tests/ui/into_iter_on_ref.rs:27:38 --> tests/ui/into_iter_on_ref.rs:26:38
| |
LL | let _ = (&mut Vec::<i32>::new()).into_iter(); LL | let _ = (&mut Vec::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter_mut` | ^^^^^^^^^ help: call directly: `iter_mut`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BTreeMap` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BTreeMap`
--> tests/ui/into_iter_on_ref.rs:28:44 --> tests/ui/into_iter_on_ref.rs:27:44
| |
LL | let _ = (&BTreeMap::<i32, u64>::new()).into_iter(); LL | let _ = (&BTreeMap::<i32, u64>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `BTreeMap` error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `BTreeMap`
--> tests/ui/into_iter_on_ref.rs:29:48 --> tests/ui/into_iter_on_ref.rs:28:48
| |
LL | let _ = (&mut BTreeMap::<i32, u64>::new()).into_iter(); LL | let _ = (&mut BTreeMap::<i32, u64>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter_mut` | ^^^^^^^^^ help: call directly: `iter_mut`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `VecDeque` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `VecDeque`
--> tests/ui/into_iter_on_ref.rs:30:39 --> tests/ui/into_iter_on_ref.rs:29:39
| |
LL | let _ = (&VecDeque::<i32>::new()).into_iter(); LL | let _ = (&VecDeque::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `VecDeque` error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `VecDeque`
--> tests/ui/into_iter_on_ref.rs:31:43 --> tests/ui/into_iter_on_ref.rs:30:43
| |
LL | let _ = (&mut VecDeque::<i32>::new()).into_iter(); LL | let _ = (&mut VecDeque::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter_mut` | ^^^^^^^^^ help: call directly: `iter_mut`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `LinkedList` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `LinkedList`
--> tests/ui/into_iter_on_ref.rs:32:41 --> tests/ui/into_iter_on_ref.rs:31:41
| |
LL | let _ = (&LinkedList::<i32>::new()).into_iter(); LL | let _ = (&LinkedList::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `LinkedList` error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `LinkedList`
--> tests/ui/into_iter_on_ref.rs:33:45 --> tests/ui/into_iter_on_ref.rs:32:45
| |
LL | let _ = (&mut LinkedList::<i32>::new()).into_iter(); LL | let _ = (&mut LinkedList::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter_mut` | ^^^^^^^^^ help: call directly: `iter_mut`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `HashMap` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `HashMap`
--> tests/ui/into_iter_on_ref.rs:34:43 --> tests/ui/into_iter_on_ref.rs:33:43
| |
LL | let _ = (&HashMap::<i32, u64>::new()).into_iter(); LL | let _ = (&HashMap::<i32, u64>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `HashMap` error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `HashMap`
--> tests/ui/into_iter_on_ref.rs:35:47 --> tests/ui/into_iter_on_ref.rs:34:47
| |
LL | let _ = (&mut HashMap::<i32, u64>::new()).into_iter(); LL | let _ = (&mut HashMap::<i32, u64>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter_mut` | ^^^^^^^^^ help: call directly: `iter_mut`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BTreeSet` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BTreeSet`
--> tests/ui/into_iter_on_ref.rs:37:39 --> tests/ui/into_iter_on_ref.rs:36:39
| |
LL | let _ = (&BTreeSet::<i32>::new()).into_iter(); LL | let _ = (&BTreeSet::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BinaryHeap` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BinaryHeap`
--> tests/ui/into_iter_on_ref.rs:38:41 --> tests/ui/into_iter_on_ref.rs:37:41
| |
LL | let _ = (&BinaryHeap::<i32>::new()).into_iter(); LL | let _ = (&BinaryHeap::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `HashSet` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `HashSet`
--> tests/ui/into_iter_on_ref.rs:39:38 --> tests/ui/into_iter_on_ref.rs:38:38
| |
LL | let _ = (&HashSet::<i32>::new()).into_iter(); LL | let _ = (&HashSet::<i32>::new()).into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Path` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Path`
--> tests/ui/into_iter_on_ref.rs:40:43 --> tests/ui/into_iter_on_ref.rs:39:43
| |
LL | let _ = std::path::Path::new("12/34").into_iter(); LL | let _ = std::path::Path::new("12/34").into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `PathBuf` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `PathBuf`
--> tests/ui/into_iter_on_ref.rs:41:47 --> tests/ui/into_iter_on_ref.rs:40:47
| |
LL | let _ = std::path::PathBuf::from("12/34").into_iter(); LL | let _ = std::path::PathBuf::from("12/34").into_iter();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array` error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
--> tests/ui/into_iter_on_ref.rs:43:26 --> tests/ui/into_iter_on_ref.rs:42:26
| |
LL | let _ = (&[1, 2, 3]).into_iter().next(); LL | let _ = (&[1, 2, 3]).into_iter().next();
| ^^^^^^^^^ help: call directly: `iter` | ^^^^^^^^^ help: call directly: `iter`
error: aborting due to 27 previous errors error: aborting due to 26 previous errors

2
tests/ui/ptr_arg.rs
View file

@ -282,7 +282,7 @@ mod issue_9218 {
todo!() todo!()
} }
// These two's return types don't use use 'a so it's not okay // These two's return types don't use 'a so it's not okay
fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str { fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str {
//~^ ERROR: using a reference to `Cow` is not recommended //~^ ERROR: using a reference to `Cow` is not recommended
todo!() todo!()

2
tests/workspace.rs
View file

@ -1,5 +1,3 @@
#![feature(lazy_cell)]
use std::path::PathBuf; use std::path::PathBuf;
use std::process::Command; use std::process::Command;
use test_utils::{CARGO_CLIPPY_PATH, IS_RUSTC_TEST_SUITE}; use test_utils::{CARGO_CLIPPY_PATH, IS_RUSTC_TEST_SUITE};