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

Rename Unsafe to Safety

Browse source
This commit is contained in:
Santiago Pastorino 2024-05-17 14:17:48 -03:00
parent 2701a4175f
commit 0590d71ce2
17 changed files with 57 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
clippy_lints/src/derive.rs
View file

@ -5,7 +5,7 @@ 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, Safety, Impl, Item, ItemKind, UnsafeSource,
}; };
use rustc_lint::{LateContext, LateLintPass}; use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::hir::nested_filter; use rustc_middle::hir::nested_filter;
@ -415,7 +415,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;
} }

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

@ -1,7 +1,7 @@
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};
@ -33,14 +33,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

@ -12,7 +12,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;
@ -415,13 +415,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, Safety, ImplicitSelfKind};
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

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

@ -5038,7 +5038,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,
@ -5214,7 +5214,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
} }

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, Safety, QPath, 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;
} }

4
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};
@ -542,7 +542,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(

4
clippy_lints/src/undocumented_unsafe_blocks.rs
View file

@ -200,7 +200,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)
{ {
@ -222,7 +222,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")

2
clippy_utils/src/hir_utils.rs
View file

@ -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);

4
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, Safety, LangItem, 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;
@ -562,7 +562,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,
} }
} }

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;
} }
} }
} }